2000-06-23 Gerd Moellmann <gerd@gnu.org>
+ * Makefile.in (DONTCOMPILE): Add eshell/esh-maint.el.
+
+ * eshell/esh-cmd.el (eshell-rewrite-for-command): Use cdr and
+ cddr instead of cdddr.
+
* eshell/esh-util.el (eshell-sublist): Use eshell-copy-list
instead of copy-list.
--- /dev/null
+;;; em-alias --- creation and management of command aliases
+
+;; Copyright (C) 1999, 2000 Free Sofware Foundation
+
+;; 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 2, 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+(provide 'em-alias)
+
+(eval-when-compile (require 'esh-maint))
+
+(defgroup eshell-alias nil
+ "Command aliases allow for easy definition of alternate commands."
+ :tag "Command aliases"
+ :link '(info-link "(eshell.info)Command aliases")
+ :group 'eshell-module)
+
+;;; Commentary:
+
+;; Command aliases greatly simplify the definition of new commands.
+;; They exist as an alternative to alias functions, which are
+;; otherwise quite superior, being more flexible and natural to the
+;; Emacs Lisp environment (if somewhat trickier to define; [Alias
+;; functions]).
+;;
+;;;_* Creating aliases
+;;
+;; The user interface is simple: type 'alias' followed by the command
+;; name followed by the definition. Argument references are made
+;; using '$1', '$2', etc., or '$*'. For example:
+;;
+;; alias ll 'ls -l $*'
+;;
+;; This will cause the command 'll NEWS' to be replaced by 'ls -l
+;; NEWS'. This is then passed back to the command parser for
+;; reparsing.{Only the command text specified in the alias definition
+;; will be reparsed. Argument references (such as '$*') are handled
+;; using variable values, which means that the expansion will not be
+;; reparsed, but used directly.}
+;;
+;; To delete an alias, specify its name without a definition:
+;;
+;; alias ll
+;;
+;; Aliases are written to disk immediately after being defined or
+;; deleted. The filename in which they are kept is defined by the
+;; following variable:
+
+(defcustom eshell-aliases-file (concat eshell-directory-name "alias")
+ "*The file in which aliases are kept.
+Whenever an alias is defined by the user, using the `alias' command,
+it will be written to this file. Thus, alias definitions (and
+deletions) are always permanent. This approach was chosen for the
+sake of simplicity, since that's pretty much the only benefit to be
+gained by using this module."
+ :type 'file
+ :group 'eshell-alias)
+
+;;;
+;; The format of this file is quite basic. It specifies the alias
+;; definitions in almost exactly the same way that the user entered
+;; them, minus any argument quoting (since interpolation is not done
+;; when the file is read). Hence, it is possible to add new aliases
+;; to the alias file directly, using a text editor rather than the
+;; `alias' command. Or, this method can be used for editing aliases
+;; that have already defined.
+;;
+;; Here is an example of a few different aliases, and they would
+;; appear in the aliases file:
+;;
+;; alias clean rm -fr **/.#*~
+;; alias commit cvs commit -m changes $*
+;; alias ll ls -l $*
+;; alias info (info)
+;; alias reindex glimpseindex -o ~/Mail
+;; alias compact for i in ~/Mail/**/*~*.bz2(Lk+50) { bzip2 -9v $i }
+;;
+;;;_* Auto-correction of bad commands
+;;
+;; When a user enters the same unknown command many times during a
+;; session, it is likely that they are experiencing a spelling
+;; difficulty associated with a certain command. To combat this,
+;; Eshell will offer to automatically define an alias for that
+;; mispelled command, once a given tolerance threshold has been
+;; reached.
+
+(defcustom eshell-bad-command-tolerance 3
+ "*The number of failed commands to ignore before creating an alias."
+ :type 'integer
+ :link '(custom-manual "(eshell.info)Auto-correction of bad commands")
+ :group 'eshell-alias)
+
+;;;
+;; Whenever the same bad command name is encountered this many times,
+;; the user will be prompted in the minibuffer to provide an alias
+;; name. An alias definition will then be created which will result
+;; in an equal call to the correct name. In this way, Eshell
+;; gradually learns about the commands that the user mistypes
+;; frequently, and will automatically correct them!
+;;
+;; Note that a '$*' is automatically appended at the end of the alias
+;; definition, so that entering it is unnecessary when specifying the
+;; corrected command name.
+
+;;; Code:
+
+(defcustom eshell-alias-load-hook '(eshell-alias-initialize)
+ "*A hook that gets run when `eshell-alias' is loaded."
+ :type 'hook
+ :group 'eshell-alias)
+
+(defvar eshell-command-aliases-list nil
+ "A list of command aliases currently defined by the user.
+Each element of this alias is a list of the form:
+
+ (NAME DEFINITION)
+
+Where NAME is the textual name of the alias, and DEFINITION is the
+command string to replace that command with.
+
+Note: this list should not be modified in your '.emacs' file. Rather,
+any desired alias definitions should be declared using the `alias'
+command, which will automatically write them to the file named by
+`eshell-aliases-file'.")
+
+(put 'eshell-command-aliases-list 'risky-local-variable t)
+
+(defvar eshell-failed-commands-alist nil
+ "An alist of command name failures.")
+
+(defun eshell-alias-initialize ()
+ "Initialize the alias handling code."
+ (make-local-variable 'eshell-failed-commands-alist)
+ (make-local-hook 'eshell-alternate-command-hook)
+ (add-hook 'eshell-alternate-command-hook 'eshell-fix-bad-commands t t)
+ (eshell-read-aliases-list)
+ (make-local-hook 'eshell-named-command-hook)
+ (add-hook 'eshell-named-command-hook 'eshell-maybe-replace-by-alias t t))
+
+(defun eshell/alias (&optional alias &rest definition)
+ "Define an ALIAS in the user's alias list using DEFINITION."
+ (if (not alias)
+ (eshell-for alias eshell-command-aliases-list
+ (eshell-print (apply 'format "alias %s %s\n" alias)))
+ (if (not definition)
+ (setq eshell-command-aliases-list
+ (delq (assoc alias eshell-command-aliases-list)
+ eshell-command-aliases-list))
+ (and (stringp definition)
+ (set-text-properties 0 (length definition) nil definition))
+ (let ((def (assoc alias eshell-command-aliases-list))
+ (alias-def (list alias
+ (eshell-flatten-and-stringify definition))))
+ (if def
+ (setq eshell-command-aliases-list
+ (delq def eshell-command-aliases-list)))
+ (setq eshell-command-aliases-list
+ (cons alias-def eshell-command-aliases-list))))
+ (eshell-write-aliases-list))
+ nil)
+
+(defun pcomplete/eshell-mode/alias ()
+ "Completion function for Eshell's `alias' command."
+ (pcomplete-here (eshell-alias-completions pcomplete-stub)))
+
+(defun eshell-read-aliases-list ()
+ "Read in an aliases list from `eshell-aliases-file'."
+ (let ((file eshell-aliases-file))
+ (when (file-readable-p file)
+ (setq eshell-command-aliases-list
+ (with-temp-buffer
+ (let (eshell-command-aliases-list)
+ (insert-file-contents file)
+ (while (not (eobp))
+ (if (re-search-forward
+ "^alias\\s-+\\(\\S-+\\)\\s-+\\(.+\\)")
+ (setq eshell-command-aliases-list
+ (cons (list (match-string 1)
+ (match-string 2))
+ eshell-command-aliases-list)))
+ (forward-line 1))
+ eshell-command-aliases-list))))))
+
+(defun eshell-write-aliases-list ()
+ "Write out the current aliases into `eshell-aliases-file'."
+ (if (file-writable-p (file-name-directory eshell-aliases-file))
+ (let ((eshell-current-handles
+ (eshell-create-handles eshell-aliases-file 'overwrite)))
+ (eshell/alias)
+ (eshell-close-handles 0))))
+
+(defsubst eshell-lookup-alias (name)
+ "Check whether NAME is aliased. Return the alias if there is one."
+ (assoc name eshell-command-aliases-list))
+
+(defvar eshell-prevent-alias-expansion nil)
+
+(defun eshell-maybe-replace-by-alias (command args)
+ "If COMMAND has an alias definition, call that instead using RAGS."
+ (unless (and eshell-prevent-alias-expansion
+ (member command eshell-prevent-alias-expansion))
+ (let ((alias (eshell-lookup-alias command)))
+ (if alias
+ (throw 'eshell-replace-command
+ (list
+ 'let
+ (list
+ (list 'eshell-command-name
+ (list 'quote eshell-last-command-name))
+ (list 'eshell-command-arguments
+ (list 'quote eshell-last-arguments))
+ (list 'eshell-prevent-alias-expansion
+ (list 'quote
+ (cons command
+ eshell-prevent-alias-expansion))))
+ (eshell-parse-command (nth 1 alias))))))))
+
+(defun eshell-alias-completions (name)
+ "Find all possible completions for NAME.
+These are all the command aliases which begin with NAME."
+ (let (completions)
+ (eshell-for alias eshell-command-aliases-list
+ (if (string-match (concat "^" name) (car alias))
+ (setq completions (cons (car alias) completions))))
+ completions))
+
+(defun eshell-fix-bad-commands (name)
+ "If the user repeatedly a bad command NAME, make an alias for them."
+ (ignore
+ (unless (file-name-directory name)
+ (let ((entry (assoc name eshell-failed-commands-alist)))
+ (if (not entry)
+ (setq eshell-failed-commands-alist
+ (cons (cons name 1) eshell-failed-commands-alist))
+ (if (< (cdr entry) eshell-bad-command-tolerance)
+ (setcdr entry (1+ (cdr entry)))
+ (let ((alias (concat
+ (read-string
+ (format "Define alias for \"%s\": " name))
+ " $*")))
+ (eshell/alias name alias)
+ (throw 'eshell-replace-command
+ (list
+ 'let
+ (list
+ (list 'eshell-command-name
+ (list 'quote name))
+ (list 'eshell-command-arguments
+ (list 'quote eshell-last-arguments))
+ (list 'eshell-prevent-alias-expansion
+ (list 'quote
+ (cons name
+ eshell-prevent-alias-expansion))))
+ (eshell-parse-command alias))))))))))
+
+;;; em-alias.el ends here
--- /dev/null
+;;; em-banner --- sample module that displays a login banner
+
+;; Copyright (C) 1999, 2000 Free Sofware Foundation
+
+;; 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 2, 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+(provide 'em-banner)
+
+(eval-when-compile (require 'esh-maint))
+
+(defgroup eshell-banner nil
+ "This sample module displays a welcome banner at login.
+It exists so that others wishing to create their own Eshell extension
+modules may have a simple template to begin with."
+ :tag "Login banner"
+ :link '(info-link "(eshell.info)Login banner")
+ :group 'eshell-module)
+
+;;; Commentary:
+
+;; There is nothing to be done or configured in order to use this
+;; module, other than to select it by customizing the variable
+;; `eshell-modules-list'. It will then display a version information
+;; message whenever Eshell is loaded.
+;;
+;; This code is only an example of a how to write a well-formed
+;; extension module for Eshell. The better way to display login text
+;; is to use the `eshell-script' module, and to echo the desired
+;; strings from the user's `eshell-login-script' file.
+;;
+;; There is one configuration variable, which demonstrates how to
+;; properly define a customization variable in an extension module.
+;; In this case, it allows the user to change the string which
+;; displays at login time.
+
+;;; User Variables:
+
+(defcustom eshell-banner-message "Welcome to the Emacs shell\n\n"
+ "*The banner message to be displayed when Eshell is loaded.
+This can be any sexp, and should end with at least two newlines."
+ :type 'sexp
+ :group 'eshell-banner)
+
+(put 'eshell-banner-message 'risky-local-variable t)
+
+;;; Code:
+
+(require 'esh-util)
+
+(defcustom eshell-banner-load-hook '(eshell-banner-initialize)
+ "*A list of functions to run when `eshell-banner' is loaded."
+ :type 'hook
+ :group 'eshell-banner)
+
+(defun eshell-banner-initialize ()
+ "Output a welcome banner on initialization."
+ ;; it's important to use `eshell-interactive-print' rather than
+ ;; `insert', because `insert' doesn't know how to interact with the
+ ;; I/O code used by Eshell
+ (unless eshell-non-interactive-p
+ (assert eshell-mode)
+ (assert eshell-banner-message)
+ (let ((msg (eval eshell-banner-message)))
+ (assert msg)
+ (eshell-interactive-print msg))))
+
+(eshell-deftest banner banner-displayed
+ "Startup banner is displayed at point-min"
+ (assert eshell-banner-message)
+ (let ((msg (eval eshell-banner-message)))
+ (assert msg)
+ (goto-char (point-min))
+ (looking-at msg)))
+
+;;; em-banner.el ends here
--- /dev/null
+;;; em-basic --- basic shell builtin commands
+
+;; Copyright (C) 1999, 2000 Free Sofware Foundation
+
+;; 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 2, 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+(provide 'em-basic)
+
+(eval-when-compile (require 'esh-maint))
+
+(defgroup eshell-basic nil
+ "The \"basic\" code provides a set of convenience functions which
+are traditionally considered shell builtins. Since all of the
+functionality provided by them is accessible through Lisp, they are
+not really builtins at all, but offer a command-oriented way to do the
+same thing."
+ :tag "Basic shell commands"
+ :group 'eshell-module)
+
+;;; Commentary:
+
+;; There are very few basic Eshell commands -- so-called builtins.
+;; They are: echo, umask, and version.
+;;
+;;;_* `echo'
+;;
+;; The `echo' command repeats its arguments to the screen. It is
+;; optional whether this is done in a Lisp-friendly fashion (so that
+;; the value of echo is useful to a Lisp command using the result of
+;; echo as an argument), or whether it should try to act like a normal
+;; shell echo, and always result in a flat string being returned.
+
+(defcustom eshell-plain-echo-behavior nil
+ "*If non-nil, `echo' tries to behave like an ordinary shell echo.
+This comes at some detriment to Lisp functionality. However, the Lisp
+equivalent of `echo' can always be achieved by using `identity'."
+ :type 'boolean
+ :group 'eshell-basic)
+
+;;;
+;; An example of the difference is the following:
+;;
+;; echo Hello world
+;;
+;; If `eshell-plain-echo-behavior' is non-nil, this will yield the
+;; string "Hello world". If Lisp behavior is enabled, however, it
+;; will yield a list whose two elements are the strings "Hello" and
+;; "world". The way to write an equivalent expression for both would
+;; be:
+;;
+;; echo "Hello world"
+;;
+;; This always returns a single string.
+;;
+;;;_* `umask'
+;;
+;; The umask command changes the default file permissions for newly
+;; created files. It uses the same syntax as bash.
+;;
+;;;_* `version'
+;;
+;; This command reports the version number for Eshell and all its
+;; dependent module, including the date when those modules were last
+;; modified.
+
+;;; Code:
+
+(require 'esh-opt)
+
+;;; Functions:
+
+(defun eshell-echo (args &optional output-newline)
+ "Implementation code for a Lisp version of `echo'.
+It returns a formatted value that should be passed to `eshell-print'
+or `eshell-printn' for display."
+ (if eshell-plain-echo-behavior
+ (concat (apply 'eshell-flatten-and-stringify args) "\n")
+ (let ((value
+ (cond
+ ((= (length args) 0) "")
+ ((= (length args) 1)
+ (car args))
+ (t
+ (mapcar
+ (function
+ (lambda (arg)
+ (if (stringp arg)
+ (set-text-properties 0 (length arg) nil arg))
+ arg))
+ args)))))
+ (if output-newline
+ (cond
+ ((stringp value)
+ (concat value "\n"))
+ ((listp value)
+ (append value (list "\n")))
+ (t
+ (concat (eshell-stringify value) "\n")))
+ value))))
+
+(defun eshell/echo (&rest args)
+ "Implementation of `echo'. See `eshell-plain-echo-behavior'."
+ (eshell-eval-using-options
+ "echo" args
+ '((?n nil nil output-newline "terminate with a newline")
+ (?h "help" nil nil "output this help screen")
+ :preserve-args
+ :usage "[-n] [object]")
+ (eshell-echo args output-newline)))
+
+(defun eshell/printnl (&rest args)
+ "Print out each of the argument, separated by newlines."
+ (let ((elems (eshell-flatten-list args)))
+ (while elems
+ (eshell-printn (eshell-echo (list (car elems))))
+ (setq elems (cdr elems)))))
+
+(defun eshell/listify (&rest args)
+ "Return the argument(s) as a single list."
+ (if (> (length args) 1)
+ args
+ (if (listp (car args))
+ (car args)
+ (list (car args)))))
+
+(defun eshell/umask (&rest args)
+ "Shell-like implementation of `umask'."
+ (eshell-eval-using-options
+ "umask" args
+ '((?S "symbolic" nil symbolic-p "display umask symbolically")
+ (?h "help" nil nil "display this usage message")
+ :usage "[-S] [mode]")
+ (if (or (not args) symbolic-p)
+ (let ((modstr
+ (concat "000"
+ (format "%o"
+ (logand (lognot (default-file-modes))
+ 511)))))
+ (setq modstr (substring modstr (- (length modstr) 3)))
+ (when symbolic-p
+ (let ((mode (default-file-modes)))
+ (setq modstr
+ (format
+ "u=%s,g=%s,o=%s"
+ (concat (and (= (logand mode 64) 64) "r")
+ (and (= (logand mode 128) 128) "w")
+ (and (= (logand mode 256) 256) "x"))
+ (concat (and (= (logand mode 8) 8) "r")
+ (and (= (logand mode 16) 16) "w")
+ (and (= (logand mode 32) 32) "x"))
+ (concat (and (= (logand mode 1) 1) "r")
+ (and (= (logand mode 2) 2) "w")
+ (and (= (logand mode 4) 4) "x"))))))
+ (eshell-printn modstr))
+ (setcar args (eshell-convert (car args)))
+ (if (numberp (car args))
+ (set-default-file-modes
+ (- 511 (car (read-from-string
+ (concat "?\\" (number-to-string (car args)))))))
+ (error "setting umask symbolically is not yet implemented"))
+ (eshell-print
+ "Warning: umask changed for all new files created by Emacs.\n"))
+ nil))
+
+(eval-when-compile
+ (defvar print-func))
+
+;;; em-basic.el ends here
--- /dev/null
+;;; em-cmpl --- completion using the TAB key
+
+;; Copyright (C) 1999, 2000 Free Sofware Foundation
+
+;; 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 2, 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+(provide 'em-cmpl)
+
+(eval-when-compile (require 'esh-maint))
+
+(defgroup eshell-cmpl nil
+ "This module provides a programmable completion function bound to
+the TAB key, which allows for completing command names, file names,
+variable names, arguments, etc."
+ :tag "Argument completion"
+ :group 'eshell-module)
+
+;;; Commentary:
+
+;; Eshell, by using the pcomplete package, provides a full
+;; programmable completion facility that is comparable to shells like
+;; tcsh or zsh.
+;;
+;; Completions are context-sensitive, which means that pressing <TAB>
+;; after the command 'rmdir' will result in a list of directories,
+;; while doing so after 'rm' will result in a list of all file
+;; entries.
+;;
+;; Many builtin completion rules are provided, for commands such as
+;; `cvs', or RedHat's `rpm' utility. Adding new completion rules is
+;; no more difficult than writing a plain Lisp functions, and they can
+;; be debugged, profiled, and compiled using exactly the same
+;; facilities (since in fact, they *are* just Lisp functions). See
+;; the definition of the function `pcomplete/make' for an example of
+;; how to write a completion function.
+;;
+;; The completion facility is very easy to use. Just press TAB. If
+;; there are a large number of possible completions, a buffer will
+;; appearing showing a list of them. Completions may be selected from
+;; that buffer using the mouse. If no completion is selected, and the
+;; user starts doing something else, the display buffer will
+;; automatically disappear.
+;;
+;; If the list of possible completions is very small, Eshell will
+;; "cycle" through them, selecting a different entry each time <TAB>
+;; is pressed. <S-TAB> may be used to cycle in the opposite
+;; direction.
+;;
+;; Glob patterns can also be cycled. For example, entering 'echo
+;; x*<tab>' will cycle through all the filenames beginning with 'x'.
+;; This is done because the glob list is treated as though it were a
+;; list of possible completions. Pressing <C-c SPC> will insert all
+;; of the matching glob patterns at point.
+;;
+;; If a Lisp form is being entered, <TAB> will complete the Lisp
+;; symbol name, in exactly the same way that <M-TAB> does in Emacs
+;; Lisp mode.
+;;
+;; The list of possible completions can be viewed at any point by
+;; pressing <M-?>.
+;;
+;; Finally, context-related help can be accessed by pressing <C-c i>.
+;; This only works well if the completion function has provided Eshell
+;; with sufficient pointers to locate the relevant help text.
+
+;;; User Variables:
+
+(defcustom eshell-cmpl-load-hook '(eshell-cmpl-initialize)
+ "*A list of functions to run when `eshell-cmpl' is loaded."
+ :type 'hook
+ :group 'eshell-cmpl)
+
+(defcustom eshell-show-lisp-completions nil
+ "*If non-nil, include Lisp functions in the command completion list.
+If this variable is nil, Lisp completion can still be done in command
+position by using M-TAB instead of TAB."
+ :type 'boolean
+ :group 'eshell-cmpl)
+
+(defcustom eshell-show-lisp-alternatives t
+ "*If non-nil, and no other completions found, show Lisp functions.
+Setting this variable means nothing if `eshell-show-lisp-completions'
+is non-nil."
+ :type 'boolean
+ :group 'eshell-cmpl)
+
+(defcustom eshell-no-completion-during-jobs t
+ "*If non-nil, don't allow completion while a process is running."
+ :type 'boolean
+ :group 'eshell-cmpl)
+
+(defcustom eshell-command-completions-alist
+ '(("acroread" . "\\.pdf\\'")
+ ("xpdf" . "\\.pdf\\'")
+ ("ar" . "\\.[ao]\\'")
+ ("gcc" . "\\.[Cc]\\([Cc]\\|[Pp][Pp]\\)?\\'")
+ ("g++" . "\\.[Cc]\\([Cc]\\|[Pp][Pp]\\)?\\'")
+ ("cc" . "\\.[Cc]\\([Cc]\\|[Pp][Pp]\\)?\\'")
+ ("CC" . "\\.[Cc]\\([Cc]\\|[Pp][Pp]\\)?\\'")
+ ("acc" . "\\.[Cc]\\([Cc]\\|[Pp][Pp]\\)?\\'")
+ ("bcc" . "\\.[Cc]\\([Cc]\\|[Pp][Pp]\\)?\\'")
+ ("objdump" . "\\(\\`[^.]*\\|\\.[ao]\\)\\'")
+ ("nm" . "\\(\\`[^.]*\\|\\.[ao]\\)\\'")
+ ("gdb" . "\\`\\([^.]*\\|a\\.out\\)\\'")
+ ("dbx" . "\\`\\([^.]*\\|a\\.out\\)\\'")
+ ("sdb" . "\\`\\([^.]*\\|a\\.out\\)\\'")
+ ("adb" . "\\`\\([^.]*\\|a\\.out\\)\\'"))
+ "*An alist that defines simple argument type correlations.
+This is provided for common commands, as a simplistic alternative
+to writing a completion function."
+ :type '(repeat (cons string regexp))
+ :group 'eshell-cmpl)
+
+(defcustom eshell-cmpl-file-ignore "~\\'"
+ (documentation-property 'pcomplete-file-ignore
+ 'variable-documentation)
+ :type (get 'pcomplete-file-ignore 'custom-type)
+ :group 'eshell-cmpl)
+
+(defcustom eshell-cmpl-dir-ignore
+ (format "\\`\\(\\.\\.?\\|CVS\\)%c\\'" directory-sep-char)
+ (documentation-property 'pcomplete-dir-ignore
+ 'variable-documentation)
+ :type (get 'pcomplete-dir-ignore 'custom-type)
+ :group 'eshell-cmpl)
+
+(defcustom eshell-cmpl-ignore-case (eshell-under-windows-p)
+ (documentation-property 'pcomplete-ignore-case
+ 'variable-documentation)
+ :type (get 'pcomplete-ignore-case 'custom-type)
+ :group 'eshell-cmpl)
+
+(defcustom eshell-cmpl-autolist nil
+ (documentation-property 'pcomplete-autolist
+ 'variable-documentation)
+ :type (get 'pcomplete-autolist 'custom-type)
+ :group 'eshell-cmpl)
+
+(defcustom eshell-cmpl-suffix-list (list directory-sep-char ?:)
+ (documentation-property 'pcomplete-suffix-list
+ 'variable-documentation)
+ :type (get 'pcomplete-suffix-list 'custom-type)
+ :group 'pcomplete)
+
+(defcustom eshell-cmpl-recexact nil
+ (documentation-property 'pcomplete-recexact
+ 'variable-documentation)
+ :type (get 'pcomplete-recexact 'custom-type)
+ :group 'eshell-cmpl)
+
+(defcustom eshell-cmpl-man-function 'man
+ (documentation-property 'pcomplete-man-function
+ 'variable-documentation)
+ :type (get 'pcomplete-man-function 'custom-type)
+ :group 'eshell-cmpl)
+
+(defcustom eshell-cmpl-compare-entry-function 'file-newer-than-file-p
+ (documentation-property 'pcomplete-compare-entry-function
+ 'variable-documentation)
+ :type (get 'pcomplete-compare-entry-function 'custom-type)
+ :group 'eshell-cmpl)
+
+(defcustom eshell-cmpl-expand-before-complete nil
+ (documentation-property 'pcomplete-expand-before-complete
+ 'variable-documentation)
+ :type (get 'pcomplete-expand-before-complete 'custom-type)
+ :group 'eshell-cmpl)
+
+(defcustom eshell-cmpl-cycle-completions t
+ (documentation-property 'pcomplete-cycle-completions
+ 'variable-documentation)
+ :type (get 'pcomplete-cycle-completions 'custom-type)
+ :group 'eshell-cmpl)
+
+(defcustom eshell-cmpl-cycle-cutoff-length 5
+ (documentation-property 'pcomplete-cycle-cutoff-length
+ 'variable-documentation)
+ :type (get 'pcomplete-cycle-cutoff-length 'custom-type)
+ :group 'eshell-cmpl)
+
+(defcustom eshell-cmpl-restore-window-delay 1
+ (documentation-property 'pcomplete-restore-window-delay
+ 'variable-documentation)
+ :type (get 'pcomplete-restore-window-delay 'custom-type)
+ :group 'eshell-cmpl)
+
+(defcustom eshell-command-completion-function
+ (function
+ (lambda ()
+ (pcomplete-here (eshell-complete-commands-list))))
+ (documentation-property 'pcomplete-command-completion-function
+ 'variable-documentation)
+ :type (get 'pcomplete-command-completion-function 'custom-type)
+ :group 'eshell-cmpl)
+
+(defcustom eshell-cmpl-command-name-function
+ 'eshell-completion-command-name
+ (documentation-property 'pcomplete-command-name-function
+ 'variable-documentation)
+ :type (get 'pcomplete-command-name-function 'custom-type)
+ :group 'eshell-cmpl)
+
+(defcustom eshell-default-completion-function
+ (function
+ (lambda ()
+ (while (pcomplete-here
+ (pcomplete-dirs-or-entries
+ (cdr (assoc (funcall eshell-cmpl-command-name-function)
+ eshell-command-completions-alist)))))))
+ (documentation-property 'pcomplete-default-completion-function
+ 'variable-documentation)
+ :type (get 'pcomplete-default-completion-function 'custom-type)
+ :group 'pcomplete)
+
+;;; Functions:
+
+(defun eshell-cmpl-initialize ()
+ "Initialize the completions module."
+ (unless (fboundp 'pcomplete)
+ (load "pcmpl-auto" t t))
+ (set (make-local-variable 'pcomplete-command-completion-function)
+ eshell-command-completion-function)
+ (set (make-local-variable 'pcomplete-command-name-function)
+ eshell-cmpl-command-name-function)
+ (set (make-local-variable 'pcomplete-default-completion-function)
+ eshell-default-completion-function)
+ (set (make-local-variable 'pcomplete-parse-arguments-function)
+ 'eshell-complete-parse-arguments)
+ (set (make-local-variable 'pcomplete-file-ignore)
+ eshell-cmpl-file-ignore)
+ (set (make-local-variable 'pcomplete-dir-ignore)
+ eshell-cmpl-dir-ignore)
+ (set (make-local-variable 'pcomplete-ignore-case)
+ eshell-cmpl-ignore-case)
+ (set (make-local-variable 'pcomplete-autolist)
+ eshell-cmpl-autolist)
+ (set (make-local-variable 'pcomplete-suffix-list)
+ eshell-cmpl-suffix-list)
+ (set (make-local-variable 'pcomplete-recexact)
+ eshell-cmpl-recexact)
+ (set (make-local-variable 'pcomplete-man-function)
+ eshell-cmpl-man-function)
+ (set (make-local-variable 'pcomplete-compare-entry-function)
+ eshell-cmpl-compare-entry-function)
+ (set (make-local-variable 'pcomplete-expand-before-complete)
+ eshell-cmpl-expand-before-complete)
+ (set (make-local-variable 'pcomplete-cycle-completions)
+ eshell-cmpl-cycle-completions)
+ (set (make-local-variable 'pcomplete-cycle-cutoff-length)
+ eshell-cmpl-cycle-cutoff-length)
+ (set (make-local-variable 'pcomplete-restore-window-delay)
+ eshell-cmpl-restore-window-delay)
+ ;; `pcomplete-arg-quote-list' should only be set after all the
+ ;; load-hooks for any other extension modules have been run, which
+ ;; is true at the time `eshell-mode-hook' is run
+ (make-local-hook 'eshell-mode-hook)
+ (add-hook 'eshell-mode-hook
+ (function
+ (lambda ()
+ (set (make-local-variable 'pcomplete-arg-quote-list)
+ eshell-special-chars-outside-quoting))) nil t)
+ (make-local-hook 'pcomplete-quote-arg-hook)
+ (add-hook 'pcomplete-quote-arg-hook 'eshell-quote-backslash nil t)
+ (define-key eshell-mode-map [(meta tab)] 'lisp-complete-symbol)
+ (define-key eshell-mode-map [(meta control ?i)] 'lisp-complete-symbol)
+ (define-key eshell-command-map [(meta ?h)] 'eshell-completion-help)
+ (define-key eshell-command-map [tab] 'pcomplete-expand-and-complete)
+ (define-key eshell-command-map [(control ?i)]
+ 'pcomplete-expand-and-complete)
+ (define-key eshell-command-map [space] 'pcomplete-expand)
+ (define-key eshell-command-map [? ] 'pcomplete-expand)
+ (define-key eshell-mode-map [tab] 'pcomplete)
+ (define-key eshell-mode-map [(control ?i)] 'pcomplete)
+ ;; jww (1999-10-19): Will this work on anything but X?
+ (if (eshell-under-xemacs-p)
+ (define-key eshell-mode-map [iso-left-tab] 'pcomplete-reverse)
+ (define-key eshell-mode-map [(shift iso-lefttab)] 'pcomplete-reverse)
+ (define-key eshell-mode-map [(shift control ?i)] 'pcomplete-reverse))
+ (define-key eshell-mode-map [(meta ??)] 'pcomplete-list))
+
+(defun eshell-completion-command-name ()
+ "Return the command name, possibly sans globbing."
+ (let ((cmd (file-name-nondirectory (pcomplete-arg 'first))))
+ (setq cmd (if (and (> (length cmd) 0)
+ (eq (aref cmd 0) ?*))
+ (substring cmd 1)
+ cmd))
+ (if (eshell-under-windows-p)
+ (file-name-sans-extension cmd)
+ cmd)))
+
+(defun eshell-completion-help ()
+ (interactive)
+ (if (= (point) eshell-last-output-end)
+ (describe-prefix-bindings)
+ (call-interactively 'pcomplete-help)))
+
+(defun eshell-complete-parse-arguments ()
+ "Parse the command line arguments for `pcomplete-argument'."
+ (when (and eshell-no-completion-during-jobs
+ (eshell-interactive-process))
+ (insert-and-inherit "\t")
+ (throw 'pcompleted t))
+ (let ((end (point-marker))
+ (begin (save-excursion (eshell-bol) (point)))
+ (posns (list t))
+ args delim)
+ (when (memq this-command '(pcomplete-expand
+ pcomplete-expand-and-complete))
+ (run-hook-with-args 'eshell-expand-input-functions begin end)
+ (if (= begin end)
+ (end-of-line))
+ (setq end (point-marker)))
+ (if (setq delim
+ (catch 'eshell-incomplete
+ (ignore
+ (setq args (eshell-parse-arguments begin end)))))
+ (cond ((memq (car delim) '(?\{ ?\<))
+ (setq begin (1+ (cadr delim))
+ args (eshell-parse-arguments begin end)))
+ ((eq (car delim) ?\()
+ (lisp-complete-symbol)
+ (throw 'pcompleted t))
+ (t
+ (insert-and-inherit "\t")
+ (throw 'pcompleted t))))
+ (when (get-text-property (1- end) 'comment)
+ (insert-and-inherit "\t")
+ (throw 'pcompleted t))
+ (let ((pos begin))
+ (while (< pos end)
+ (if (get-text-property pos 'arg-begin)
+ (nconc posns (list pos)))
+ (setq pos (1+ pos))))
+ (setq posns (cdr posns))
+ (assert (= (length args) (length posns)))
+ (let ((a args)
+ (i 0)
+ l final)
+ (while a
+ (if (and (consp (car a))
+ (eq (caar a) 'eshell-operator))
+ (setq l i))
+ (setq a (cdr a) i (1+ i)))
+ (and l
+ (setq args (nthcdr (1+ l) args)
+ posns (nthcdr (1+ l) posns))))
+ (assert (= (length args) (length posns)))
+ (when (and args (eq (char-syntax (char-before end)) ? ))
+ (nconc args (list ""))
+ (nconc posns (list (point))))
+ (cons (mapcar
+ (function
+ (lambda (arg)
+ (let ((val
+ (if (listp arg)
+ (let ((result
+ (eshell-do-eval
+ (list 'eshell-commands arg) t)))
+ (assert (eq (car result) 'quote))
+ (cadr result))
+ arg)))
+ (if (numberp val)
+ (setq val (number-to-string val)))
+ (or val ""))))
+ args)
+ posns)))
+
+(defun eshell-complete-commands-list ()
+ "Generate list of applicable, visible commands."
+ (let ((filename (pcomplete-arg)) glob-name)
+ (if (file-name-directory filename)
+ (pcomplete-executables)
+ (if (and (> (length filename) 0)
+ (eq (aref filename 0) ?*))
+ (setq filename (substring filename 1)
+ pcomplete-stub filename
+ glob-name t))
+ (let* ((paths (split-string (getenv "PATH") path-separator))
+ (cwd (file-name-as-directory
+ (expand-file-name default-directory)))
+ (path "") (comps-in-path ())
+ (file "") (filepath "") (completions ()))
+ ;; Go thru each path in the search path, finding completions.
+ (while paths
+ (setq path (file-name-as-directory
+ (expand-file-name (or (car paths) ".")))
+ comps-in-path
+ (and (file-accessible-directory-p path)
+ (file-name-all-completions filename path)))
+ ;; Go thru each completion found, to see whether it should
+ ;; be used.
+ (while comps-in-path
+ (setq file (car comps-in-path)
+ filepath (concat path file))
+ (if (and (not (member file completions)) ;
+ (or (string-equal path cwd)
+ (not (file-directory-p filepath)))
+ (file-executable-p filepath))
+ (setq completions (cons file completions)))
+ (setq comps-in-path (cdr comps-in-path)))
+ (setq paths (cdr paths)))
+ ;; Add aliases which are currently visible, and Lisp functions.
+ (pcomplete-uniqify-list
+ (if glob-name
+ completions
+ (setq completions
+ (append (and (eshell-using-module 'eshell-alias)
+ (funcall (symbol-function 'eshell-alias-completions)
+ filename))
+ (eshell-winnow-list
+ (mapcar
+ (function
+ (lambda (name)
+ (substring name 7)))
+ (all-completions (concat "eshell/" filename)
+ obarray 'functionp))
+ nil '(eshell-find-alias-function))
+ completions))
+ (append (and (or eshell-show-lisp-completions
+ (and eshell-show-lisp-alternatives
+ (null completions)))
+ (all-completions filename obarray 'functionp))
+ completions)))))))
+
+;;; Code:
+
+;;; em-cmpl.el ends here
--- /dev/null
+;;; em-dirs --- directory navigation commands
+
+;; Copyright (C) 1999, 2000 Free Sofware Foundation
+
+;; 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 2, 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+(provide 'em-dirs)
+
+(eval-when-compile (require 'esh-maint))
+
+(defgroup eshell-dirs nil
+ "Directory navigation involves changing directories, examining the
+current directory, maintaining a directory stack, and also keeping
+track of a history of the last directory locations the user was in.
+Emacs does provide standard Lisp definitions of `pwd' and `cd', but
+they lack somewhat in feel from the typical shell equivalents."
+ :tag "Directory navigation"
+ :group 'eshell-module)
+
+;;; Commentary:
+
+;; The only special feature that Eshell offers in the last-dir-ring.
+;; To view the ring, enter:
+;;
+;; cd =
+;;
+;; Changing to an index within the ring is done using:
+;;
+;; cd - ; same as cd -0
+;; cd -4
+;;
+;; Or, it is possible to change the first member in the ring which
+;; matches a regexp:
+;;
+;; cd =bcc ; change to the last directory visited containing "bcc"
+;;
+;; This ring is maintained automatically, and is persisted across
+;; Eshell sessions. It is a separate mechanism from `pushd' and
+;; `popd', and the two may be used at the same time.
+
+(require 'ring)
+(require 'esh-opt)
+
+;;; User Variables:
+
+(defcustom eshell-dirs-load-hook '(eshell-dirs-initialize)
+ "*A hook that gets run when `eshell-dirs' is loaded."
+ :type 'hook
+ :group 'eshell-dirs)
+
+(defcustom eshell-pwd-convert-function (if (eshell-under-windows-p)
+ 'expand-file-name
+ 'identity)
+ "*The function used to normalize the value of Eshell's `pwd'.
+The value returned by `pwd' is also used when recording the
+last-visited directory in the last-dir-ring, so it will affect the
+form of the list used by 'cd ='."
+ :type '(radio (function-item file-truename)
+ (function-item expand-file-name)
+ (function-item identity)
+ (function :tag "Other"))
+ :group 'eshell-dirs)
+
+(defcustom eshell-ask-to-save-last-dir 'always
+ "*Determine if the last-dir-ring should be automatically saved.
+The last-dir-ring is always preserved when exiting an Eshell buffer.
+However, when Emacs is being shut down, this variable determines
+whether to prompt the user, or just save the ring.
+If set to nil, it means never ask whether to save the last-dir-ring.
+If set to t, always ask if any Eshell buffers are open at exit time.
+If set to `always', the list-dir-ring will always be saved, silently."
+ :type '(choice (const :tag "Never" nil)
+ (const :tag "Ask" t)
+ (const :tag "Always save" always))
+ :group 'eshell-dirs)
+
+(defcustom eshell-cd-shows-directory nil
+ "*If non-nil, using `cd' will report the directory it changes to."
+ :type 'boolean
+ :group 'eshell-dirs)
+
+(defcustom eshell-cd-on-directory t
+ "*If non-nil, do a cd if a directory is in command position."
+ :type 'boolean
+ :group 'eshell-dirs)
+
+(defcustom eshell-directory-change-hook nil
+ "*A hook to run when the current directory changes."
+ :type 'hook
+ :group 'eshell-dirs)
+
+(defcustom eshell-list-files-after-cd nil
+ "*If non-nil, call \"ls\" with any remaining args after doing a cd.
+This is provided for convenience, since the same effect is easily
+achieved by adding a function to `eshell-directory-change-hook' that
+calls \"ls\" and references `eshell-last-arguments'."
+ :type 'boolean
+ :group 'eshell-dirs)
+
+(defcustom eshell-pushd-tohome nil
+ "*If non-nil, make pushd with no arg behave as 'pushd ~' (like `cd').
+This mirrors the optional behavior of tcsh."
+ :type 'boolean
+ :group 'eshell-dirs)
+
+(defcustom eshell-pushd-dextract nil
+ "*If non-nil, make \"pushd +n\" pop the nth dir to the stack top.
+This mirrors the optional behavior of tcsh."
+ :type 'boolean
+ :group 'eshell-dirs)
+
+(defcustom eshell-pushd-dunique nil
+ "*If non-nil, make pushd only add unique directories to the stack.
+This mirrors the optional behavior of tcsh."
+ :type 'boolean
+ :group 'eshell-dirs)
+
+(defcustom eshell-dirtrack-verbose t
+ "*If non-nil, show the directory stack following directory change.
+This is effective only if directory tracking is enabled."
+ :type 'boolean
+ :group 'eshell-dirs)
+
+(defcustom eshell-last-dir-ring-file-name
+ (concat eshell-directory-name "lastdir")
+ "*If non-nil, name of the file to read/write the last-dir-ring.
+See also `eshell-read-last-dir-ring' and `eshell-write-last-dir-ring'.
+If it is nil, the last-dir-ring will not be written to disk."
+ :type 'file
+ :group 'eshell-dirs)
+
+(defcustom eshell-last-dir-ring-size 32
+ "*If non-nil, the size of the directory history ring.
+This ring is added to every time `cd' or `pushd' is used. It simply
+stores the most recent directory locations Eshell has been in. To
+return to the most recent entry, use 'cd -' (equivalent to 'cd -0').
+To return to an older entry, use 'cd -N', where N is an integer less
+than `eshell-last-dir-ring-size'. To return to the last directory
+matching a particular regexp, use 'cd =REGEXP'. To display the
+directory history list, use 'cd ='.
+
+This mechanism is very similar to that provided by `pushd', except
+it's far more automatic. `pushd' allows the user to decide which
+directories gets pushed, and its size is unlimited.
+
+`eshell-last-dir-ring' is meant for users who don't use `pushd'
+explicity very much, but every once in a while would like to return to
+a previously visited directory without having to type in the whole
+thing again."
+ :type 'integer
+ :group 'eshell-dirs)
+
+(defcustom eshell-last-dir-unique t
+ "*If non-nil, `eshell-last-dir-ring' contains only unique entries."
+ :type 'boolean
+ :group 'eshell-dirs)
+
+;;; Internal Variables:
+
+(defvar eshell-dirstack nil
+ "List of directories saved by pushd in the Eshell buffer.
+Thus, this does not include the current directory.")
+
+(defvar eshell-last-dir-ring nil
+ "The last directory that eshell was in.")
+
+;;; Functions:
+
+(defun eshell-dirs-initialize ()
+ "Initialize the builtin functions for Eshell."
+ (make-local-variable 'eshell-variable-aliases-list)
+ (setq eshell-variable-aliases-list
+ (append
+ eshell-variable-aliases-list
+ '(("-" (lambda (indices)
+ (if (not indices)
+ (unless (ring-empty-p eshell-last-dir-ring)
+ (expand-file-name
+ (ring-ref eshell-last-dir-ring 0)))
+ (expand-file-name
+ (eshell-apply-indices eshell-last-dir-ring indices)))))
+ ("+" "PWD")
+ ("PWD" (lambda (indices)
+ (expand-file-name (eshell/pwd))) t)
+ ("OLDPWD" (lambda (indices)
+ (unless (ring-empty-p eshell-last-dir-ring)
+ (expand-file-name
+ (ring-ref eshell-last-dir-ring 0)))) t))))
+
+ (when eshell-cd-on-directory
+ (make-local-variable 'eshell-interpreter-alist)
+ (setq eshell-interpreter-alist
+ (cons (cons 'eshell-lone-directory-p
+ 'eshell-dirs-substitute-cd)
+ eshell-interpreter-alist)))
+
+ (make-local-hook 'eshell-parse-argument-hook)
+ (add-hook 'eshell-parse-argument-hook
+ 'eshell-parse-user-reference nil t)
+ (if (eshell-under-windows-p)
+ (add-hook 'eshell-parse-argument-hook
+ 'eshell-parse-drive-letter nil t))
+
+ (when (eshell-using-module 'eshell-cmpl)
+ (make-local-hook 'pcomplete-try-first-hook)
+ (add-hook 'pcomplete-try-first-hook
+ 'eshell-complete-user-reference nil t))
+
+ (make-local-variable 'eshell-dirstack)
+ (make-local-variable 'eshell-last-dir-ring)
+
+ (if eshell-last-dir-ring-file-name
+ (eshell-read-last-dir-ring))
+ (unless eshell-last-dir-ring
+ (setq eshell-last-dir-ring (make-ring eshell-last-dir-ring-size)))
+
+ (make-local-hook 'eshell-exit-hook)
+ (add-hook 'eshell-exit-hook 'eshell-write-last-dir-ring nil t)
+
+ (add-hook 'kill-emacs-hook 'eshell-save-some-last-dir))
+
+(defun eshell-save-some-last-dir ()
+ "Save the list-dir-ring for any open Eshell buffers."
+ (eshell-for buf (buffer-list)
+ (if (buffer-live-p buf)
+ (with-current-buffer buf
+ (if (and eshell-mode
+ eshell-ask-to-save-last-dir
+ (or (eq eshell-ask-to-save-last-dir 'always)
+ (y-or-n-p
+ (format "Save last dir ring for Eshell buffer `%s'? "
+ (buffer-name buf)))))
+ (eshell-write-last-dir-ring))))))
+
+(defun eshell-lone-directory-p (file)
+ "Test whether FILE is just a directory name, and not a command name."
+ (and (file-directory-p file)
+ (or (file-name-directory file)
+ (not (eshell-search-path file)))))
+
+(defun eshell-dirs-substitute-cd (&rest args)
+ "Substitute the given command for a call to `cd' on that name."
+ (if (> (length args) 1)
+ (error "%s: command not found" (car args))
+ (throw 'eshell-replace-command
+ (eshell-parse-command "cd" args))))
+
+(defun eshell-parse-user-reference ()
+ "An argument beginning with ~ is a filename to be expanded."
+ (when (and (not eshell-current-argument)
+ (eq (char-after) ?~))
+ (add-to-list 'eshell-current-modifiers 'expand-file-name)
+ (forward-char)
+ (char-to-string (char-before))))
+
+(defun eshell-parse-drive-letter ()
+ "An argument beginning X:[^/] is a drive letter reference."
+ (when (and (not eshell-current-argument)
+ (looking-at "\\([A-Za-z]:\\)\\([^/\\\\]\\|\\'\\)"))
+ (goto-char (match-end 1))
+ (let* ((letter (match-string 1))
+ (regexp (concat "\\`" letter))
+ (path (eshell-find-previous-directory regexp)))
+ (concat (or path letter)
+ (char-to-string directory-sep-char)))))
+
+(defun eshell-complete-user-reference ()
+ "If there is a user reference, complete it."
+ (let ((arg (pcomplete-actual-arg)))
+ (when (string-match "\\`~[a-z]*\\'" arg)
+ (setq pcomplete-stub (substring arg 1)
+ pcomplete-last-completion-raw t)
+ (throw 'pcomplete-completions
+ (progn
+ (eshell-read-user-names)
+ (pcomplete-uniqify-list
+ (mapcar
+ (function
+ (lambda (user)
+ (file-name-as-directory (cdr user))))
+ eshell-user-names)))))))
+
+(defun eshell/pwd (&rest args) ; ignored
+ "Change output from `pwd` to be cleaner."
+ (let* ((path default-directory)
+ (len (length path)))
+ (if (and (> len 1)
+ (eq (aref path (1- len)) directory-sep-char)
+ (not (and (eshell-under-windows-p)
+ (string-match "\\`[A-Za-z]:[\\\\/]\\'" path))))
+ (setq path (substring path 0 (1- (length path)))))
+ (if eshell-pwd-convert-function
+ (setq path (funcall eshell-pwd-convert-function path)))
+ path))
+
+(defun eshell-expand-multiple-dots (path)
+ "Convert '...' to '../..', '....' to '../../..', etc..
+
+With the following piece of advice, you can make this functionality
+available in most of Emacs, with the exception of filename completion
+in the minibuffer:
+
+ (defadvice expand-file-name
+ (before translate-multiple-dots
+ (filename &optional directory) activate)
+ (setq filename (eshell-expand-multiple-dots filename)))"
+ (while (string-match "\\.\\.\\(\\.+\\)" path)
+ (let* ((extra-dots (match-string 1 path))
+ (len (length extra-dots))
+ replace-text)
+ (while (> len 0)
+ (setq replace-text
+ (concat replace-text
+ (char-to-string directory-sep-char) "..")
+ len (1- len)))
+ (setq path
+ (replace-match replace-text t t path 1))))
+ path)
+
+(defun eshell-find-previous-directory (regexp)
+ "Find the most recent last-dir matching REGEXP."
+ (let ((index 0)
+ (len (ring-length eshell-last-dir-ring))
+ oldpath)
+ (if (> (length regexp) 0)
+ (while (< index len)
+ (setq oldpath (ring-ref eshell-last-dir-ring index))
+ (if (string-match regexp oldpath)
+ (setq index len)
+ (setq oldpath nil
+ index (1+ index)))))
+ oldpath))
+
+(eval-when-compile
+ (defvar dired-directory))
+
+(defun eshell/cd (&rest args) ; all but first ignored
+ "Alias to extend the behavior of `cd'."
+ (let ((path (car args))
+ (subpath (car (cdr args)))
+ handled)
+ (if (numberp path)
+ (setq path (number-to-string path)))
+ (if (numberp subpath)
+ (setq subpath (number-to-string subpath)))
+ (cond
+ (subpath
+ (let ((curdir (eshell/pwd)))
+ (if (string-match path curdir)
+ (setq path (replace-match subpath nil nil curdir))
+ (error "Path substring '%s' not found" path))))
+ ((and path (string-match "^-\\([0-9]*\\)$" path))
+ (let ((index (match-string 1 path)))
+ (setq path
+ (ring-remove eshell-last-dir-ring
+ (if index
+ (string-to-int index)
+ 0)))))
+ ((and path (string-match "^=\\(.*\\)$" path))
+ (let ((oldpath (eshell-find-previous-directory
+ (match-string 1 path))))
+ (if oldpath
+ (setq path oldpath)
+ (let ((len (ring-length eshell-last-dir-ring))
+ (index 0))
+ (if (= len 0)
+ (error "Directory ring empty"))
+ (while (< index len)
+ (eshell-printn
+ (concat (number-to-string index) ": "
+ (ring-ref eshell-last-dir-ring index)))
+ (setq index (1+ index)))
+ (setq handled t)))))
+ (path
+ (setq path (eshell-expand-multiple-dots path))))
+ (unless handled
+ (setq dired-directory (or path "~"))
+ (let ((curdir (eshell/pwd)))
+ (unless (equal curdir dired-directory)
+ (eshell-add-to-dir-ring curdir))
+ (let ((result (cd dired-directory)))
+ (and eshell-cd-shows-directory
+ (eshell-printn result)))
+ (run-hooks 'eshell-directory-change-hook)
+ (if eshell-list-files-after-cd
+ (throw 'eshell-replace-command
+ (eshell-parse-command "ls" (cdr args))))
+ nil))))
+
+(defun eshell-add-to-dir-ring (path)
+ "Add PATH to the last-dir-ring, if applicable."
+ (unless (and (not (ring-empty-p eshell-last-dir-ring))
+ (equal path (ring-ref eshell-last-dir-ring 0)))
+ (if eshell-last-dir-unique
+ (let ((index 0)
+ (len (ring-length eshell-last-dir-ring)))
+ (while (< index len)
+ (if (equal (ring-ref eshell-last-dir-ring index) path)
+ (ring-remove eshell-last-dir-ring index)
+ (setq index (1+ index))))))
+ (ring-insert eshell-last-dir-ring path)))
+
+;;; pushd [+n | dir]
+(defun eshell/pushd (&rest args) ; all but first ignored
+ "Implementation of pushd in Lisp."
+ (let ((path (car args)))
+ (cond
+ ((null path)
+ ;; no arg -- swap pwd and car of stack unless eshell-pushd-tohome
+ (cond (eshell-pushd-tohome
+ (eshell/pushd "~"))
+ (eshell-dirstack
+ (let ((old (eshell/pwd)))
+ (eshell/cd (car eshell-dirstack))
+ (setq eshell-dirstack (cons old (cdr eshell-dirstack)))
+ (eshell/dirs t)))
+ (t
+ (error "pushd: No other directory"))))
+ ((string-match "^\\+\\([0-9]\\)" path)
+ ;; pushd +n
+ (setq path (string-to-number (match-string 1 path)))
+ (cond ((> path (length eshell-dirstack))
+ (error "Directory stack not that deep"))
+ ((= path 0)
+ (error "Couldn't cd"))
+ (eshell-pushd-dextract
+ (let ((dir (nth (1- path) eshell-dirstack)))
+ (eshell/popd path)
+ (eshell/pushd (eshell/pwd))
+ (eshell/cd dir)
+ (eshell/dirs t)))
+ (t
+ (let* ((ds (cons (eshell/pwd) eshell-dirstack))
+ (dslen (length ds))
+ (front (nthcdr path ds))
+ (back (nreverse (nthcdr (- dslen path) (reverse ds))))
+ (new-ds (append front back)))
+ (eshell/cd (car new-ds))
+ (setq eshell-dirstack (cdr new-ds))
+ (eshell/dirs t)))))
+ (t
+ ;; pushd <dir>
+ (let ((old-wd (eshell/pwd)))
+ (eshell/cd path)
+ (if (or (null eshell-pushd-dunique)
+ (not (member old-wd eshell-dirstack)))
+ (setq eshell-dirstack (cons old-wd eshell-dirstack)))
+ (eshell/dirs t)))))
+ nil)
+
+;;; popd [+n]
+(defun eshell/popd (&rest args)
+ "Implementation of popd in Lisp."
+ (let ((ref (or (car args) "+0")))
+ (unless (and (stringp ref)
+ (string-match "\\`\\([+-][0-9]+\\)\\'" ref))
+ (error "popd: bad arg `%s'" ref))
+ (setq ref (string-to-number (match-string 1 ref)))
+ (cond ((= ref 0)
+ (unless eshell-dirstack
+ (error "popd: Directory stack empty"))
+ (eshell/cd (car eshell-dirstack))
+ (setq eshell-dirstack (cdr eshell-dirstack))
+ (eshell/dirs t))
+ ((<= (abs ref) (length eshell-dirstack))
+ (let* ((ds (cons nil eshell-dirstack))
+ (cell (nthcdr (if (> ref 0)
+ (1- ref)
+ (+ (length eshell-dirstack) ref)) ds))
+ (dir (cadr cell)))
+ (eshell/cd dir)
+ (setcdr cell (cdr (cdr cell)))
+ (setq eshell-dirstack (cdr ds))
+ (eshell/dirs t)))
+ (t
+ (error "Couldn't popd"))))
+ nil)
+
+(defun eshell/dirs (&optional if-verbose)
+ "Implementation of dirs in Lisp."
+ (when (or (not if-verbose) eshell-dirtrack-verbose)
+ (let* ((msg "")
+ (ds (cons (eshell/pwd) eshell-dirstack))
+ (home (expand-file-name "~/"))
+ (homelen (length home)))
+ (while ds
+ (let ((dir (car ds)))
+ (and (>= (length dir) homelen)
+ (string= home (substring dir 0 homelen))
+ (setq dir (concat "~/" (substring dir homelen))))
+ (setq msg (concat msg (directory-file-name dir) " "))
+ (setq ds (cdr ds))))
+ msg)))
+
+(defun eshell-read-last-dir-ring ()
+ "Sets the buffer's `eshell-last-dir-ring' from a history file."
+ (let ((file eshell-last-dir-ring-file-name))
+ (cond
+ ((or (null file)
+ (equal file "")
+ (not (file-readable-p file)))
+ nil)
+ (t
+ (let* ((count 0)
+ (size eshell-last-dir-ring-size)
+ (ring (make-ring size)))
+ (with-temp-buffer
+ (insert-file-contents file)
+ ;; Save restriction in case file is already visited...
+ ;; Watch for those date stamps in history files!
+ (goto-char (point-max))
+ (while (and (< count size)
+ (re-search-backward "^\\([^\n].*\\)$" nil t))
+ (ring-insert-at-beginning ring (match-string 1))
+ (setq count (1+ count)))
+ ;; never allow the top element to equal the current
+ ;; directory
+ (while (and (not (ring-empty-p ring))
+ (equal (ring-ref ring 0) (eshell/pwd)))
+ (ring-remove ring 0)))
+ (setq eshell-last-dir-ring ring))))))
+
+(defun eshell-write-last-dir-ring ()
+ "Writes the buffer's `eshell-last-dir-ring' to a history file."
+ (let ((file eshell-last-dir-ring-file-name))
+ (cond
+ ((or (null file)
+ (equal file "")
+ (null eshell-last-dir-ring)
+ (ring-empty-p eshell-last-dir-ring))
+ nil)
+ ((not (file-writable-p file))
+ (message "Cannot write last-dir-ring file %s" file))
+ (t
+ (let* ((ring eshell-last-dir-ring)
+ (index (ring-length ring)))
+ (with-temp-buffer
+ (while (> index 0)
+ (setq index (1- index))
+ (insert (ring-ref ring index) ?\n))
+ (insert (eshell/pwd) ?\n)
+ (eshell-with-private-file-modes
+ (write-region (point-min) (point-max) file nil
+ 'no-message))))))))
+
+;;; Code:
+
+;;; em-dirs.el ends here
--- /dev/null
+;;; em-glob --- extended file name globbing
+
+;; Copyright (C) 1999, 2000 Free Sofware Foundation
+
+;; 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 2, 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+(provide 'em-glob)
+
+(eval-when-compile (require 'esh-maint))
+
+(defgroup eshell-glob nil
+ "This module provides extended globbing syntax, similar what is used
+by zsh for filename generation."
+ :tag "Extended filename globbing"
+ :group 'eshell-module)
+
+;;; Commentary:
+
+;; The globbing code used by Eshell closely follows the syntax used by
+;; zsh. Basically, here is a summary of examples:
+;;
+;; echo a* ; anything starting with 'a'
+;; echo a#b ; zero or more 'a's, then 'b'
+;; echo a##b ; one or more 'a's, then 'b'
+;; echo a? ; a followed by any character
+;; echo a*~ab ; 'a', then anything, but not 'ab'
+;; echo c*~*~ ; all files beginning with 'c', except backups (*~)
+;;
+;; Recursive globbing is also supported:
+;;
+;; echo **/*.c ; all '.c' files at or under current directory
+;; echo ***/*.c ; same as above, but traverse symbolic links
+;;
+;; Using argument predication, the recursive globbing syntax is
+;; sufficient to replace the use of 'find <expr> | xargs <cmd>' in
+;; most cases. For example, to change the readership of all files
+;; belonging to 'johnw' in the '/tmp' directory or lower, use:
+;;
+;; chmod go-r /tmp/**/*(u'johnw')
+;;
+;; The glob above matches all of the files beneath '/tmp' that are
+;; owned by the user 'johnw'. See [Value modifiers and predicates],
+;; for more information about argument predication.
+
+;;; User Variables:
+
+(defcustom eshell-glob-load-hook '(eshell-glob-initialize)
+ "*A list of functions to run when `eshell-glob' is loaded."
+ :type 'hook
+ :group 'eshell-glob)
+
+(defcustom eshell-glob-include-dot-files nil
+ "*If non-nil, glob patterns will match files beginning with a dot."
+ :type 'boolean
+ :group 'eshell-glob)
+
+(defcustom eshell-glob-include-dot-dot t
+ "*If non-nil, glob patterns that match dots will match . and .."
+ :type 'boolean
+ :group 'eshell-glob)
+
+(defcustom eshell-glob-case-insensitive (eshell-under-windows-p)
+ "*If non-nil, glob pattern matching will ignore case."
+ :type 'boolean
+ :group 'eshell-glob)
+
+(defcustom eshell-glob-show-progress t
+ "*If non-nil, display progress messages during a recursive glob."
+ :type 'boolean
+ :group 'eshell-glob)
+
+(defcustom eshell-error-if-no-glob nil
+ "*If non-nil, it is an error for a glob pattern not to match.
+ This mimcs the behavior of zsh if non-nil, but bash if nil."
+ :type 'boolean
+ :group 'eshell-glob)
+
+(defcustom eshell-glob-chars-list '(?\] ?\[ ?* ?? ?~ ?\( ?\) ?| ?#)
+ "*List of additional characters used in extended globbing."
+ :type '(repeat character)
+ :group 'eshell-glob)
+
+(defcustom eshell-glob-translate-alist
+ '((?\] . "]")
+ (?\[ . "[")
+ (?? . ".")
+ (?* . ".*")
+ (?~ . "~")
+ (?\( . "\\(")
+ (?\) . "\\)")
+ (?\| . "\\|")
+ (?# . (lambda (str pos)
+ (if (and (< (1+ pos) (length str))
+ (memq (aref str (1+ pos)) '(?* ?# ?+ ??)))
+ (cons (if (eq (aref str (1+ pos)) ??)
+ "?"
+ (if (eq (aref str (1+ pos)) ?*)
+ "*" "+")) (+ pos 2))
+ (cons "*" (1+ pos))))))
+ "*An alist for translation of extended globbing characters."
+ :type '(repeat (cons character (choice regexp function)))
+ :group 'eshell-glob)
+
+;;; Internal Variables:
+
+(defvar eshell-glob-chars-regexp nil)
+
+;;; Functions:
+
+(defun eshell-glob-initialize ()
+ "Initialize the extended globbing code."
+ ;; it's important that `eshell-glob-chars-list' come first
+ (set (make-local-variable 'eshell-special-chars-outside-quoting)
+ (append eshell-glob-chars-list eshell-special-chars-outside-quoting))
+ (set (make-local-variable 'eshell-glob-chars-regexp)
+ (format "[%s]+" (apply 'string eshell-glob-chars-list)))
+ (make-local-hook 'eshell-parse-argument-hook)
+ (add-hook 'eshell-parse-argument-hook 'eshell-parse-glob-chars t t)
+ (make-local-hook 'eshell-pre-rewrite-command-hook)
+ (add-hook 'eshell-pre-rewrite-command-hook
+ 'eshell-no-command-globbing nil t))
+
+(defun eshell-no-command-globbing (terms)
+ "Don't glob the command argument. Reflect this by modifying TERMS."
+ (ignore
+ (when (and (listp (car terms))
+ (eq (caar terms) 'eshell-extended-glob))
+ (setcar terms (cadr (car terms))))))
+
+(defun eshell-add-glob-modifier ()
+ "Add `eshell-extended-glob' to the argument modifier list."
+ (when (memq 'expand-file-name eshell-current-modifiers)
+ (setq eshell-current-modifiers
+ (delq 'expand-file-name eshell-current-modifiers))
+ ;; if this is a glob pattern than needs to be expanded, then it
+ ;; will need to expand each member of the resulting glob list
+ (add-to-list 'eshell-current-modifiers
+ '(lambda (list)
+ (if (listp list)
+ (mapcar 'expand-file-name list)
+ (expand-file-name list)))))
+ (add-to-list 'eshell-current-modifiers 'eshell-extended-glob))
+
+(defun eshell-parse-glob-chars ()
+ "Parse a globbing delimiter.
+The character is not advanced for ordinary globbing characters, so
+that other function may have a chance to override the globbing
+interpretation."
+ (when (memq (char-after) eshell-glob-chars-list)
+ (if (not (memq (char-after) '(?\( ?\[)))
+ (ignore (eshell-add-glob-modifier))
+ (let ((here (point)))
+ (forward-char)
+ (let* ((delim (char-before))
+ (end (eshell-find-delimiter
+ delim (if (eq delim ?\[) ?\] ?\)))))
+ (if (not end)
+ (throw 'eshell-incomplete delim)
+ (if (and (eshell-using-module 'eshell-pred)
+ (eshell-arg-delimiter (1+ end)))
+ (ignore (goto-char here))
+ (eshell-add-glob-modifier)
+ (prog1
+ (buffer-substring-no-properties (1- (point)) (1+ end))
+ (goto-char (1+ end))))))))))
+
+(defun eshell-glob-regexp (pattern)
+ "Convert glob-pattern PATTERN to a regular expression.
+The basic syntax is:
+
+ glob regexp meaning
+ ---- ------ -------
+ ? . matches any single character
+ * .* matches any group of characters (or none)
+ # * matches zero or more occurrences of preceding
+ ## + matches one or more occurrences of preceding
+ (x) \(x\) makes 'x' a regular expression group
+ | \| boolean OR within an expression group
+ [a-b] [a-b] matches a character or range
+ [^a] [^a] excludes a character or range
+
+If any characters in PATTERN have the text property `eshell-escaped'
+set to true, then these characters will match themselves in the
+resulting regular expression."
+ (let ((matched-in-pattern 0) ; How much of PATTERN handled
+ regexp)
+ (while (string-match eshell-glob-chars-regexp
+ pattern matched-in-pattern)
+ (let* ((op-begin (match-beginning 0))
+ (op-char (aref pattern op-begin)))
+ (setq regexp
+ (concat regexp
+ (regexp-quote
+ (substring pattern matched-in-pattern op-begin))))
+ (if (get-text-property op-begin 'escaped pattern)
+ (setq regexp (concat regexp
+ (regexp-quote (char-to-string op-char)))
+ matched-in-pattern (1+ op-begin))
+ (let ((xlat (assq op-char eshell-glob-translate-alist)))
+ (if (not xlat)
+ (error "Unrecognized globbing character '%c'" op-char)
+ (if (stringp (cdr xlat))
+ (setq regexp (concat regexp (cdr xlat))
+ matched-in-pattern (1+ op-begin))
+ (let ((result (funcall (cdr xlat) pattern op-begin)))
+ (setq regexp (concat regexp (car result))
+ matched-in-pattern (cdr result)))))))))
+ (concat "\\`"
+ regexp
+ (regexp-quote (substring pattern matched-in-pattern))
+ "\\'")))
+
+(defun eshell-extended-glob (glob)
+ "Return a list of files generated from GLOB, perhaps looking for DIRS-ONLY.
+ This function almost fully supports zsh style filename generation
+ syntax. Things that are not supported are:
+
+ ^foo for matching everything but foo
+ (foo~bar) tilde within a parenthesis group
+ foo<1-10> numeric ranges
+ foo~x(a|b) (a|b) will be interpreted as a predicate/modifier list
+
+ Mainly they are not supported because file matching is done with Emacs
+ regular expressions, and these cannot support the above constructs.
+
+ If this routine fails, it returns nil. Otherwise, it returns a list
+ the form:
+
+ (INCLUDE-REGEXP EXCLUDE-REGEXP (PRED-FUNC-LIST) (MOD-FUNC-LIST))"
+ (let ((paths (eshell-split-path glob))
+ matches message-shown)
+ (unwind-protect
+ (if (and (cdr paths)
+ (file-name-absolute-p (car paths)))
+ (eshell-glob-entries (file-name-as-directory (car paths))
+ (cdr paths))
+ (eshell-glob-entries (file-name-as-directory ".") paths))
+ (if message-shown
+ (message nil)))
+ (or (and matches (nreverse matches))
+ (if eshell-error-if-no-glob
+ (error "No matches found: %s" glob)
+ glob))))
+
+(eval-when-compile
+ (defvar matches)
+ (defvar message-shown))
+
+;; jww (1999-11-18): this function assumes that directory-sep-char is
+;; a forward slash (/)
+
+(defun eshell-glob-entries (path globs &optional recurse-p)
+ "Glob the entries in PATHS, possibly recursing if RECURSE-P is non-nil."
+ (let* ((entries (ignore-errors
+ (file-name-all-completions "" path)))
+ (case-fold-search eshell-glob-case-insensitive)
+ (glob (car globs))
+ (len (length glob))
+ dirs rdirs
+ incl excl
+ name isdir pathname)
+ (while (cond
+ ((and (= len 3) (equal glob "**/"))
+ (setq recurse-p 2
+ globs (cdr globs)
+ glob (car globs)
+ len (length glob)))
+ ((and (= len 4) (equal glob "***/"))
+ (setq recurse-p 3
+ globs (cdr globs)
+ glob (car globs)
+ len (length glob)))))
+ (if (and recurse-p (not glob))
+ (error "'**' cannot end a globbing pattern"))
+ (let ((index 1))
+ (setq incl glob)
+ (while (and (eq incl glob)
+ (setq index (string-match "~" glob index)))
+ (if (or (get-text-property index 'escaped glob)
+ (or (= (1+ index) len)))
+ (setq index (1+ index))
+ (setq incl (substring glob 0 index)
+ excl (substring glob (1+ index))))))
+ ;; can't use `directory-file-name' because it strips away text
+ ;; properties in the string
+ (let ((len (1- (length incl))))
+ (if (eq (aref incl len) directory-sep-char)
+ (setq incl (substring incl 0 len)))
+ (when excl
+ (setq len (1- (length excl)))
+ (if (eq (aref excl len) directory-sep-char)
+ (setq excl (substring excl 0 len)))))
+ (setq incl (eshell-glob-regexp incl)
+ excl (and excl (eshell-glob-regexp excl)))
+ (if (or eshell-glob-include-dot-files
+ (eq (aref glob 0) ?.))
+ (unless (or eshell-glob-include-dot-dot
+ (cdr globs))
+ (setq excl (if excl
+ (concat "\\(\\`\\.\\.?\\'\\|" excl "\\)")
+ "\\`\\.\\.?\\'")))
+ (setq excl (if excl
+ (concat "\\(\\`\\.\\|" excl "\\)")
+ "\\`\\.")))
+ (when (and recurse-p eshell-glob-show-progress)
+ (message "Building file list...%d so far: %s"
+ (length matches) path)
+ (setq message-shown t))
+ (if (equal path "./") (setq path ""))
+ (while entries
+ (setq name (car entries)
+ len (length name)
+ isdir (eq (aref name (1- len)) directory-sep-char))
+ (if (let ((fname (directory-file-name name)))
+ (and (not (and excl (string-match excl fname)))
+ (string-match incl fname)))
+ (if (cdr globs)
+ (if isdir
+ (setq dirs (cons (concat path name) dirs)))
+ (setq matches (cons (concat path name) matches))))
+ (if (and recurse-p isdir
+ (or (> len 3)
+ (not (or (and (= len 2) (equal name "./"))
+ (and (= len 3) (equal name "../")))))
+ (setq pathname (concat path name))
+ (not (and (= recurse-p 2)
+ (file-symlink-p
+ (directory-file-name pathname)))))
+ (setq rdirs (cons pathname rdirs)))
+ (setq entries (cdr entries)))
+ (setq dirs (nreverse dirs)
+ rdirs (nreverse rdirs))
+ (while dirs
+ (eshell-glob-entries (car dirs) (cdr globs))
+ (setq dirs (cdr dirs)))
+ (while rdirs
+ (eshell-glob-entries (car rdirs) globs recurse-p)
+ (setq rdirs (cdr rdirs)))))
+
+;;; Code:
+
+;;; em-glob.el ends here
--- /dev/null
+;;; em-hist --- history list management
+
+;; Copyright (C) 1999, 2000 Free Sofware Foundation
+
+;; 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 2, 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+(provide 'em-hist)
+
+(eval-when-compile (require 'esh-maint))
+
+(defgroup eshell-hist nil
+ "This module provides command history management."
+ :tag "History list management"
+ :group 'eshell-module)
+
+;;; Commentary:
+
+;; Eshell's history facility imitates the syntax used by bash
+;; ([(bash)History Interaction]). Thus:
+;;
+;; !ls ; repeat the last command beginning with 'ls'
+;; !?ls ; repeat the last command containing ls
+;; echo !ls:2 ; echo the second arg of the last 'ls' command
+;; !ls<tab> ; complete against all possible words in this
+;; ; position, by looking at the history list
+;; !ls<C-c SPC> ; expand any matching history input at point
+;;
+;; Also, most of `comint-mode's keybindings are accepted:
+;;
+;; M-r ; search backward for a previous command by regexp
+;; M-s ; search forward for a previous command by regexp
+;; M-p ; access the last command entered, repeatable
+;; M-n ; access the first command entered, repeatable
+;;
+;; C-c M-r ; using current input, find a matching command thus, with
+;; ; 'ls' as the current input, it will go back to the same
+;; ; command that '!ls' would have selected
+;; C-c M-s ; same, but in reverse order
+;;
+;; Note that some of these keybindings are only available if the
+;; `eshell-rebind' is not in use, in which case M-p does what C-c M-r
+;; normally would do, and C-p is used instead of M-p. It may seem
+;; confusing, but the intention is to make the most useful
+;; functionality the most easily accessible. If `eshell-rebind' is
+;; not being used, history navigation will use comint's keybindings;
+;; if it is, history navigation tries to use similar keybindings to
+;; bash. This is all configurable, of course.
+
+;;; Code:
+
+(require 'ring)
+(require 'esh-opt)
+(require 'em-pred)
+
+;;; User Variables:
+
+(defcustom eshell-hist-load-hook '(eshell-hist-initialize)
+ "*A list of functions to call when loading `eshell-hist'."
+ :type 'hook
+ :group 'eshell-hist)
+
+(defcustom eshell-hist-unload-hook
+ (list
+ (function
+ (lambda ()
+ (remove-hook 'kill-emacs-hook 'eshell-save-some-history))))
+ "*A hook that gets run when `eshell-hist' is unloaded."
+ :type 'hook
+ :group 'eshell-hist)
+
+(defcustom eshell-history-file-name
+ (concat eshell-directory-name "history")
+ "*If non-nil, name of the file to read/write input history.
+See also `eshell-read-history' and `eshell-write-history'.
+If it is nil, Eshell will use the value of HISTFILE."
+ :type 'file
+ :group 'eshell-hist)
+
+(defcustom eshell-history-size 128
+ "*Size of the input history ring. If nil, use envvar HISTSIZE."
+ :type 'integer
+ :group 'eshell-hist)
+
+(defcustom eshell-hist-ignoredups nil
+ "*If non-nil, don't add input matching the last on the input ring.
+This mirrors the optional behavior of bash."
+ :type 'boolean
+ :group 'eshell-hist)
+
+(defcustom eshell-ask-to-save-history t
+ "*Determine if history should be automatically saved.
+History is always preserved after sanely exiting an Eshell buffer.
+However, when Emacs is being shut down, this variable determines
+whether to prompt the user.
+If set to nil, it means never ask whether history should be saved.
+If set to t, always ask if any Eshell buffers are open at exit time.
+If set to `always', history will always be saved, silently."
+ :type '(choice (const :tag "Never" nil)
+ (const :tag "Ask" t)
+ (const :tag "Always save" always))
+ :group 'eshell-hist)
+
+(defcustom eshell-input-filter
+ (function
+ (lambda (str)
+ (not (string-match "\\`\\s-*\\'" str))))
+ "*Predicate for filtering additions to input history.
+Takes one argument, the input. If non-nil, the input may be saved on
+the input history list. Default is to save anything that isn't all
+whitespace."
+ :type 'function
+ :group 'eshell-hist)
+
+(put 'eshell-input-filter 'risky-local-variable t)
+
+(defcustom eshell-hist-match-partial t
+ "*If non-nil, movement through history is constrained by current input.
+Otherwise, typing <M-p> and <M-n> will always go to the next history
+element, regardless of any text on the command line. In that case,
+<C-c M-r> and <C-c M-s> still offer that functionality."
+ :type 'boolean
+ :group 'eshell-hist)
+
+(defcustom eshell-hist-move-to-end t
+ "*If non-nil, move to the end of the buffer before cycling history."
+ :type 'boolean
+ :group 'eshell-hist)
+
+(defcustom eshell-hist-event-designator
+ "^!\\(!\\|-?[0-9]+\\|\\??[^:^$%*?]+\\??\\|#\\)"
+ "*The regexp used to identifier history event designators."
+ :type 'regexp
+ :group 'eshell-hist)
+
+(defcustom eshell-hist-word-designator
+ "^:?\\([0-9]+\\|[$^%*]\\)?\\(\\*\\|-[0-9]*\\|[$^%*]\\)?"
+ "*The regexp used to identify history word designators."
+ :type 'regexp
+ :group 'eshell-hist)
+
+(defcustom eshell-hist-modifier
+ "^\\(:\\([hretpqx&g]\\|s/\\([^/]*\\)/\\([^/]*\\)/\\)\\)*"
+ "*The regexp used to identity history modifiers."
+ :type 'regexp
+ :group 'eshell-hist)
+
+(defcustom eshell-hist-rebind-keys-alist
+ '(([(control ?p)] . eshell-previous-input)
+ ([(control ?n)] . eshell-next-input)
+ ([(control up)] . eshell-previous-input)
+ ([(control down)] . eshell-next-input)
+ ([(control ?r)] . eshell-isearch-backward)
+ ([(control ?s)] . eshell-isearch-forward)
+ ([(meta ?r)] . eshell-previous-matching-input)
+ ([(meta ?s)] . eshell-next-matching-input)
+ ([(meta ?p)] . eshell-previous-matching-input-from-input)
+ ([(meta ?n)] . eshell-next-matching-input-from-input)
+ ([up] . eshell-previous-matching-input-from-input)
+ ([down] . eshell-next-matching-input-from-input))
+ "*History keys to bind differently if point is in input text."
+ :type '(repeat (cons (vector :tag "Keys to bind"
+ (repeat :inline t sexp))
+ (function :tag "Command")))
+ :group 'eshell-hist)
+
+;;; Internal Variables:
+
+(defvar eshell-history-ring nil)
+(defvar eshell-history-index nil)
+(defvar eshell-matching-input-from-input-string "")
+(defvar eshell-save-history-index nil)
+
+(defvar eshell-isearch-map nil)
+
+(unless eshell-isearch-map
+ (setq eshell-isearch-map (copy-keymap isearch-mode-map))
+ (define-key eshell-isearch-map [(control ?m)] 'eshell-isearch-return)
+ (define-key eshell-isearch-map [return] 'eshell-isearch-return)
+ (define-key eshell-isearch-map [(control ?r)] 'eshell-isearch-repeat-backward)
+ (define-key eshell-isearch-map [(control ?s)] 'eshell-isearch-repeat-forward)
+ (define-key eshell-isearch-map [(control ?g)] 'eshell-isearch-abort)
+ (define-key eshell-isearch-map [backspace] 'eshell-isearch-delete-char)
+ (define-key eshell-isearch-map [delete] 'eshell-isearch-delete-char)
+ (defvar eshell-isearch-cancel-map)
+ (define-prefix-command 'eshell-isearch-cancel-map)
+ (define-key eshell-isearch-map [(control ?c)] 'eshell-isearch-cancel-map)
+ (define-key eshell-isearch-cancel-map [(control ?c)] 'eshell-isearch-cancel))
+
+;;; Functions:
+
+(defun eshell-hist-initialize ()
+ "Initialize the history management code for one Eshell buffer."
+ (make-local-hook 'eshell-expand-input-functions)
+ (add-hook 'eshell-expand-input-functions
+ 'eshell-expand-history-references nil t)
+
+ (when (eshell-using-module 'eshell-cmpl)
+ (make-local-hook 'pcomplete-try-first-hook)
+ (add-hook 'pcomplete-try-first-hook
+ 'eshell-complete-history-reference nil t))
+
+ (if (eshell-using-module 'eshell-rebind)
+ (let ((rebind-alist (symbol-value 'eshell-rebind-keys-alist)))
+ (make-local-variable 'eshell-rebind-keys-alist)
+ (set 'eshell-rebind-keys-alist
+ (append rebind-alist eshell-hist-rebind-keys-alist))
+ (set (make-local-variable 'search-invisible) t)
+ (set (make-local-variable 'search-exit-option) t)
+ (make-local-hook 'isearch-mode-hook)
+ (add-hook 'isearch-mode-hook
+ (function
+ (lambda ()
+ (if (>= (point) eshell-last-output-end)
+ (setq overriding-terminal-local-map
+ eshell-isearch-map)))) nil t)
+ (make-local-hook 'isearch-mode-end-hook)
+ (add-hook 'isearch-mode-end-hook
+ (function
+ (lambda ()
+ (setq overriding-terminal-local-map nil))) nil t))
+ (define-key eshell-mode-map [up] 'eshell-previous-matching-input-from-input)
+ (define-key eshell-mode-map [down] 'eshell-next-matching-input-from-input)
+ (define-key eshell-mode-map [(control up)] 'eshell-previous-input)
+ (define-key eshell-mode-map [(control down)] 'eshell-next-input)
+ (define-key eshell-mode-map [(meta ?r)] 'eshell-previous-matching-input)
+ (define-key eshell-mode-map [(meta ?s)] 'eshell-next-matching-input)
+ (define-key eshell-command-map [(meta ?r)]
+ 'eshell-previous-matching-input-from-input)
+ (define-key eshell-command-map [(meta ?s)]
+ 'eshell-next-matching-input-from-input)
+ (if eshell-hist-match-partial
+ (progn
+ (define-key eshell-mode-map [(meta ?p)]
+ 'eshell-previous-matching-input-from-input)
+ (define-key eshell-mode-map [(meta ?n)]
+ 'eshell-next-matching-input-from-input)
+ (define-key eshell-command-map [(meta ?p)] 'eshell-previous-input)
+ (define-key eshell-command-map [(meta ?n)] 'eshell-next-input))
+ (define-key eshell-mode-map [(meta ?p)] 'eshell-previous-input)
+ (define-key eshell-mode-map [(meta ?n)] 'eshell-next-input)
+ (define-key eshell-command-map [(meta ?p)]
+ 'eshell-previous-matching-input-from-input)
+ (define-key eshell-command-map [(meta ?n)]
+ 'eshell-next-matching-input-from-input)))
+
+ (make-local-variable 'eshell-history-size)
+ (or eshell-history-size
+ (setq eshell-history-size (getenv "HISTSIZE")))
+
+ (make-local-variable 'eshell-history-file-name)
+ (or eshell-history-file-name
+ (setq eshell-history-file-name (getenv "HISTFILE")))
+
+ (make-local-variable 'eshell-history-index)
+ (make-local-variable 'eshell-save-history-index)
+ (make-local-variable 'eshell-history-ring)
+ (if eshell-history-file-name
+ (eshell-read-history nil t))
+ (unless eshell-history-ring
+ (setq eshell-history-ring (make-ring eshell-history-size)))
+
+ (make-local-hook 'eshell-exit-hook)
+ (add-hook 'eshell-exit-hook 'eshell-write-history nil t)
+
+ (add-hook 'kill-emacs-hook 'eshell-save-some-history)
+
+ (make-local-variable 'eshell-input-filter-functions)
+ (add-hook 'eshell-input-filter-functions 'eshell-add-to-history nil t)
+
+ (define-key eshell-command-map [(control ?l)] 'eshell-list-history)
+ (define-key eshell-command-map [(control ?x)] 'eshell-get-next-from-history))
+
+(defun eshell-save-some-history ()
+ "Save the history for any open Eshell buffers."
+ (eshell-for buf (buffer-list)
+ (if (buffer-live-p buf)
+ (with-current-buffer buf
+ (if (and eshell-mode
+ eshell-history-file-name
+ eshell-ask-to-save-history
+ (or (eq eshell-ask-to-save-history 'always)
+ (y-or-n-p
+ (format "Save input history for Eshell buffer `%s'? "
+ (buffer-name buf)))))
+ (eshell-write-history))))))
+
+(defun eshell/history (&rest args)
+ "List in help buffer the buffer's input history."
+ (eshell-init-print-buffer)
+ (eshell-eval-using-options
+ "history" args
+ '((?r "read" nil read-history
+ "read from history file to current history list")
+ (?w "write" nil write-history
+ "write current history list to history file")
+ (?a "append" nil append-history
+ "append current history list to history file")
+ (?h "help" nil nil "display this usage message")
+ :usage "[n] [-rwa [filename]]"
+ :post-usage
+"When Eshell is started, history is read from `eshell-history-file-name'.
+This is also the location where history info will be saved by this command,
+unless a different file is specified on the command line.")
+ (and (or (not (ring-p eshell-history-ring))
+ (ring-empty-p eshell-history-ring))
+ (error "No history"))
+ (let (length command file)
+ (when (and args (string-match "^[0-9]+$" (car args)))
+ (setq length (min (eshell-convert (car args))
+ (ring-length eshell-history-ring))
+ args (cdr args)))
+ (and length
+ (or read-history write-history append-history)
+ (error "history: extra arguments"))
+ (when (and args (stringp (car args)))
+ (setq file (car args)
+ args (cdr args)))
+ (cond
+ (read-history (eshell-read-history file))
+ (write-history (eshell-write-history file))
+ (append-history (eshell-write-history file t))
+ (t
+ (let* ((history nil)
+ (index (1- (or length (ring-length eshell-history-ring))))
+ (ref (- (ring-length eshell-history-ring) index)))
+ ;; We have to build up a list ourselves from the ring vector.
+ (while (>= index 0)
+ (eshell-buffered-print
+ (format "%5d %s\n" ref (eshell-get-history index)))
+ (setq index (1- index)
+ ref (1+ ref)))))))
+ (eshell-flush)
+ nil))
+
+(defun eshell-put-history (input &optional ring at-beginning)
+ "Put a new input line into the history ring."
+ (unless ring (setq ring eshell-history-ring))
+ (subst-char-in-string ?\n ?\177 input t)
+ (if at-beginning
+ (ring-insert-at-beginning ring input)
+ (ring-insert ring input)))
+
+(defun eshell-get-history (index &optional ring)
+ "Get an input line from the history ring."
+ (unless ring (setq ring eshell-history-ring))
+ (let ((input (concat (ring-ref ring index))))
+ (subst-char-in-string ?\177 ?\n input t)
+ input))
+
+(defun eshell-add-to-history ()
+ "Add INPUT to the history ring.
+The input is entered into the input history ring, if the value of
+variable `eshell-input-filter' returns non-nil when called on the
+input."
+ (when (> (1- eshell-last-input-end) eshell-last-input-start)
+ (let ((input (buffer-substring eshell-last-input-start
+ (1- eshell-last-input-end))))
+ (if (and (funcall eshell-input-filter input)
+ (or (null eshell-hist-ignoredups)
+ (not (ring-p eshell-history-ring))
+ (ring-empty-p eshell-history-ring)
+ (not (string-equal (eshell-get-history 0) input))))
+ (eshell-put-history input))
+ (setq eshell-save-history-index eshell-history-ring)
+ (setq eshell-history-index nil))))
+
+(defun eshell-read-history (&optional filename silent)
+ "Sets the buffer's `eshell-history-ring' from a history file.
+The name of the file is given by the variable
+`eshell-history-file-name'. The history ring is of size
+`eshell-history-size', regardless of file size. If
+`eshell-history-file-name' is nil this function does nothing.
+
+If the optional argument SILENT is non-nil, we say nothing about a
+failure to read the history file.
+
+This function is useful for major mode commands and mode hooks.
+
+The structure of the history file should be one input command per
+line, with the most recent command last. See also
+`eshell-hist-ignoredups' and `eshell-write-history'."
+ (let ((file (or filename eshell-history-file-name)))
+ (cond
+ ((or (null file)
+ (equal file ""))
+ nil)
+ ((not (file-readable-p file))
+ (or silent
+ (message "Cannot read history file %s" file)))
+ (t
+ (let* ((count 0)
+ (size eshell-history-size)
+ (ring (make-ring size))
+ (ignore-dups eshell-hist-ignoredups))
+ (with-temp-buffer
+ (insert-file-contents file)
+ ;; Save restriction in case file is already visited...
+ ;; Watch for those date stamps in history files!
+ (goto-char (point-max))
+ (while (and (< count size)
+ (re-search-backward "^[ \t]*\\([^#\n].*\\)[ \t]*$"
+ nil t))
+ (let ((history (match-string 1)))
+ (if (or (null ignore-dups)
+ (ring-empty-p ring)
+ (not (string-equal (ring-ref ring 0) history)))
+ (ring-insert-at-beginning ring history)))
+ (setq count (1+ count))))
+ (setq eshell-history-ring ring
+ eshell-history-index nil))))))
+
+(defun eshell-write-history (&optional filename append)
+ "Writes the buffer's `eshell-history-ring' to a history file.
+The name of the file is given by the variable
+`eshell-history-file-name'. The original contents of the file are
+lost if `eshell-history-ring' is not empty. If
+`eshell-history-file-name' is nil this function does nothing.
+
+Useful within process sentinels.
+
+See also `eshell-read-history'."
+ (let ((file (or filename eshell-history-file-name)))
+ (cond
+ ((or (null file)
+ (equal file "")
+ (null eshell-history-ring)
+ (ring-empty-p eshell-history-ring))
+ nil)
+ ((not (file-writable-p file))
+ (message "Cannot write history file %s" file))
+ (t
+ (let* ((ring eshell-history-ring)
+ (index (ring-length ring)))
+ ;; Write it all out into a buffer first. Much faster, but
+ ;; messier, than writing it one line at a time.
+ (with-temp-buffer
+ (while (> index 0)
+ (setq index (1- index))
+ (insert (ring-ref ring index) ?\n))
+ (eshell-with-private-file-modes
+ (write-region (point-min) (point-max) file append
+ 'no-message))))))))
+
+(defun eshell-list-history ()
+ "List in help buffer the buffer's input history."
+ (interactive)
+ (let (prefix prelen)
+ (save-excursion
+ (if (re-search-backward "!\\(.+\\)" (line-beginning-position) t)
+ (setq prefix (match-string 1)
+ prelen (length prefix))))
+ (if (or (not (ring-p eshell-history-ring))
+ (ring-empty-p eshell-history-ring))
+ (message "No history")
+ (let ((history nil)
+ (history-buffer " *Input History*")
+ (index (1- (ring-length eshell-history-ring)))
+ (conf (current-window-configuration)))
+ ;; We have to build up a list ourselves from the ring vector.
+ (while (>= index 0)
+ (let ((hist (eshell-get-history index)))
+ (if (or (not prefix)
+ (and (>= (length hist) prelen)
+ (string= (substring hist 0 prelen) prefix)))
+ (setq history (cons hist history))))
+ (setq index (1- index)))
+ ;; Change "completion" to "history reference"
+ ;; to make the display accurate.
+ (with-output-to-temp-buffer history-buffer
+ (display-completion-list history)
+ (set-buffer history-buffer)
+ (forward-line 3)
+ (while (search-backward "completion" nil 'move)
+ (replace-match "history reference")))
+ (eshell-redisplay)
+ (message "Hit space to flush")
+ (let ((ch (read-event)))
+ (if (eq ch ?\ )
+ (set-window-configuration conf)
+ (setq unread-command-events (list ch))))))))
+
+(defun eshell-hist-word-reference (ref)
+ "Return the word designator index referred to by REF."
+ (cond
+ ((string-match "^[0-9]+$" ref)
+ (string-to-number ref))
+ ((string= "^" ref) 1)
+ ((string= "$" ref) nil)
+ ((string= "%" ref)
+ (error "`%' history word designator not yet implemented"))))
+
+(defun eshell-hist-parse-arguments (&optional silent b e)
+ "Parse current command arguments in a history-code-friendly way."
+ (let ((end (or e (point)))
+ (begin (or b (save-excursion (eshell-bol) (point))))
+ (posb (list t))
+ (pose (list t))
+ (textargs (list t))
+ hist args)
+ (unless (catch 'eshell-incomplete
+ (ignore
+ (setq args (eshell-parse-arguments begin end))))
+ (save-excursion
+ (goto-char begin)
+ (while (< (point) end)
+ (if (get-text-property (point) 'arg-begin)
+ (nconc posb (list (point))))
+ (if (get-text-property (point) 'arg-end)
+ (nconc pose
+ (list (if (= (1+ (point)) end)
+ (1+ (point))
+ (point)))))
+ (forward-char))
+ (setq posb (cdr posb)
+ pose (cdr pose))
+ (assert (= (length posb) (length args)))
+ (assert (<= (length posb) (length pose))))
+ (setq hist (buffer-substring-no-properties begin end))
+ (let ((b posb) (e pose))
+ (while b
+ (nconc textargs
+ (list (substring hist (- (car b) begin)
+ (- (car e) begin))))
+ (setq b (cdr b)
+ e (cdr e))))
+ (setq textargs (cdr textargs))
+ (assert (= (length textargs) (length args)))
+ (list textargs posb pose))))
+
+(defun eshell-expand-history-references (beg end)
+ "Parse and expand any history references in current input."
+ (let ((result (eshell-hist-parse-arguments t beg end)))
+ (when result
+ (let ((textargs (nreverse (nth 0 result)))
+ (posb (nreverse (nth 1 result)))
+ (pose (nreverse (nth 2 result))))
+ (save-excursion
+ (while textargs
+ (let ((str (eshell-history-reference (car textargs))))
+ (unless (eq str (car textargs))
+ (goto-char (car posb))
+ (insert-and-inherit str)
+ (delete-char (- (car pose) (car posb)))))
+ (setq textargs (cdr textargs)
+ posb (cdr posb)
+ pose (cdr pose))))))))
+
+(defun eshell-complete-history-reference ()
+ "Complete a history reference, by completing the event designator."
+ (let ((arg (pcomplete-actual-arg)))
+ (when (string-match "\\`![^:^$*%]*\\'" arg)
+ (setq pcomplete-stub (substring arg 1)
+ pcomplete-last-completion-raw t)
+ (throw 'pcomplete-completions
+ (let ((history nil)
+ (index (1- (ring-length eshell-history-ring)))
+ (stublen (length pcomplete-stub)))
+ ;; We have to build up a list ourselves from the ring
+ ;; vector.
+ (while (>= index 0)
+ (let ((hist (eshell-get-history index)))
+ (if (and (>= (length hist) stublen)
+ (string= (substring hist 0 stublen)
+ pcomplete-stub)
+ (string-match "^\\([^:^$*% \t\n]+\\)" hist))
+ (setq history (cons (match-string 1 hist)
+ history))))
+ (setq index (1- index)))
+ (let ((fhist (list t)))
+ ;; uniqify the list, but preserve the order
+ (while history
+ (unless (member (car history) fhist)
+ (nconc fhist (list (car history))))
+ (setq history (cdr history)))
+ (cdr fhist)))))))
+
+(defun eshell-history-reference (reference)
+ "Expand directory stack REFERENCE.
+The syntax used here was taken from the Bash info manual.
+Returns the resultant reference, or the same string REFERENCE if none
+matched."
+ ;; `^string1^string2^'
+ ;; Quick Substitution. Repeat the last command, replacing
+ ;; STRING1 with STRING2. Equivalent to `!!:s/string1/string2/'
+ (if (and (eshell-using-module 'eshell-pred)
+ (string-match "\\^\\([^^]+\\)\\^\\([^^]+\\)\\^?\\s-*$"
+ reference))
+ (setq reference (format "!!:s/%s/%s/"
+ (match-string 1 reference)
+ (match-string 2 reference))))
+ ;; `!'
+ ;; Start a history substitution, except when followed by a
+ ;; space, tab, the end of the line, = or (.
+ (if (not (string-match "^![^ \t\n=\(]" reference))
+ reference
+ (setq eshell-history-index nil)
+ (let ((event (eshell-hist-parse-event-designator reference)))
+ (unless event
+ (error "Could not find history event `%s'" reference))
+ (setq eshell-history-index (car event)
+ reference (substring reference (cdr event))
+ event (eshell-get-history eshell-history-index))
+ (if (not (string-match "^[:^$*%]" reference))
+ event
+ (let ((word (eshell-hist-parse-word-designator
+ event reference)))
+ (unless word
+ (error "Unable to honor word designator `%s'" reference))
+ (unless (string-match "^[:^$*%][[$^*%0-9-]" reference)
+ (setcdr word 0))
+ (setq event (car word)
+ reference (substring reference (cdr word)))
+ (if (not (and (eshell-using-module 'eshell-pred)
+ (string-match "^:" reference)))
+ event
+ (eshell-hist-parse-modifier event reference)))))))
+
+(defun eshell-hist-parse-event-designator (reference)
+ "Parse a history event designator beginning in REFERENCE."
+ (let* ((index (string-match eshell-hist-event-designator reference))
+ (end (and index (match-end 0))))
+ (unless index
+ (error "Invalid history event designator `%s'" reference))
+ (let* ((event (match-string 1 reference))
+ (pos
+ (cond
+ ((string= event "!") (ring-length eshell-history-ring))
+ ((string= event "#") (error "!# not yet implemented"))
+ ((string-match "^-?[0-9]+$" event)
+ (let ((num (string-to-number event)))
+ (if (>= num 0)
+ (- (ring-length eshell-history-ring) num)
+ (1- (abs num)))))
+ ((string-match "^\\(\\??\\)\\([^?]+\\)\\??$" event)
+ (let ((pref (if (> (length (match-string 1 event)) 0)
+ "" "^"))
+ (str (match-string 2 event)))
+ (save-match-data
+ (eshell-previous-matching-input-string-position
+ (concat pref (regexp-quote str)) 1))))
+ (t
+ (error "Failed to parse event designator `%s'" event)))))
+ (and pos (cons pos end)))))
+
+(defun eshell-hist-parse-word-designator (hist reference)
+ "Parse a history word designator beginning for HIST in REFERENCE."
+ (let* ((index (string-match eshell-hist-word-designator reference))
+ (end (and index (match-end 0))))
+ (unless (memq (aref reference 0) '(?: ?^ ?$ ?* ?%))
+ (error "Invalid history word designator `%s'" reference))
+ (let ((nth (match-string 1 reference))
+ (mth (match-string 2 reference))
+ (here (point))
+ textargs)
+ (insert hist)
+ (setq textargs (car (eshell-hist-parse-arguments nil here (point))))
+ (delete-region here (point))
+ (if (string= nth "*")
+ (if mth
+ (error "Invalid history word designator `%s'"
+ reference)
+ (setq nth 1 mth "-$")))
+ (if (not mth)
+ (if nth
+ (setq mth nth)
+ (setq nth 0 mth "$"))
+ (if (string= mth "-")
+ (setq mth (- (length textargs) 2))
+ (if (string= mth "*")
+ (setq mth "$")
+ (if (not (and (> (length mth) 1)
+ (eq (aref mth 0) ?-)))
+ (error "Invalid history word designator `%s'"
+ reference)
+ (setq mth (substring mth 1))))))
+ (unless (numberp nth)
+ (setq nth (eshell-hist-word-reference nth)))
+ (unless (numberp mth)
+ (setq mth (eshell-hist-word-reference mth)))
+ (cons (mapconcat 'identity (eshell-sublist textargs nth mth) "")
+ end))))
+
+(defun eshell-hist-parse-modifier (hist reference)
+ "Parse a history modifier beginning for HIST in REFERENCE."
+ (let ((here (point)))
+ (insert reference)
+ (prog1
+ (save-restriction
+ (narrow-to-region here (point))
+ (goto-char (point-min))
+ (let ((modifiers (cdr (eshell-parse-modifiers))))
+ (eshell-for mod modifiers
+ (setq hist (funcall mod hist)))
+ hist))
+ (delete-region here (point)))))
+
+(defun eshell-get-next-from-history ()
+ "After fetching a line from input history, this fetches the next.
+In other words, this recalls the input line after the line you
+recalled last. You can use this to repeat a sequence of input lines."
+ (interactive)
+ (if eshell-save-history-index
+ (progn
+ (setq eshell-history-index (1+ eshell-save-history-index))
+ (eshell-next-input 1))
+ (message "No previous history command")))
+
+(defun eshell-search-arg (arg)
+ ;; First make sure there is a ring and that we are after the process
+ ;; mark
+ (if (and eshell-hist-move-to-end
+ (< (point) eshell-last-output-end))
+ (goto-char eshell-last-output-end))
+ (cond ((or (null eshell-history-ring)
+ (ring-empty-p eshell-history-ring))
+ (error "Empty input ring"))
+ ((zerop arg)
+ ;; arg of zero resets search from beginning, and uses arg of
+ ;; 1
+ (setq eshell-history-index nil)
+ 1)
+ (t
+ arg)))
+
+(defun eshell-search-start (arg)
+ "Index to start a directional search, starting at `eshell-history-index'."
+ (if eshell-history-index
+ ;; If a search is running, offset by 1 in direction of arg
+ (mod (+ eshell-history-index (if (> arg 0) 1 -1))
+ (ring-length eshell-history-ring))
+ ;; For a new search, start from beginning or end, as appropriate
+ (if (>= arg 0)
+ 0 ; First elt for forward search
+ ;; Last elt for backward search
+ (1- (ring-length eshell-history-ring)))))
+
+(defun eshell-previous-input-string (arg)
+ "Return the string ARG places along the input ring.
+Moves relative to `eshell-history-index'."
+ (eshell-get-history (if eshell-history-index
+ (mod (+ arg eshell-history-index)
+ (ring-length eshell-history-ring))
+ arg)))
+
+(defun eshell-previous-input (arg)
+ "Cycle backwards through input history."
+ (interactive "*p")
+ (eshell-previous-matching-input "." arg))
+
+(defun eshell-next-input (arg)
+ "Cycle forwards through input history."
+ (interactive "*p")
+ (eshell-previous-input (- arg)))
+
+(defun eshell-previous-matching-input-string (regexp arg)
+ "Return the string matching REGEXP ARG places along the input ring.
+Moves relative to `eshell-history-index'."
+ (let* ((pos (eshell-previous-matching-input-string-position regexp arg)))
+ (if pos (eshell-get-history pos))))
+
+(defun eshell-previous-matching-input-string-position
+ (regexp arg &optional start)
+ "Return the index matching REGEXP ARG places along the input ring.
+Moves relative to START, or `eshell-history-index'."
+ (if (or (not (ring-p eshell-history-ring))
+ (ring-empty-p eshell-history-ring))
+ (error "No history"))
+ (let* ((len (ring-length eshell-history-ring))
+ (motion (if (> arg 0) 1 -1))
+ (n (mod (- (or start (eshell-search-start arg)) motion) len))
+ (tried-each-ring-item nil)
+ (case-fold-search (eshell-under-windows-p))
+ (prev nil))
+ ;; Do the whole search as many times as the argument says.
+ (while (and (/= arg 0) (not tried-each-ring-item))
+ ;; Step once.
+ (setq prev n
+ n (mod (+ n motion) len))
+ ;; If we haven't reached a match, step some more.
+ (while (and (< n len) (not tried-each-ring-item)
+ (not (string-match regexp (eshell-get-history n))))
+ (setq n (mod (+ n motion) len)
+ ;; If we have gone all the way around in this search.
+ tried-each-ring-item (= n prev)))
+ (setq arg (if (> arg 0) (1- arg) (1+ arg))))
+ ;; Now that we know which ring element to use, if we found it,
+ ;; return that.
+ (if (string-match regexp (eshell-get-history n))
+ n)))
+
+(defun eshell-previous-matching-input (regexp arg)
+ "Search backwards through input history for match for REGEXP.
+\(Previous history elements are earlier commands.)
+With prefix argument N, search for Nth previous match.
+If N is negative, find the next or Nth next match."
+ (interactive (eshell-regexp-arg "Previous input matching (regexp): "))
+ (setq arg (eshell-search-arg arg))
+ (let ((pos (eshell-previous-matching-input-string-position regexp arg)))
+ ;; Has a match been found?
+ (if (null pos)
+ (error "Not found")
+ (setq eshell-history-index pos)
+ (message "History item: %d" (- (ring-length eshell-history-ring) pos))
+ ;; Can't use kill-region as it sets this-command
+ (delete-region (save-excursion (eshell-bol) (point)) (point))
+ (insert-and-inherit (eshell-get-history pos)))))
+
+(defun eshell-next-matching-input (regexp arg)
+ "Search forwards through input history for match for REGEXP.
+\(Later history elements are more recent commands.)
+With prefix argument N, search for Nth following match.
+If N is negative, find the previous or Nth previous match."
+ (interactive (eshell-regexp-arg "Next input matching (regexp): "))
+ (eshell-previous-matching-input regexp (- arg)))
+
+(defun eshell-previous-matching-input-from-input (arg)
+ "Search backwards through input history for match for current input.
+\(Previous history elements are earlier commands.)
+With prefix argument N, search for Nth previous match.
+If N is negative, search forwards for the -Nth following match."
+ (interactive "p")
+ (if (not (memq last-command '(eshell-previous-matching-input-from-input
+ eshell-next-matching-input-from-input)))
+ ;; Starting a new search
+ (setq eshell-matching-input-from-input-string
+ (buffer-substring (save-excursion (eshell-bol) (point))
+ (point))
+ eshell-history-index nil))
+ (eshell-previous-matching-input
+ (concat "^" (regexp-quote eshell-matching-input-from-input-string))
+ arg))
+
+(defun eshell-next-matching-input-from-input (arg)
+ "Search forwards through input history for match for current input.
+\(Following history elements are more recent commands.)
+With prefix argument N, search for Nth following match.
+If N is negative, search backwards for the -Nth previous match."
+ (interactive "p")
+ (eshell-previous-matching-input-from-input (- arg)))
+
+(defun eshell-test-imatch ()
+ "If isearch match good, put point at the beginning and return non-nil."
+ (if (get-text-property (point) 'history)
+ (progn (beginning-of-line) t)
+ (let ((before (point)))
+ (eshell-bol)
+ (if (and (not (bolp))
+ (<= (point) before))
+ t
+ (if isearch-forward
+ (progn
+ (end-of-line)
+ (forward-char))
+ (beginning-of-line)
+ (backward-char))))))
+
+(defun eshell-return-to-prompt ()
+ "Once a search string matches, insert it at the end and go there."
+ (setq isearch-other-end nil)
+ (let ((found (eshell-test-imatch)) before)
+ (while (and (not found)
+ (setq before
+ (funcall (if isearch-forward
+ 're-search-forward
+ 're-search-backward)
+ isearch-string nil t)))
+ (setq found (eshell-test-imatch)))
+ (if (not found)
+ (progn
+ (goto-char eshell-last-output-end)
+ (delete-region (point) (point-max)))
+ (setq before (point))
+ (let ((text (buffer-substring-no-properties
+ (point) (line-end-position)))
+ (orig (marker-position eshell-last-output-end)))
+ (goto-char eshell-last-output-end)
+ (delete-region (point) (point-max))
+ (when (and text (> (length text) 0))
+ (subst-char-in-string ?\177 ?\n text t)
+ (insert text)
+ (put-text-property (1- (point)) (point)
+ 'last-search-pos before)
+ (set-marker eshell-last-output-end orig)
+ (goto-char eshell-last-output-end))))))
+
+(defun eshell-prepare-for-search ()
+ "Make sure the old history file is at the beginning of the buffer."
+ (unless (get-text-property (point-min) 'history)
+ (save-excursion
+ (goto-char (point-min))
+ (let ((end (copy-marker (point) t)))
+ (insert-file-contents eshell-history-file-name)
+ (set-text-properties (point-min) end
+ '(history t invisible t))))))
+
+(defun eshell-isearch-backward (&optional invert)
+ "Do incremental regexp search backward through past commands."
+ (interactive)
+ (let ((inhibit-read-only t) end)
+ (eshell-prepare-for-search)
+ (goto-char (point-max))
+ (set-marker eshell-last-output-end (point))
+ (delete-region (point) (point-max)))
+ (isearch-mode invert t 'eshell-return-to-prompt))
+
+(defun eshell-isearch-repeat-backward (&optional invert)
+ "Do incremental regexp search backward through past commands."
+ (interactive)
+ (let ((old-pos (get-text-property (1- (point-max))
+ 'last-search-pos)))
+ (when old-pos
+ (goto-char old-pos)
+ (if invert
+ (end-of-line)
+ (backward-char)))
+ (setq isearch-forward invert)
+ (isearch-search-and-update)))
+
+(defun eshell-isearch-forward ()
+ "Do incremental regexp search backward through past commands."
+ (interactive)
+ (eshell-isearch-backward t))
+
+(defun eshell-isearch-repeat-forward ()
+ "Do incremental regexp search backward through past commands."
+ (interactive)
+ (eshell-isearch-repeat-backward t))
+
+(defun eshell-isearch-cancel ()
+ (interactive)
+ (goto-char eshell-last-output-end)
+ (delete-region (point) (point-max))
+ (call-interactively 'isearch-cancel))
+
+(defun eshell-isearch-abort ()
+ (interactive)
+ (goto-char eshell-last-output-end)
+ (delete-region (point) (point-max))
+ (call-interactively 'isearch-abort))
+
+(defun eshell-isearch-delete-char ()
+ (interactive)
+ (save-excursion
+ (isearch-delete-char)))
+
+(defun eshell-isearch-return ()
+ (interactive)
+ (isearch-done)
+ (eshell-send-input))
+
+;;; em-hist.el ends here
--- /dev/null
+;;; em-ls --- implementation of ls in Lisp
+
+;; Copyright (C) 1999, 2000 Free Sofware Foundation
+
+;; 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 2, 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+(provide 'em-ls)
+
+(eval-when-compile (require 'esh-maint))
+
+(defgroup eshell-ls nil
+ "This module implements the \"ls\" utility fully in Lisp. If it is
+passed any unrecognized command switches, it will revert to the
+operating system's version. This version of \"ls\" uses text
+properties to colorize its output based on the setting of
+`eshell-ls-use-colors'."
+ :tag "Implementation of `ls' in Lisp"
+ :group 'eshell-module)
+
+;;; Commentary:
+
+;; Most of the command switches recognized by GNU's ls utility are
+;; supported ([(fileutils)ls invocation]).
+
+(require 'esh-util)
+(require 'esh-opt)
+
+;;; User Variables:
+
+(defvar eshell-ls-orig-insert-directory
+ (symbol-function 'insert-directory)
+ "Preserve the original definition of `insert-directory'.")
+
+(defcustom eshell-ls-unload-hook
+ (list
+ (function
+ (lambda ()
+ (fset 'insert-directory eshell-ls-orig-insert-directory))))
+ "*When unloading `eshell-ls', restore the definition of `insert-directory'."
+ :type 'hook
+ :group 'eshell-ls)
+
+(defcustom eshell-ls-use-in-dired nil
+ "*If non-nil, use `eshell-ls' to read directories in dired."
+ :set (lambda (symbol value)
+ (if value
+ (unless (and (boundp 'eshell-ls-use-in-dired)
+ eshell-ls-use-in-dired)
+ (fset 'insert-directory 'eshell-ls-insert-directory))
+ (when (and (boundp 'eshell-ls-insert-directory)
+ eshell-ls-use-in-dired)
+ (fset 'insert-directory eshell-ls-orig-insert-directory)))
+ (setq eshell-ls-use-in-dired value))
+ :type 'boolean
+ :require 'em-ls
+ :group 'eshell-ls)
+
+(defcustom eshell-ls-default-blocksize 1024
+ "*The default blocksize to use when display file sizes with -s."
+ :type 'integer
+ :group 'eshell-ls)
+
+(defcustom eshell-ls-exclude-regexp "\\`\\."
+ "*Unless -a is specified, files matching this regexp will not be shown."
+ :type 'regexp
+ :group 'eshell-ls)
+
+(defcustom eshell-ls-use-colors t
+ "*If non-nil, use colors in file listings."
+ :type 'boolean
+ :group 'eshell-ls)
+
+(defface eshell-ls-directory-face
+ '((((class color) (background light)) (:foreground "Blue" :bold t))
+ (((class color) (background dark)) (:foreground "SkyBlue" :bold t))
+ (t (:bold t)))
+ "*The face used for highlight directories."
+ :group 'eshell-ls)
+
+(defface eshell-ls-symlink-face
+ '((((class color) (background light)) (:foreground "Dark Cyan" :bold t))
+ (((class color) (background dark)) (:foreground "Cyan" :bold t)))
+ "*The face used for highlight symbolic links."
+ :group 'eshell-ls)
+
+(defface eshell-ls-executable-face
+ '((((class color) (background light)) (:foreground "ForestGreen" :bold t))
+ (((class color) (background dark)) (:foreground "Green" :bold t)))
+ "*The face used for highlighting executables (not directories, though)."
+ :group 'eshell-ls)
+
+(defface eshell-ls-readonly-face
+ '((((class color) (background light)) (:foreground "Brown"))
+ (((class color) (background dark)) (:foreground "Pink")))
+ "*The face used for highlighting read-only files."
+ :group 'eshell-ls)
+
+(defface eshell-ls-unreadable-face
+ '((((class color) (background light)) (:foreground "Grey30"))
+ (((class color) (background dark)) (:foreground "DarkGrey")))
+ "*The face used for highlighting unreadable files."
+ :group 'eshell-ls)
+
+(defface eshell-ls-special-face
+ '((((class color) (background light)) (:foreground "Magenta" :bold t))
+ (((class color) (background dark)) (:foreground "Magenta" :bold t)))
+ "*The face used for highlighting non-regular files."
+ :group 'eshell-ls)
+
+(defface eshell-ls-missing-face
+ '((((class color) (background light)) (:foreground "Red" :bold t))
+ (((class color) (background dark)) (:foreground "Red" :bold t)))
+ "*The face used for highlighting non-existant file names."
+ :group 'eshell-ls)
+
+(defcustom eshell-ls-archive-regexp
+ (concat "\\.\\(t\\(a[rz]\\|gz\\)\\|arj\\|lzh\\|"
+ "zip\\|[zZ]\\|gz\\|bz2\\|deb\\|rpm\\)\\'")
+ "*A regular expression that matches names of file archives.
+This typically includes both traditional archives and compressed
+files."
+ :type 'regexp
+ :group 'eshell-ls)
+
+(defface eshell-ls-archive-face
+ '((((class color) (background light)) (:foreground "Orchid" :bold t))
+ (((class color) (background dark)) (:foreground "Orchid" :bold t)))
+ "*The face used for highlighting archived and compressed file names."
+ :group 'eshell-ls)
+
+(defcustom eshell-ls-backup-regexp
+ "\\(\\`\\.?#\\|\\(\\.bak\\|~\\)\\'\\)"
+ "*A regular expression that matches names of backup files."
+ :type 'regexp
+ :group 'eshell-ls)
+
+(defface eshell-ls-backup-face
+ '((((class color) (background light)) (:foreground "OrangeRed"))
+ (((class color) (background dark)) (:foreground "LightSalmon")))
+ "*The face used for highlighting backup file names."
+ :group 'eshell-ls)
+
+(defcustom eshell-ls-product-regexp
+ "\\.\\(elc\\|o\\(bj\\)?\\|a\\||lib\\|res\\)\\'"
+ "*A regular expression that matches names of product files.
+Products are files that get generated from a source file, and hence
+ought to be recreatable if they are deleted."
+ :type 'regexp
+ :group 'eshell-ls)
+
+(defface eshell-ls-product-face
+ '((((class color) (background light)) (:foreground "OrangeRed"))
+ (((class color) (background dark)) (:foreground "LightSalmon")))
+ "*The face used for highlighting files that are build products."
+ :group 'eshell-ls)
+
+(defcustom eshell-ls-clutter-regexp
+ "\\(^texput\\.log\\|^core\\)\\'"
+ "*A regular expression that matches names of junk files.
+These are mainly files that get created for various reasons, but don't
+really need to stick around for very long."
+ :type 'regexp
+ :group 'eshell-ls)
+
+(defface eshell-ls-clutter-face
+ '((((class color) (background light)) (:foreground "OrangeRed" :bold t))
+ (((class color) (background dark)) (:foreground "OrangeRed" :bold t)))
+ "*The face used for highlighting junk file names."
+ :group 'eshell-ls)
+
+(defsubst eshell-ls-filetype-p (attrs type)
+ "Test whether ATTRS specifies a directory."
+ (if (nth 8 attrs)
+ (eq (aref (nth 8 attrs) 0) type)))
+
+(defmacro eshell-ls-applicable (attrs index func file)
+ "Test whether, for ATTRS, the user UID can do what corresponds to INDEX.
+This is really just for efficiency, to avoid having to stat the file
+yet again."
+ `(if (= (user-uid) (nth 2 ,attrs))
+ (not (eq (aref (nth 8 ,attrs) ,index) ?-))
+ (,(eval func) ,file)))
+
+(defcustom eshell-ls-highlight-alist nil
+ "*This alist correlates test functions to color.
+The format of the members of this alist is
+
+ (TEST-SEXP . FACE)
+
+If TEST-SEXP evals to non-nil, that face will be used to highlight the
+name of the file. The first match wins. `file' and `attrs' are in
+scope during the evaluation of TEST-SEXP."
+ :type '(repeat (cons function face))
+ :group 'eshell-ls)
+
+;;; Functions:
+
+(defun eshell-ls-insert-directory
+ (file switches &optional wildcard full-directory-p)
+ "Insert directory listing for FILE, formatted according to SWITCHES.
+Leaves point after the inserted text.
+SWITCHES may be a string of options, or a list of strings.
+Optional third arg WILDCARD means treat FILE as shell wildcard.
+Optional fourth arg FULL-DIRECTORY-P means file is a directory and
+switches do not contain `d', so that a full listing is expected.
+
+This version of the function uses `eshell/ls'. If any of the switches
+passed are not recognized, the operating system's version will be used
+instead."
+ (let ((handler (find-file-name-handler file 'insert-directory)))
+ (if handler
+ (funcall handler 'insert-directory file switches
+ wildcard full-directory-p)
+ (if (stringp switches)
+ (setq switches (split-string switches)))
+ (let (eshell-current-handles
+ eshell-current-subjob-p)
+ ;; use the fancy highlighting in `eshell-ls' rather than font-lock
+ (when (and eshell-ls-use-colors
+ (featurep 'font-lock))
+ (font-lock-mode -1)
+ (if (boundp 'font-lock-buffers)
+ (set 'font-lock-buffers
+ (delq (current-buffer)
+ (symbol-value 'font-lock-buffers)))))
+ (let ((insert-func 'insert)
+ (error-func 'insert)
+ (flush-func 'ignore))
+ (eshell-do-ls (append switches (list file))))))))
+
+(defsubst eshell/ls (&rest args)
+ "An alias version of `eshell-do-ls'."
+ (let ((insert-func 'eshell-buffered-print)
+ (error-func 'eshell-error)
+ (flush-func 'eshell-flush))
+ (eshell-do-ls args)))
+
+(eval-when-compile
+ (defvar block-size)
+ (defvar dereference-links)
+ (defvar dir-literal)
+ (defvar error-func)
+ (defvar flush-func)
+ (defvar human-readable)
+ (defvar ignore-pattern)
+ (defvar insert-func)
+ (defvar listing-style)
+ (defvar numeric-uid-gid)
+ (defvar reverse-list)
+ (defvar show-all)
+ (defvar show-recursive)
+ (defvar show-size)
+ (defvar sort-method))
+
+(defun eshell-do-ls (&rest args)
+ "Implementation of \"ls\" in Lisp, passing ARGS."
+ (funcall flush-func -1)
+ ;; process the command arguments, and begin listing files
+ (eshell-eval-using-options
+ "ls" args
+ `((?a "all" nil show-all
+ "show all files in directory")
+ (?c nil by-ctime sort-method
+ "sort by modification time")
+ (?d "directory" nil dir-literal
+ "list directory entries instead of contents")
+ (?k "kilobytes" 1024 block-size
+ "using 1024 as the block size")
+ (?h "human-readable" 1024 human-readable
+ "print sizes in human readable format")
+ (?H "si" 1000 human-readable
+ "likewise, but use powers of 1000 not 1024")
+ (?I "ignore" t ignore-pattern
+ "do not list implied entries matching pattern")
+ (?l nil long-listing listing-style
+ "use a long listing format")
+ (?n "numeric-uid-gid" nil numeric-uid-gid
+ "list numeric UIDs and GIDs instead of names")
+ (?r "reverse" nil reverse-list
+ "reverse order while sorting")
+ (?s "size" nil show-size
+ "print size of each file, in blocks")
+ (?t nil by-mtime sort-method
+ "sort by modification time")
+ (?u nil by-atime sort-method
+ "sort by last access time")
+ (?x nil by-lines listing-style
+ "list entries by lines instead of by columns")
+ (?C nil by-columns listing-style
+ "list entries by columns")
+ (?L "deference" nil dereference-links
+ "list entries pointed to by symbolic links")
+ (?R "recursive" nil show-recursive
+ "list subdirectories recursively")
+ (?S nil by-size sort-method
+ "sort by file size")
+ (?U nil unsorted sort-method
+ "do not sort; list entries in directory order")
+ (?X nil by-extension sort-method
+ "sort alphabetically by entry extension")
+ (?1 nil single-column listing-style
+ "list one file per line")
+ (nil "help" nil nil
+ "show this usage display")
+ :external "ls"
+ :usage "[OPTION]... [FILE]...
+List information about the FILEs (the current directory by default).
+Sort entries alphabetically across.")
+ ;; setup some defaults, based on what the user selected
+ (unless block-size
+ (setq block-size eshell-ls-default-blocksize))
+ (unless listing-style
+ (setq listing-style 'by-columns))
+ (unless args
+ (setq args (list ".")))
+ (let ((eshell-ls-exclude-regexp eshell-ls-exclude-regexp))
+ (when ignore-pattern
+ (unless (eshell-using-module 'eshell-glob)
+ (error (concat "-I option requires that `eshell-glob'"
+ " be a member of `eshell-modules-list'")))
+ (set-text-properties 0 (length ignore-pattern) nil ignore-pattern)
+ (if eshell-ls-exclude-regexp
+ (setq eshell-ls-exclude-regexp
+ (concat "\\(" eshell-ls-exclude-regexp "\\|"
+ (eshell-glob-regexp ignore-pattern) "\\)"))
+ (setq eshell-ls-exclude-regexp (eshell-glob-regexp ignore-pattern))))
+ ;; list the files!
+ (eshell-ls-entries
+ (mapcar (function
+ (lambda (arg)
+ (cons (if (and (eshell-under-windows-p)
+ (file-name-absolute-p arg))
+ (expand-file-name arg)
+ arg)
+ (file-attributes arg)))) args)
+ t (expand-file-name default-directory)))
+ (funcall flush-func)))
+
+(defsubst eshell-ls-printable-size (filesize &optional by-blocksize)
+ "Return a printable FILESIZE."
+ (eshell-printable-size filesize human-readable
+ (and by-blocksize block-size)
+ eshell-ls-use-colors))
+
+(defsubst eshell-ls-size-string (attrs size-width)
+ "Return the size string for ATTRS length, using SIZE-WIDTH."
+ (let* ((str (eshell-ls-printable-size (nth 7 attrs) t))
+ (len (length str)))
+ (if (< len size-width)
+ (concat (make-string (- size-width len) ? ) str)
+ str)))
+
+(defun eshell-ls-annotate (fileinfo)
+ "Given a FILEINFO object, return a resolved, decorated FILEINFO.
+This means resolving any symbolic links, determining what face the
+name should be displayed as, etc. Think of it as cooking a FILEINFO."
+ (if (not (and (stringp (cadr fileinfo))
+ (or dereference-links
+ (eq listing-style 'long-listing))))
+ (setcar fileinfo (eshell-ls-decorated-name fileinfo))
+ (let (dir attr)
+ (unless (file-name-absolute-p (cadr fileinfo))
+ (setq dir (file-truename
+ (file-name-directory
+ (expand-file-name (car fileinfo))))))
+ (setq attr
+ (file-attributes
+ (let ((target (if dir
+ (expand-file-name (cadr fileinfo) dir)
+ (cadr fileinfo))))
+ (if dereference-links
+ (file-truename target)
+ target))))
+ (if (or dereference-links
+ (string-match "^\\.\\.?$" (car fileinfo)))
+ (progn
+ (setcdr fileinfo attr)
+ (setcar fileinfo (eshell-ls-decorated-name fileinfo)))
+ (assert (eq listing-style 'long-listing))
+ (setcar fileinfo
+ (concat (eshell-ls-decorated-name fileinfo) " -> "
+ (eshell-ls-decorated-name
+ (cons (cadr fileinfo) attr)))))))
+ fileinfo)
+
+(defun eshell-ls-file (fileinfo &optional size-width copy-fileinfo)
+ "Output FILE in long format.
+FILE may be a string, or a cons cell whose car is the filename and
+whose cdr is the list of file attributes."
+ (if (not (cdr fileinfo))
+ (funcall error-func (format "%s: No such file or directory\n"
+ (car fileinfo)))
+ (setq fileinfo
+ (eshell-ls-annotate (if copy-fileinfo
+ (cons (car fileinfo)
+ (cdr fileinfo))
+ fileinfo)))
+ (let ((file (car fileinfo))
+ (attrs (cdr fileinfo)))
+ (if (not (eq listing-style 'long-listing))
+ (if show-size
+ (funcall insert-func (eshell-ls-size-string attrs size-width)
+ " " file "\n")
+ (funcall insert-func file "\n"))
+ (let ((line
+ (concat
+ (if show-size
+ (concat (eshell-ls-size-string attrs size-width) " "))
+ (format
+ "%s%4d %-8s %-8s "
+ (or (nth 8 attrs) "??????????")
+ (or (nth 1 attrs) 0)
+ (or (and (not numeric-uid-gid)
+ (nth 2 attrs)
+ (eshell-substring
+ (user-login-name (nth 2 attrs)) 8))
+ (nth 2 attrs)
+ "")
+ (or (and (not numeric-uid-gid)
+ (nth 3 attrs)
+ (eshell-substring
+ (eshell-group-name (nth 3 attrs)) 8))
+ (nth 3 attrs)
+ ""))
+ (let* ((str (eshell-ls-printable-size (nth 7 attrs)))
+ (len (length str)))
+ (if (< len 8)
+ (concat (make-string (- 8 len) ? ) str)
+ str))
+ " " (format-time-string
+ (concat
+ "%b %e "
+ (if (= (nth 5 (decode-time (current-time)))
+ (nth 5 (decode-time
+ (nth (cond
+ ((eq sort-method 'by-atime) 4)
+ ((eq sort-method 'by-ctime) 6)
+ (t 5)) attrs))))
+ "%H:%M"
+ " %Y")) (nth (cond
+ ((eq sort-method 'by-atime) 4)
+ ((eq sort-method 'by-ctime) 6)
+ (t 5)) attrs)) " ")))
+ (funcall insert-func line file "\n"))))))
+
+(defun eshell-ls-dir (dirinfo &optional insert-name root-dir size-width)
+ "Output the entries in DIRINFO.
+If INSERT-NAME is non-nil, the name of DIRINFO will be output. If
+ROOT-DIR is also non-nil, and a directory name, DIRINFO will be output
+relative to that directory."
+ (let ((dir (car dirinfo)))
+ (if (not (cdr dirinfo))
+ (funcall error-func (format "%s: No such file or directory\n" dir))
+ (if dir-literal
+ (eshell-ls-file dirinfo size-width)
+ (if insert-name
+ (funcall insert-func
+ (eshell-ls-decorated-name
+ (cons (concat
+ (if root-dir
+ (file-relative-name dir root-dir)
+ (expand-file-name dir)))
+ (cdr dirinfo))) ":\n"))
+ (let ((entries
+ (eshell-directory-files-and-attributes dir nil nil t)))
+ (unless show-all
+ (while (and entries
+ (string-match eshell-ls-exclude-regexp
+ (caar entries)))
+ (setq entries (cdr entries)))
+ (let ((e entries))
+ (while (cdr e)
+ (if (string-match eshell-ls-exclude-regexp (car (cadr e)))
+ (setcdr e (cddr e))
+ (setq e (cdr e))))))
+ (when (or (eq listing-style 'long-listing) show-size)
+ (let ((total 0.0))
+ (setq size-width 0)
+ (eshell-for e entries
+ (if (nth 7 (cdr e))
+ (setq total (+ total (nth 7 (cdr e)))
+ size-width
+ (max size-width
+ (length (eshell-ls-printable-size
+ (nth 7 (cdr e)) t))))))
+ (funcall insert-func "total "
+ (eshell-ls-printable-size total t) "\n")))
+ (let ((default-directory (expand-file-name dir)))
+ (if show-recursive
+ (eshell-ls-entries
+ (let ((e entries) (good-entries (list t)))
+ (while e
+ (unless (let ((len (length (caar e))))
+ (and (eq (aref (caar e) 0) ?.)
+ (or (= len 1)
+ (and (= len 2)
+ (eq (aref (caar e) 1) ?.)))))
+ (nconc good-entries (list (car e))))
+ (setq e (cdr e)))
+ (cdr good-entries))
+ nil root-dir)
+ (eshell-ls-files (eshell-ls-sort-entries entries)
+ size-width))))))))
+
+(defsubst eshell-ls-compare-entries (l r inx func)
+ "Compare the time of two files, L and R, the attribute indexed by INX."
+ (let ((lt (nth inx (cdr l)))
+ (rt (nth inx (cdr r))))
+ (if (equal lt rt)
+ (string-lessp (directory-file-name (car l))
+ (directory-file-name (car r)))
+ (funcall func rt lt))))
+
+(defun eshell-ls-sort-entries (entries)
+ "Sort the given ENTRIES, which may be files, directories or both.
+In Eshell's implementation of ls, ENTRIES is always reversed."
+ (if (eq sort-method 'unsorted)
+ (nreverse entries)
+ (sort entries
+ (function
+ (lambda (l r)
+ (let ((result
+ (cond
+ ((eq sort-method 'by-atime)
+ (eshell-ls-compare-entries
+ l r 4 'eshell-time-less-p))
+ ((eq sort-method 'by-mtime)
+ (eshell-ls-compare-entries
+ l r 5 'eshell-time-less-p))
+ ((eq sort-method 'by-ctime)
+ (eshell-ls-compare-entries
+ l r 6 'eshell-time-less-p))
+ ((eq sort-method 'by-size)
+ (eshell-ls-compare-entries
+ l r 7 '<))
+ ((eq sort-method 'by-extension)
+ (let ((lx (file-name-extension
+ (directory-file-name (car l))))
+ (rx (file-name-extension
+ (directory-file-name (car r)))))
+ (cond
+ ((or (and (not lx) (not rx))
+ (equal lx rx))
+ (string-lessp (directory-file-name (car l))
+ (directory-file-name (car r))))
+ ((not lx) t)
+ ((not rx) nil)
+ (t
+ (string-lessp lx rx)))))
+ (t
+ (string-lessp (directory-file-name (car l))
+ (directory-file-name (car r)))))))
+ (if reverse-list
+ (not result)
+ result)))))))
+
+(defun eshell-ls-files (files &optional size-width copy-fileinfo)
+ "Output a list of FILES.
+Each member of FILES is either a string or a cons cell of the form
+\(FILE . ATTRS)."
+ (if (memq listing-style '(long-listing single-column))
+ (eshell-for file files
+ (if file
+ (eshell-ls-file file size-width copy-fileinfo)))
+ (let ((f files)
+ last-f
+ display-files
+ ignore)
+ (while f
+ (if (cdar f)
+ (setq last-f f
+ f (cdr f))
+ (unless ignore
+ (funcall error-func
+ (format "%s: No such file or directory\n" (caar f))))
+ (if (eq f files)
+ (setq files (cdr files)
+ f files)
+ (if (not (cdr f))
+ (progn
+ (setcdr last-f nil)
+ (setq f nil))
+ (setcar f (cadr f))
+ (setcdr f (cddr f))))))
+ (if (not show-size)
+ (setq display-files (mapcar 'eshell-ls-annotate files))
+ (eshell-for file files
+ (let* ((str (eshell-ls-printable-size (nth 7 (cdr file)) t))
+ (len (length str)))
+ (if (< len size-width)
+ (setq str (concat (make-string (- size-width len) ? ) str)))
+ (setq file (eshell-ls-annotate file)
+ display-files (cons (cons (concat str " " (car file))
+ (cdr file))
+ display-files))))
+ (setq display-files (nreverse display-files)))
+ (let* ((col-vals
+ (if (eq listing-style 'by-columns)
+ (eshell-ls-find-column-lengths display-files)
+ (assert (eq listing-style 'by-lines))
+ (eshell-ls-find-column-widths display-files)))
+ (col-widths (car col-vals))
+ (display-files (cdr col-vals))
+ (columns (length col-widths))
+ (col-index 1)
+ need-return)
+ (eshell-for file display-files
+ (let ((name
+ (if (car file)
+ (if show-size
+ (concat (substring (car file) 0 size-width)
+ (eshell-ls-decorated-name
+ (cons (substring (car file) size-width)
+ (cdr file))))
+ (eshell-ls-decorated-name file))
+ "")))
+ (if (< col-index columns)
+ (setq need-return
+ (concat need-return name
+ (make-string
+ (max 0 (- (aref col-widths
+ (1- col-index))
+ (length name))) ? ))
+ col-index (1+ col-index))
+ (funcall insert-func need-return name "\n")
+ (setq col-index 1 need-return nil))))
+ (if need-return
+ (funcall insert-func need-return "\n"))))))
+
+(defun eshell-ls-entries (entries &optional separate root-dir)
+ "Output PATH's directory ENTRIES, formatted according to OPTIONS.
+Each member of ENTRIES may either be a string or a cons cell, the car
+of which is the file name, and the cdr of which is the list of
+attributes.
+If SEPARATE is non-nil, directories name will be entirely separated
+from the filenames. This is the normal behavior, except when doing a
+recursive listing.
+ROOT-DIR, if non-nil, specifies the root directory of the listing, to
+which non-absolute directory names will be made relative if ever they
+need to be printed."
+ (let (dirs files show-names need-return (size-width 0))
+ (eshell-for entry entries
+ (if (and (not dir-literal)
+ (or (eshell-ls-filetype-p (cdr entry) ?d)
+ (and (eshell-ls-filetype-p (cdr entry) ?l)
+ (file-directory-p (car entry)))))
+ (progn
+ (unless separate
+ (setq files (cons entry files)
+ size-width
+ (if show-size
+ (max size-width
+ (length (eshell-ls-printable-size
+ (nth 7 (cdr entry)) t))))))
+ (setq dirs (cons entry dirs)))
+ (setq files (cons entry files)
+ size-width
+ (if show-size
+ (max size-width
+ (length (eshell-ls-printable-size
+ (nth 7 (cdr entry)) t)))))))
+ (when files
+ (eshell-ls-files (eshell-ls-sort-entries files)
+ size-width show-recursive)
+ (setq need-return t))
+ (setq show-names (or show-recursive
+ (> (+ (length files) (length dirs)) 1)))
+ (eshell-for dir (eshell-ls-sort-entries dirs)
+ (if (and need-return (not dir-literal))
+ (funcall insert-func "\n"))
+ (eshell-ls-dir dir show-names
+ (unless (file-name-absolute-p (car dir))
+ root-dir) size-width)
+ (setq need-return t))))
+
+(defun eshell-ls-find-column-widths (files)
+ "Find the best fitting column widths for FILES.
+It will be returned as a vector, whose length is the number of columns
+to use, and each member of which is the width of that column
+\(including spacing)."
+ (let* ((numcols 0)
+ (width 0)
+ (widths
+ (mapcar
+ (function
+ (lambda (file)
+ (+ 2 (length (car file)))))
+ files))
+ ;; must account for the added space...
+ (max-width (+ (window-width) 2))
+ (best-width 0)
+ col-widths)
+
+ ;; determine the largest number of columns in the first row
+ (let ((w widths))
+ (while (and w (< width max-width))
+ (setq width (+ width (car w))
+ numcols (1+ numcols)
+ w (cdr w))))
+
+ ;; refine it based on the following rows
+ (while (> numcols 0)
+ (let ((i 0)
+ (colw (make-vector numcols 0))
+ (w widths))
+ (while w
+ (if (= i numcols)
+ (setq i 0))
+ (aset colw i (max (aref colw i) (car w)))
+ (setq w (cdr w) i (1+ i)))
+ (setq i 0 width 0)
+ (while (< i numcols)
+ (setq width (+ width (aref colw i))
+ i (1+ i)))
+ (if (and (< width max-width)
+ (> width best-width))
+ (setq col-widths colw
+ best-width width)))
+ (setq numcols (1- numcols)))
+
+ (cons (or col-widths (vector max-width)) files)))
+
+(defun eshell-ls-find-column-lengths (files)
+ "Find the best fitting column lengths for FILES.
+It will be returned as a vector, whose length is the number of columns
+to use, and each member of which is the width of that column
+\(including spacing)."
+ (let* ((numcols 1)
+ (width 0)
+ (widths
+ (mapcar
+ (function
+ (lambda (file)
+ (+ 2 (length (car file)))))
+ files))
+ (max-width (+ (window-width) 2))
+ col-widths
+ colw)
+
+ ;; refine it based on the following rows
+ (while numcols
+ (let* ((rows (ceiling (/ (length widths)
+ (float numcols))))
+ (w widths)
+ (len (* rows numcols))
+ (index 0)
+ (i 0))
+ (setq width 0)
+ (unless (or (= rows 0)
+ (<= (/ (length widths) (float rows))
+ (float (1- numcols))))
+ (setq colw (make-vector numcols 0))
+ (while (> len 0)
+ (if (= i numcols)
+ (setq i 0 index (1+ index)))
+ (aset colw i
+ (max (aref colw i)
+ (or (nth (+ (* i rows) index) w) 0)))
+ (setq len (1- len) i (1+ i)))
+ (setq i 0)
+ (while (< i numcols)
+ (setq width (+ width (aref colw i))
+ i (1+ i))))
+ (if (>= width max-width)
+ (setq numcols nil)
+ (if colw
+ (setq col-widths colw))
+ (if (>= numcols (length widths))
+ (setq numcols nil)
+ (setq numcols (1+ numcols))))))
+
+ (if (not col-widths)
+ (cons (vector max-width) files)
+ (setq numcols (length col-widths))
+ (let* ((rows (ceiling (/ (length widths)
+ (float numcols))))
+ (len (* rows numcols))
+ (newfiles (make-list len nil))
+ (index 0)
+ (i 0)
+ (j 0))
+ (while (< j len)
+ (if (= i numcols)
+ (setq i 0 index (1+ index)))
+ (setcar (nthcdr j newfiles)
+ (nth (+ (* i rows) index) files))
+ (setq j (1+ j) i (1+ i)))
+ (cons col-widths newfiles)))))
+
+(defun eshell-ls-decorated-name (file)
+ "Return FILE, possibly decorated.
+Use TRUENAME for predicate tests, if passed."
+ (if eshell-ls-use-colors
+ (let ((face
+ (cond
+ ((not (cdr file))
+ 'eshell-ls-missing-face)
+
+ ((stringp (cadr file))
+ 'eshell-ls-symlink-face)
+
+ ((eq (cadr file) t)
+ 'eshell-ls-directory-face)
+
+ ((not (eshell-ls-filetype-p (cdr file) ?-))
+ 'eshell-ls-special-face)
+
+ ((and (not (= (user-uid) 0)) ; root can execute anything
+ (eshell-ls-applicable (cdr file) 3
+ 'file-executable-p (car file)))
+ 'eshell-ls-executable-face)
+
+ ((not (eshell-ls-applicable (cdr file) 1
+ 'file-readable-p (car file)))
+ 'eshell-ls-unreadable-face)
+
+ ((string-match eshell-ls-archive-regexp (car file))
+ 'eshell-ls-archive-face)
+
+ ((string-match eshell-ls-backup-regexp (car file))
+ 'eshell-ls-backup-face)
+
+ ((string-match eshell-ls-product-regexp (car file))
+ 'eshell-ls-product-face)
+
+ ((string-match eshell-ls-clutter-regexp (car file))
+ 'eshell-ls-clutter-face)
+
+ ((not (eshell-ls-applicable (cdr file) 2
+ 'file-writable-p (car file)))
+ 'eshell-ls-readonly-face)
+ (eshell-ls-highlight-alist
+ (let ((tests eshell-ls-highlight-alist)
+ value)
+ (while tests
+ (if (funcall (caar tests) (car file) (cdr file))
+ (setq value (cdar tests) tests nil)
+ (setq tests (cdr tests))))
+ value)))))
+ (if face
+ (add-text-properties 0 (length (car file))
+ (list 'face face)
+ (car file)))))
+ (car file))
+
+;;; Code:
+
+;;; em-ls.el ends here
--- /dev/null
+;;; em-pred --- argument predicates and modifiers (ala zsh)
+
+;; Copyright (C) 1999, 2000 Free Sofware Foundation
+
+;; 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 2, 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+(provide 'em-pred)
+
+(eval-when-compile (require 'esh-maint))
+
+(defgroup eshell-pred nil
+ "This module allows for predicates to be applied to globbing
+patterns (similar to zsh), in addition to string modifiers which can
+be applied either to globbing results, variable references, or just
+ordinary strings."
+ :tag "Value modifiers and predicates"
+ :group 'eshell-module)
+
+;;; Commentary:
+
+;; Argument predication is used to affect which members of a list are
+;; selected for use as argument. This is most useful with globbing,
+;; but can be used on any list argument, to select certain members.
+;;
+;; Argument modifiers are used to manipulate argument values. For
+;; example, sorting lists, upcasing words, substituting characters,
+;; etc.
+;;
+;; Here are some examples of how to use argument predication. Most of
+;; the predicates and modifiers are modeled after those provided by
+;; zsh.
+;;
+;; ls -ld *(/) ; list all directories
+;; ls -l *(@u'johnw') ; list all symlinks owned by 'johnw'
+;; bzip2 -9v **/*(a+30) ; compress everything which hasn't been
+;; accessed in 30 days
+;; echo *.c(:o:R) ; a reversed, sorted list of C files
+;; *(^@:U^u0) ; all non-symlinks not owned by 'root', upcased
+;; chmod u-x *(U*) : remove exec bit on all executables owned by user
+;;
+;; See the zsh docs for more on the syntax ([(zsh.info)Filename
+;; Generation]).
+
+;;; User Variables:
+
+(defcustom eshell-pred-load-hook '(eshell-pred-initialize)
+ "*A list of functions to run when `eshell-pred' is loaded."
+ :type 'hook
+ :group 'eshell-pred)
+
+(defcustom eshell-predicate-alist
+ '((?/ . (eshell-pred-file-type ?d)) ; directories
+ (?. . (eshell-pred-file-type ?-)) ; regular files
+ (?s . (eshell-pred-file-type ?s)) ; sockets
+ (?p . (eshell-pred-file-type ?p)) ; named pipes
+ (?@ . (eshell-pred-file-type ?l)) ; symbolic links
+ (?% . (eshell-pred-file-type ?%)) ; allow user to specify (c def.)
+ (?r . (eshell-pred-file-mode 0400)) ; owner-readable
+ (?w . (eshell-pred-file-mode 0200)) ; owner-writable
+ (?x . (eshell-pred-file-mode 0100)) ; owner-executable
+ (?A . (eshell-pred-file-mode 0040)) ; group-readable
+ (?I . (eshell-pred-file-mode 0020)) ; group-writable
+ (?E . (eshell-pred-file-mode 0010)) ; group-executable
+ (?R . (eshell-pred-file-mode 0004)) ; world-readable
+ (?W . (eshell-pred-file-mode 0002)) ; world-writable
+ (?X . (eshell-pred-file-mode 0001)) ; world-executable
+ (?s . (eshell-pred-file-mode 4000)) ; setuid
+ (?S . (eshell-pred-file-mode 2000)) ; setgid
+ (?t . (eshell-pred-file-mode 1000)) ; sticky bit
+ (?U . '(lambda (file) ; owned by effective uid
+ (if (file-exists-p file)
+ (= (nth 2 (file-attributes file)) (user-uid)))))
+;;; (?G . '(lambda (file) ; owned by effective gid
+;;; (if (file-exists-p file)
+;;; (= (nth 2 (file-attributes file)) (user-uid)))))
+ (?* . '(lambda (file)
+ (and (file-regular-p file)
+ (not (file-symlink-p file))
+ (file-executable-p file))))
+ (?l . (eshell-pred-file-links))
+ (?u . (eshell-pred-user-or-group ?u "user" 2 'eshell-user-id))
+ (?g . (eshell-pred-user-or-group ?g "group" 3 'eshell-group-id))
+ (?a . (eshell-pred-file-time ?a "access" 4))
+ (?m . (eshell-pred-file-time ?m "modification" 5))
+ (?c . (eshell-pred-file-time ?c "change" 6))
+ (?L . (eshell-pred-file-size)))
+ "*A list of predicates than can be applied to a globbing pattern.
+The format of each entry is
+
+ (CHAR . PREDICATE-FUNC-SEXP)"
+ :type '(repeat (cons character sexp))
+ :group 'eshell-pred)
+
+(put 'eshell-predicate-alist 'risky-local-variable t)
+
+(defcustom eshell-modifier-alist
+ '((?e . '(lambda (lst)
+ (mapcar
+ (function
+ (lambda (str)
+ (eshell-stringify
+ (car (eshell-parse-argument str))))) lst)))
+ (?L . '(lambda (lst)
+ (mapcar 'downcase lst)))
+ (?U . '(lambda (lst)
+ (mapcar 'upcase lst)))
+ (?C . '(lambda (lst)
+ (mapcar 'capitalize lst)))
+ (?h . '(lambda (lst)
+ (mapcar 'file-name-directory lst)))
+ (?i . (eshell-include-members))
+ (?x . (eshell-include-members t))
+ (?r . '(lambda (lst)
+ (mapcar 'file-name-sans-extension lst)))
+ (?e . '(lambda (lst)
+ (mapcar 'file-name-extension lst)))
+ (?t . '(lambda (lst)
+ (mapcar 'file-name-nondirectory lst)))
+ (?q . '(lambda (lst)
+ (mapcar 'eshell-escape-arg lst)))
+ (?u . '(lambda (lst)
+ (eshell-uniqify-list lst)))
+ (?o . '(lambda (lst)
+ (sort lst 'string-lessp)))
+ (?O . '(lambda (lst)
+ (nreverse (sort lst 'string-lessp))))
+ (?j . (eshell-join-members))
+ (?S . (eshell-split-members))
+ (?R . 'reverse)
+ (?g . (progn
+ (forward-char)
+ (if (eq (char-before) ?s)
+ (eshell-pred-substitute t)
+ (error "`g' modifier cannot be used alone"))))
+ (?s . (eshell-pred-substitute)))
+ "*A list of modifiers than can be applied to an argument expansion.
+The format of each entry is
+
+ (CHAR ENTRYWISE-P MODIFIER-FUNC-SEXP)"
+ :type '(repeat (cons character sexp))
+ :group 'eshell-pred)
+
+(put 'eshell-modifier-alist 'risky-local-variable t)
+
+(defvar eshell-predicate-help-string
+ "Eshell predicate quick reference:
+
+ - follow symbolic references for predicates after the `-'
+ ^ invert sense of predicates after the `^'
+
+FILE TYPE:
+ / directories s sockets
+ . regular files p named pipes
+ * executable (files only) @ symbolic links
+
+ %x file type == `x' (as by ls -l; so `c' = char device, etc.)
+
+PERMISSION BITS (for owner/group/world):
+ r/A/R readable s setuid
+ w/I/W writable S setgid
+ x/E/X executable t sticky bit
+
+OWNERSHIP:
+ U owned by effective uid
+ u(UID|'user') owned by UID/user
+ g(GID|'group') owned by GID/group
+
+FILE ATTRIBUTES:
+ l[+-]N +/-/= N links
+ a[Mwhm][+-](N|'FILE') access time +/-/= N mnths/weeks/days/mins
+ if FILE specified, use as comparison basis;
+ so a+'file.c' shows files accessed before
+ file.c was last accessed
+ m[Mwhm][+-](N|'FILE') modification time...
+ c[Mwhm][+-](N|'FILE') change time...
+ L[kmp][+-]N file size +/-/= N Kb/Mb/blocks
+
+EXAMPLES:
+ *(^@) all non-dot files which are not symlinks
+ .#*(^@) all files which are not symbolic links
+ **/.#*(*) all executable files, searched recursively
+ ***/*~f*(-/) recursively (though not traversing symlinks),
+ find all directories (or symlinks referring to
+ directories) whose names do not begin with f.
+ e*(*Lk+50) executables 50k or larger beginning with 'e'")
+
+(defvar eshell-modifier-help-string
+ "Eshell modifier quick reference:
+
+FOR SINGLE ARGUMENTS, or each argument of a list of strings:
+ e evaluate again
+ L lowercase
+ U uppercase
+ C capitalize
+ h dirname
+ t basename
+ e file extension
+ r strip file extension
+ q escape special characters
+
+ S split string at any whitespace character
+ S/PAT/ split string at each occurance of PAT
+
+FOR LISTS OF ARGUMENTS:
+ o sort alphabetically
+ O reverse sort alphabetically
+ u uniq list (typically used after :o or :O)
+ R reverse list
+
+ j join list members, separated by a space
+ j/PAT/ join list members, separated by PAT
+ i/PAT/ exclude all members not matching PAT
+ x/PAT/ exclude all members matching PAT
+
+ s/pat/match/ substitute PAT with MATCH
+ g/pat/match/ substitute PAT with MATCH for all occurances
+
+EXAMPLES:
+ *.c(:o) sorted list of .c files")
+
+;;; Functions:
+
+(defun eshell-display-predicate-help ()
+ (interactive)
+ (with-electric-help
+ (function
+ (lambda ()
+ (insert eshell-predicate-help-string)))))
+
+(defun eshell-display-modifier-help ()
+ (interactive)
+ (with-electric-help
+ (function
+ (lambda ()
+ (insert eshell-modifier-help-string)))))
+
+(defun eshell-pred-initialize ()
+ "Initialize the predicate/modifier code."
+ (make-local-hook 'eshell-parse-argument-hook)
+ (add-hook 'eshell-parse-argument-hook
+ 'eshell-parse-arg-modifier t t)
+ (define-key eshell-command-map [(meta ?q)] 'eshell-display-predicate-help)
+ (define-key eshell-command-map [(meta ?m)] 'eshell-display-modifier-help))
+
+(defun eshell-apply-modifiers (lst predicates modifiers)
+ "Apply to LIST a series of PREDICATES and MODIFIERS."
+ (let (stringified)
+ (if (stringp lst)
+ (setq lst (list lst)
+ stringified t))
+ (when (listp lst)
+ (setq lst (eshell-winnow-list lst nil predicates))
+ (while modifiers
+ (setq lst (funcall (car modifiers) lst)
+ modifiers (cdr modifiers)))
+ (if (and stringified
+ (= (length lst) 1))
+ (car lst)
+ lst))))
+
+(defun eshell-parse-arg-modifier ()
+ "Parse a modifier that has been specified after an argument.
+This function is specially for adding onto `eshell-parse-argument-hook'."
+ (when (eq (char-after) ?\()
+ (forward-char)
+ (let ((end (eshell-find-delimiter ?\( ?\))))
+ (if (not end)
+ (throw 'eshell-incomplete ?\()
+ (when (eshell-arg-delimiter (1+ end))
+ (save-restriction
+ (narrow-to-region (point) end)
+ (let* ((modifiers (eshell-parse-modifiers))
+ (preds (car modifiers))
+ (mods (cdr modifiers)))
+ (if (or preds mods)
+ ;; has to go at the end, which is only natural since
+ ;; syntactically it can only occur at the end
+ (setq eshell-current-modifiers
+ (append
+ eshell-current-modifiers
+ (list
+ `(lambda (lst)
+ (eshell-apply-modifiers
+ lst (quote ,preds) (quote ,mods)))))))))
+ (goto-char (1+ end))
+ (eshell-finish-arg))))))
+
+(defun eshell-parse-modifiers ()
+ "Parse value modifiers and predicates at point.
+If ALLOW-PREDS is non-nil, predicates will be parsed as well.
+Return a cons cell of the form
+
+ (PRED-FUNC-LIST . MOD-FUNC-LIST)
+
+NEW-STRING is STRING minus any modifiers. PRED-FUNC-LIST is a list of
+predicate functions. MOD-FUNC-LIST is a list of result modifier
+functions. PRED-FUNCS take a filename and return t if the test
+succeeds; MOD-FUNCS take any string and preform a modification,
+returning the resultant string."
+ (let (result negate follow preds mods)
+ (condition-case err
+ (while (not (eobp))
+ (let ((char (char-after)))
+ (cond
+ ((eq char ?')
+ (forward-char)
+ (if (looking-at "[^|':]")
+ (let ((func (read (current-buffer))))
+ (if (and func (functionp func))
+ (setq preds (eshell-add-pred-func func preds
+ negate follow))
+ (error "Invalid function predicate '%s'"
+ (eshell-stringify func))))
+ (error "Invalid function predicate")))
+ ((eq char ?^)
+ (forward-char)
+ (setq negate (not negate)))
+ ((eq char ?-)
+ (forward-char)
+ (setq follow (not follow)))
+ ((eq char ?|)
+ (forward-char)
+ (if (looking-at "[^|':]")
+ (let ((func (read (current-buffer))))
+ (if (and func (functionp func))
+ (setq mods
+ (cons `(lambda (lst)
+ (mapcar (function ,func) lst))
+ mods))
+ (error "Invalid function modifier '%s'"
+ (eshell-stringify func))))
+ (error "Invalid function modifier")))
+ ((eq char ?:)
+ (forward-char)
+ (let ((mod (assq (char-after) eshell-modifier-alist)))
+ (if (not mod)
+ (error "Unknown modifier character '%c'" (char-after))
+ (forward-char)
+ (setq mods (cons (eval (cdr mod)) mods)))))
+ (t
+ (let ((pred (assq char eshell-predicate-alist)))
+ (if (not pred)
+ (error "Unknown predicate character '%c'" char)
+ (forward-char)
+ (setq preds
+ (eshell-add-pred-func (eval (cdr pred)) preds
+ negate follow))))))))
+ (end-of-buffer
+ (error "Predicate or modifier ended prematurely")))
+ (cons (nreverse preds) (nreverse mods))))
+
+(defun eshell-add-pred-func (pred funcs negate follow)
+ "Add the predicate function PRED to FUNCS."
+ (if negate
+ (setq pred `(lambda (file)
+ (not (funcall ,pred file)))))
+ (if follow
+ (setq pred `(lambda (file)
+ (funcall ,pred (file-truename file)))))
+ (cons pred funcs))
+
+(defun eshell-pred-user-or-group (mod-char mod-type attr-index get-id-func)
+ "Return a predicate to test whether a file match a given user/group id."
+ (let (ugid open close end)
+ (if (looking-at "[0-9]+")
+ (progn
+ (setq ugid (string-to-number (match-string 0)))
+ (goto-char (match-end 0)))
+ (setq open (char-after))
+ (if (setq close (memq open '(?\( ?\[ ?\< ?\{)))
+ (setq close (car (last '(?\) ?\] ?\> ?\})
+ (length close))))
+ (setq close open))
+ (forward-char)
+ (setq end (eshell-find-delimiter open close))
+ (unless end
+ (error "Malformed %s name string for modifier `%c'"
+ mod-type mod-char))
+ (setq ugid
+ (funcall get-id-func (buffer-substring (point) end)))
+ (goto-char (1+ end)))
+ (unless ugid
+ (error "Unknown %s name specified for modifier `%c'"
+ mod-type mod-char))
+ `(lambda (file)
+ (let ((attrs (file-attributes file)))
+ (if attrs
+ (= (nth ,attr-index attrs) ,ugid))))))
+
+(defun eshell-pred-file-time (mod-char mod-type attr-index)
+ "Return a predicate to test whether a file matches a certain time."
+ (let* ((quantum 86400)
+ qual amount when open close end)
+ (when (memq (char-after) '(?M ?w ?h ?m))
+ (setq quantum (char-after))
+ (cond
+ ((eq quantum ?M)
+ (setq quantum (* 60 60 24 30)))
+ ((eq quantum ?w)
+ (setq quantum (* 60 60 24 7)))
+ ((eq quantum ?h)
+ (setq quantum (* 60 60)))
+ ((eq quantum ?m)
+ (setq quantum 60))
+ ((eq quantum ?s)
+ (setq quantum 1)))
+ (forward-char))
+ (when (memq (char-after) '(?+ ?-))
+ (setq qual (char-after))
+ (forward-char))
+ (if (looking-at "[0-9]+")
+ (progn
+ (setq when (- (eshell-time-to-seconds (current-time))
+ (* (string-to-number (match-string 0))
+ quantum)))
+ (goto-char (match-end 0)))
+ (setq open (char-after))
+ (if (setq close (memq open '(?\( ?\[ ?\< ?\{)))
+ (setq close (car (last '(?\) ?\] ?\> ?\})
+ (length close))))
+ (setq close open))
+ (forward-char)
+ (setq end (eshell-find-delimiter open close))
+ (unless end
+ (error "Malformed %s time modifier `%c'" mod-type mod-char))
+ (let* ((file (buffer-substring (point) end))
+ (attrs (file-attributes file)))
+ (unless attrs
+ (error "Cannot stat file `%s'" file))
+ (setq when (eshell-time-to-seconds (nth attr-index attrs))))
+ (goto-char (1+ end)))
+ `(lambda (file)
+ (let ((attrs (file-attributes file)))
+ (if attrs
+ (,(if (eq qual ?-)
+ '<
+ (if (eq qual ?+)
+ '>
+ '=)) ,when (eshell-time-to-seconds
+ (nth ,attr-index attrs))))))))
+
+(defun eshell-pred-file-type (type)
+ "Return a test which tests that the file is of a certain TYPE.
+TYPE must be a character, and should be one of the possible options
+that 'ls -l' will show in the first column of its display. "
+ (when (eq type ?%)
+ (setq type (char-after))
+ (if (memq type '(?b ?c))
+ (forward-char)
+ (setq type ?%)))
+ `(lambda (file)
+ (let ((attrs (file-attributes (directory-file-name file))))
+ (if attrs
+ (memq (aref (nth 8 attrs) 0)
+ ,(if (eq type ?%)
+ '(?b ?c)
+ (list 'quote (list type))))))))
+
+(defsubst eshell-pred-file-mode (mode)
+ "Return a test which tests that MODE pertains to the file."
+ `(lambda (file)
+ (let ((modes (file-modes file)))
+ (if modes
+ (logand ,mode modes)))))
+
+(defun eshell-pred-file-links ()
+ "Return a predicate to test whether a file has a given number of links."
+ (let (qual amount)
+ (when (memq (char-after) '(?- ?+))
+ (setq qual (char-after))
+ (forward-char))
+ (unless (looking-at "[0-9]+")
+ (error "Invalid file link count modifier `l'"))
+ (setq amount (string-to-number (match-string 0)))
+ (goto-char (match-end 0))
+ `(lambda (file)
+ (let ((attrs (file-attributes file)))
+ (if attrs
+ (,(if (eq qual ?-)
+ '<
+ (if (eq qual ?+)
+ '>
+ '=)) (nth 1 attrs) ,amount))))))
+
+(defun eshell-pred-file-size ()
+ "Return a predicate to test whether a file is of a given size."
+ (let ((quantum 1) qual amount)
+ (when (memq (downcase (char-after)) '(?k ?m ?p))
+ (setq qual (downcase (char-after)))
+ (cond
+ ((eq qual ?k)
+ (setq quantum 1024))
+ ((eq qual ?m)
+ (setq quantum (* 1024 1024)))
+ ((eq qual ?p)
+ (setq quantum 512)))
+ (forward-char))
+ (when (memq (char-after) '(?- ?+))
+ (setq qual (char-after))
+ (forward-char))
+ (unless (looking-at "[0-9]+")
+ (error "Invalid file size modifier `L'"))
+ (setq amount (* (string-to-number (match-string 0)) quantum))
+ (goto-char (match-end 0))
+ `(lambda (file)
+ (let ((attrs (file-attributes file)))
+ (if attrs
+ (,(if (eq qual ?-)
+ '<
+ (if (eq qual ?+)
+ '>
+ '=)) (nth 7 attrs) ,amount))))))
+
+(defun eshell-pred-substitute (&optional repeat)
+ "Return a modifier function that will substitute matches."
+ (let ((delim (char-after))
+ match replace end)
+ (forward-char)
+ (setq end (eshell-find-delimiter delim delim nil nil t)
+ match (buffer-substring-no-properties (point) end))
+ (goto-char (1+ end))
+ (setq end (eshell-find-delimiter delim delim nil nil t)
+ replace (buffer-substring-no-properties (point) end))
+ (goto-char (1+ end))
+ (if repeat
+ `(lambda (lst)
+ (mapcar
+ (function
+ (lambda (str)
+ (let ((i 0))
+ (while (setq i (string-match ,match str i))
+ (setq str (replace-match ,replace t nil str))))
+ str)) lst))
+ `(lambda (lst)
+ (mapcar
+ (function
+ (lambda (str)
+ (if (string-match ,match str)
+ (setq str (replace-match ,replace t nil str)))
+ str)) lst)))))
+
+(defun eshell-include-members (&optional invert-p)
+ "Include only lisp members matching a regexp."
+ (let ((delim (char-after))
+ regexp end)
+ (forward-char)
+ (setq end (eshell-find-delimiter delim delim nil nil t)
+ regexp (buffer-substring-no-properties (point) end))
+ (goto-char (1+ end))
+ `(lambda (lst)
+ (eshell-winnow-list
+ lst nil '((lambda (elem)
+ ,(if invert-p
+ `(not (string-match ,regexp elem))
+ `(string-match ,regexp elem))))))))
+
+(defun eshell-join-members ()
+ "Return a modifier function that join matches."
+ (let ((delim (char-after))
+ str end)
+ (if (not (memq delim '(?' ?/)))
+ (setq delim " ")
+ (forward-char)
+ (setq end (eshell-find-delimiter delim delim nil nil t)
+ str (buffer-substring-no-properties (point) end))
+ (goto-char (1+ end)))
+ `(lambda (lst)
+ (mapconcat 'identity lst ,str))))
+
+(defun eshell-split-members ()
+ "Return a modifier function that splits members."
+ (let ((delim (char-after))
+ sep end)
+ (when (memq delim '(?' ?/))
+ (forward-char)
+ (setq end (eshell-find-delimiter delim delim nil nil t)
+ sep (buffer-substring-no-properties (point) end))
+ (goto-char (1+ end)))
+ `(lambda (lst)
+ (mapcar
+ (function
+ (lambda (str)
+ (split-string str ,sep))) lst))))
+
+;;; Code:
+
+;;; em-pred.el ends here
--- /dev/null
+;;; em-prompt --- command prompts
+
+;; Copyright (C) 1999, 2000 Free Sofware Foundation
+
+;; 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 2, 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+(provide 'em-prompt)
+
+(eval-when-compile (require 'esh-maint))
+
+(defgroup eshell-prompt nil
+ "This module provides command prompts, and navigation between them,
+as is common with most shells."
+ :tag "Command prompts"
+ :group 'eshell-module)
+
+;;; Commentary:
+
+;; Most of the prompt navigation commands of `comint-mode' are
+;; supported, such as C-c C-n, C-c C-p, etc.
+
+;;; User Variables:
+
+(defcustom eshell-prompt-load-hook '(eshell-prompt-initialize)
+ "*A list of functions to call when loading `eshell-prompt'."
+ :type 'hook
+ :group 'eshell-prompt)
+
+(defcustom eshell-prompt-function
+ (function
+ (lambda ()
+ (concat (eshell/pwd)
+ (if (= (user-uid) 0) " # " " $ "))))
+ "*A function that returns the Eshell prompt string.
+Make sure to update `eshell-prompt-regexp' so that it will match your
+prompt."
+ :type 'function
+ :group 'eshell-prompt)
+
+(defcustom eshell-prompt-regexp "^[^#$\n]* [#$] "
+ "*A regexp which fully matches your eshell prompt.
+This setting is important, since it affects how eshell will interpret
+the lines that are passed to it.
+If this variable is changed, all Eshell buffers must be exited and
+re-entered for it to take effect."
+ :type 'regexp
+ :group 'eshell-prompt)
+
+(defcustom eshell-highlight-prompt t
+ "*If non-nil, Eshell should highlight the prompt."
+ :type 'boolean
+ :group 'eshell-prompt)
+
+(defface eshell-prompt-face
+ '((((class color) (background light)) (:foreground "Red" :bold t))
+ (((class color) (background dark)) (:foreground "Pink" :bold t))
+ (t (:bold t)))
+ "*The face used to highlight prompt strings.
+For highlighting other kinds of strings -- similar to shell mode's
+behavior -- simply use an output filer which changes text properties."
+ :group 'eshell-prompt)
+
+(defcustom eshell-before-prompt-hook nil
+ "*A list of functions to call before outputting the prompt."
+ :type 'hook
+ :options '(eshell-begin-on-new-line)
+ :group 'eshell-prompt)
+
+(defcustom eshell-after-prompt-hook nil
+ "*A list of functions to call after outputting the prompt.
+Note that if `eshell-scroll-show-maximum-output' is non-nil, then
+setting `eshell-show-maximum-output' here won't do much. It depends
+on whether the user wants the resizing to happen while output is
+arriving, or after."
+ :type 'hook
+ :options '(eshell-show-maximum-output)
+ :group 'eshell-prompt)
+
+;;; Functions:
+
+(defun eshell-prompt-initialize ()
+ "Initialize the prompting code."
+ (unless eshell-non-interactive-p
+ (make-local-hook 'eshell-post-command-hook)
+ (add-hook 'eshell-post-command-hook 'eshell-emit-prompt nil t)
+
+ (make-local-variable 'eshell-prompt-regexp)
+ (if eshell-prompt-regexp
+ (set (make-local-variable 'paragraph-start) eshell-prompt-regexp))
+
+ (set (make-local-variable 'eshell-skip-prompt-function)
+ 'eshell-skip-prompt)
+
+ (define-key eshell-command-map [(control ?n)] 'eshell-next-prompt)
+ (define-key eshell-command-map [(control ?p)] 'eshell-previous-prompt)))
+
+(defun eshell-emit-prompt ()
+ "Emit a prompt if eshell is being used interactively."
+ (run-hooks 'eshell-before-prompt-hook)
+ (if (not eshell-prompt-function)
+ (set-marker eshell-last-output-end (point))
+ (let ((prompt (funcall eshell-prompt-function)))
+ (and eshell-highlight-prompt
+ (add-text-properties 0 (length prompt)
+ '(read-only t
+ face eshell-prompt-face
+ rear-nonsticky (face read-only))
+ prompt))
+ (eshell-interactive-print prompt)))
+ (run-hooks 'eshell-after-prompt-hook))
+
+(defun eshell-backward-matching-input (regexp arg)
+ "Search backward through buffer for match for REGEXP.
+Matches are searched for on lines that match `eshell-prompt-regexp'.
+With prefix argument N, search for Nth previous match.
+If N is negative, find the next or Nth next match."
+ (interactive (eshell-regexp-arg "Backward input matching (regexp): "))
+ (let* ((re (concat eshell-prompt-regexp ".*" regexp))
+ (pos (save-excursion (end-of-line (if (> arg 0) 0 1))
+ (if (re-search-backward re nil t arg)
+ (point)))))
+ (if (null pos)
+ (progn (message "Not found")
+ (ding))
+ (goto-char pos)
+ (eshell-bol))))
+
+(defun eshell-forward-matching-input (regexp arg)
+ "Search forward through buffer for match for REGEXP.
+Matches are searched for on lines that match `eshell-prompt-regexp'.
+With prefix argument N, search for Nth following match.
+If N is negative, find the previous or Nth previous match."
+ (interactive (eshell-regexp-arg "Forward input matching (regexp): "))
+ (eshell-backward-matching-input regexp (- arg)))
+
+(defun eshell-next-prompt (n)
+ "Move to end of Nth next prompt in the buffer.
+See `eshell-prompt-regexp'."
+ (interactive "p")
+ (forward-paragraph n)
+ (eshell-skip-prompt))
+
+(defun eshell-previous-prompt (n)
+ "Move to end of Nth previous prompt in the buffer.
+See `eshell-prompt-regexp'."
+ (interactive "p")
+ (eshell-next-prompt (- (1+ n))))
+
+(defun eshell-skip-prompt ()
+ "Skip past the text matching regexp `eshell-prompt-regexp'.
+If this takes us past the end of the current line, don't skip at all."
+ (let ((eol (line-end-position)))
+ (if (and (looking-at eshell-prompt-regexp)
+ (<= (match-end 0) eol))
+ (goto-char (match-end 0)))))
+
+;;; Code:
+
+;;; em-prompt.el ends here
--- /dev/null
+;;; em-rebind --- rebind keys when point is at current input
+
+;; Copyright (C) 1999, 2000 Free Sofware Foundation
+
+;; 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 2, 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+(provide 'em-rebind)
+
+(eval-when-compile (require 'esh-maint))
+
+(defgroup eshell-rebind nil
+ "This module allows for special keybindings that only take effect
+while the point is in a region of input text. By default, it binds
+C-a to move to the beginning of the input text (rather than just the
+beginning of the line), and C-p and C-n to move through the input
+history, C-u kills the current input text, etc. It also, if
+`eshell-confine-point-to-input' is non-nil, does not allow certain
+commands to cause the point to leave the input area, such as
+`backward-word', `previous-line', etc. This module intends to mimic
+the behavior of normal shells while the user editing new input text."
+ :tag "Rebind keys at input"
+ :group 'eshell-module)
+
+;;; Commentary:
+
+;;; User Variables:
+
+(defcustom eshell-rebind-load-hook '(eshell-rebind-initialize)
+ "*A list of functions to call when loading `eshell-rebind'."
+ :type 'hook
+ :group 'eshell-rebind)
+
+(defcustom eshell-rebind-keys-alist
+ '(([(control ?a)] . eshell-bol)
+ ([home] . eshell-bol)
+ ([(control ?d)] . eshell-delchar-or-maybe-eof)
+ ([backspace] . eshell-delete-backward-char)
+ ([delete] . eshell-delete-backward-char)
+ ([(control ?w)] . backward-kill-word)
+ ([(control ?u)] . eshell-kill-input))
+ "*Bind some keys differently if point is in input text."
+ :type '(repeat (cons (vector :tag "Keys to bind"
+ (repeat :inline t sexp))
+ (function :tag "Command")))
+ :group 'eshell-rebind)
+
+(defcustom eshell-confine-point-to-input t
+ "*If non-nil, do not allow the point to leave the current input.
+This is more difficult to do nicely in Emacs than one might think.
+Basically, the `point-left' attribute is added to the input text, and
+a function is placed on that hook to take the point back to
+`eshell-last-output-end' every time the user tries to move away. But
+since there are many cases in which the point _ought_ to move away
+\(for programmatic reasons), the variable
+`eshell-cannot-leave-input-list' defines commands which are affected
+from this rule. However, this list is by no means as complete as it
+probably should be, so basically all one can hope for is that other
+people will left the point alone in the Eshell buffer. Sigh."
+ :type 'boolean
+ :group 'eshell-rebind)
+
+(defcustom eshell-error-if-move-away t
+ "*If non-nil, consider it an error to try to move outside current input.
+This is default behavior of shells like bash."
+ :type 'boolean
+ :group 'eshell-rebind)
+
+(defcustom eshell-remap-previous-input t
+ "*If non-nil, remap input keybindings on previous prompts as well."
+ :type 'boolean
+ :group 'eshell-rebind)
+
+(defcustom eshell-cannot-leave-input-list
+ '(beginning-of-line-text
+ beginning-of-line
+ move-to-column
+ move-to-column-force
+ move-to-left-margin
+ move-to-tab-stop
+ forward-char
+ backward-char
+ delete-char
+ delete-backward-char
+ backward-delete-char
+ backward-delete-char-untabify
+ kill-paragraph
+ backward-kill-paragraph
+ kill-sentence
+ backward-kill-sentence
+ kill-sexp
+ backward-kill-sexp
+ kill-word
+ backward-kill-word
+ kill-region
+ forward-list
+ backward-list
+ forward-page
+ backward-page
+ forward-point
+ forward-paragraph
+ backward-paragraph
+ backward-prefix-chars
+ forward-sentence
+ backward-sentence
+ forward-sexp
+ backward-sexp
+ forward-to-indentation
+ backward-to-indentation
+ backward-up-list
+ forward-word
+ backward-word
+ forward-line
+ backward-line
+ previous-line
+ next-line
+ forward-visible-line
+ forward-comment
+ forward-thing)
+ "*A list of commands that cannot leave the input area."
+ :type '(repeat function)
+ :group 'eshell-rebind)
+
+;; Internal Variables:
+
+(defvar eshell-input-keymap)
+(defvar eshell-previous-point)
+(defvar eshell-lock-keymap)
+
+;;; Functions:
+
+(defun eshell-rebind-initialize ()
+ "Initialize the inputing code."
+ (unless eshell-non-interactive-p
+ (make-local-hook 'eshell-mode-hook)
+ (add-hook 'eshell-mode-hook 'eshell-setup-input-keymap nil t)
+ (make-local-hook 'pre-command-hook)
+ (make-local-variable 'eshell-previous-point)
+ (add-hook 'pre-command-hook 'eshell-save-previous-point nil t)
+ (make-local-hook 'post-command-hook)
+ (make-local-variable 'overriding-local-map)
+ (add-hook 'post-command-hook 'eshell-rebind-input-map nil t)
+ (set (make-local-variable 'eshell-lock-keymap) nil)
+ (define-key eshell-command-map [(meta ?l)] 'eshell-lock-local-map)))
+
+(defun eshell-lock-local-map (&optional arg)
+ "Lock or unlock the current local keymap.
+Within a prefix arg, set the local keymap to its normal value, and
+lock it at that."
+ (interactive "P")
+ (if (or arg (not eshell-lock-keymap))
+ (progn
+ (use-local-map eshell-mode-map)
+ (setq eshell-lock-keymap t)
+ (message "Local keymap locked in normal mode"))
+ (use-local-map eshell-input-keymap)
+ (setq eshell-lock-keymap nil)
+ (message "Local keymap unlocked: obey context")))
+
+(defun eshell-save-previous-point ()
+ "Save the location of point before the next command is run."
+ (setq eshell-previous-point (point)))
+
+(defsubst eshell-point-within-input-p (pos)
+ "Test whether POS is within an input range."
+ (let (begin)
+ (or (and (>= pos eshell-last-output-end)
+ eshell-last-output-end)
+ (and eshell-remap-previous-input
+ (setq begin
+ (save-excursion
+ (eshell-bol)
+ (and (not (bolp)) (point))))
+ (>= pos begin)
+ (<= pos (line-end-position))
+ begin))))
+
+(defun eshell-rebind-input-map ()
+ "Rebind the input keymap based on the location of the cursor."
+ (ignore-errors
+ (unless eshell-lock-keymap
+ (if (eshell-point-within-input-p (point))
+ (use-local-map eshell-input-keymap)
+ (let (begin)
+ (if (and eshell-confine-point-to-input
+ (setq begin
+ (eshell-point-within-input-p eshell-previous-point))
+ (memq this-command eshell-cannot-leave-input-list))
+ (progn
+ (use-local-map eshell-input-keymap)
+ (goto-char begin)
+ (if (and eshell-error-if-move-away
+ (not (eq this-command 'kill-region)))
+ (beep)))
+ (use-local-map eshell-mode-map)))))))
+
+(defun eshell-setup-input-keymap ()
+ "Setup the input keymap to be used during input editing."
+ (make-local-variable 'eshell-input-keymap)
+ (setq eshell-input-keymap (make-sparse-keymap))
+ (set-keymap-parent eshell-input-keymap eshell-mode-map)
+ (let ((bindings eshell-rebind-keys-alist))
+ (while bindings
+ (define-key eshell-input-keymap (caar bindings)
+ (cdar bindings))
+ (setq bindings (cdr bindings)))))
+
+(defun eshell-delete-backward-char (n &optional killflag)
+ "Delete the last character, unless it's part of the output."
+ (interactive "P")
+ (let ((count (prefix-numeric-value n)))
+ (if (eshell-point-within-input-p (- (point) count))
+ (delete-backward-char count n)
+ (beep))))
+
+(defun eshell-delchar-or-maybe-eof (arg)
+ "Delete ARG characters forward or send an EOF to subprocess.
+Sends an EOF only if point is at the end of the buffer and there is no
+input."
+ (interactive "p")
+ (let ((proc (get-buffer-process (current-buffer))))
+ (if (eobp)
+ (cond
+ ((not (= (point) eshell-last-output-end))
+ (beep))
+ (proc
+ (process-send-eof))
+ (t
+ (eshell-life-is-too-much)))
+ (eshell-delete-backward-char (- arg)))))
+
+;;; Code:
+
+;;; em-rebind.el ends here
--- /dev/null
+;;; em-script --- Eshell script files
+
+;; Copyright (C) 1999, 2000 Free Sofware Foundation
+
+;; 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 2, 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+(provide 'em-script)
+
+(eval-when-compile (require 'esh-maint))
+
+(defgroup eshell-script nil
+ "This module allows for the execution of files containing Eshell
+commands, as a script file."
+ :tag "Running script files."
+ :group 'eshell-module)
+
+;;; Commentary:
+
+;;; User Variables:
+
+(defcustom eshell-script-load-hook '(eshell-script-initialize)
+ "*A list of functions to call when loading `eshell-script'."
+ :type 'hook
+ :group 'eshell-script)
+
+(defcustom eshell-login-script (concat eshell-directory-name "login")
+ "*If non-nil, a file to invoke when starting up Eshell interactively.
+This file should be a file containing Eshell commands, where comment
+lines begin with '#'."
+ :type 'file
+ :group 'eshell-script)
+
+(defcustom eshell-rc-script (concat eshell-directory-name "profile")
+ "*If non-nil, a file to invoke whenever Eshell is started.
+This includes when running `eshell-command'."
+ :type 'file
+ :group 'eshell-script)
+
+;;; Functions:
+
+(defun eshell-script-initialize ()
+ "Initialize the script parsing code."
+ (make-local-variable 'eshell-interpreter-alist)
+ (setq eshell-interpreter-alist
+ (cons '((lambda (file)
+ (string= (file-name-nondirectory file)
+ "eshell")) . eshell/source)
+ eshell-interpreter-alist))
+ ;; these two variables are changed through usage, but we don't want
+ ;; to ruin it for other modules
+ (let (eshell-inside-quote-regexp
+ eshell-outside-quote-regexp)
+ (and (not eshell-non-interactive-p)
+ eshell-login-script
+ (file-readable-p eshell-login-script)
+ (eshell-do-eval
+ (list 'eshell-commands
+ (catch 'eshell-replace-command
+ (eshell-source-file eshell-login-script))) t))
+ (and eshell-rc-script
+ (file-readable-p eshell-rc-script)
+ (eshell-do-eval
+ (list 'eshell-commands
+ (catch 'eshell-replace-command
+ (eshell-source-file eshell-rc-script))) t))))
+
+(defun eshell-source-file (file &optional args subcommand-p)
+ "Execute a series of Eshell commands in FILE, passing ARGS.
+Comments begin with '#'."
+ (interactive "f")
+ (let ((orig (point))
+ (here (point-max))
+ (inhibit-point-motion-hooks t)
+ after-change-functions)
+ (goto-char (point-max))
+ (insert-file-contents file)
+ (goto-char (point-max))
+ (throw 'eshell-replace-command
+ (prog1
+ (list 'let
+ (list (list 'eshell-command-name (list 'quote file))
+ (list 'eshell-command-arguments
+ (list 'quote args)))
+ (let ((cmd (eshell-parse-command (cons here (point)))))
+ (if subcommand-p
+ (setq cmd (list 'eshell-as-subcommand cmd)))
+ cmd))
+ (delete-region here (point))
+ (goto-char orig)))))
+
+(defun eshell/source (&rest args)
+ "Source a file in a subshell environment."
+ (eshell-eval-using-options
+ "source" args
+ '((?h "help" nil nil "show this usage screen")
+ :show-usage
+ :usage "FILE [ARGS]
+Invoke the Eshell commands in FILE in a subshell, binding ARGS to $1,
+$2, etc.")
+ (eshell-source-file (car args) (cdr args) t)))
+
+(defun eshell/. (&rest args)
+ "Source a file in the current environment."
+ (eshell-eval-using-options
+ "." args
+ '((?h "help" nil nil "show this usage screen")
+ :show-usage
+ :usage "FILE [ARGS]
+Invoke the Eshell commands in FILE within the current shell
+environment, binding ARGS to $1, $2, etc.")
+ (eshell-source-file (car args) (cdr args))))
+
+;;; Code:
+
+;;; em-script.el ends here
--- /dev/null
+;;; em-smart --- smart display of output
+
+;; Copyright (C) 1999, 2000 Free Sofware Foundation
+
+;; 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 2, 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+(provide 'em-smart)
+
+(eval-when-compile (require 'esh-maint))
+
+(defgroup eshell-smart nil
+ "This module combines the facility of normal, modern shells with
+some of the edit/review concepts inherent in the design of Plan 9's
+9term. See the docs for more details.
+
+Most likely you will have to turn this option on and play around with
+it to get a real sense of how it works."
+ :tag "Smart display of output"
+ :link '(info-link "(eshell.info)Smart display of output")
+ :group 'eshell-module)
+
+;;; Commentary:
+
+;; The best way to get a sense of what this code is trying to do is by
+;; using it. Basically, the philosophy represents a blend between the
+;; ease of use of modern day shells, and the review-before-you-proceed
+;; mentality of Plan 9's 9term.
+;;
+;; @ When you invoke a command, it is assumed that you want to read
+;; the output of that command.
+;;
+;; @ If the output is not what you wanted, it is assumed that you will
+;; want to edit, and then resubmit a refined version of that
+;; command.
+;;
+;; @ If the output is valid, pressing any self-inserting character key
+;; will jump to end of the buffer and insert that character, in
+;; order to begin entry of a new command.
+;;
+;; @ If you show an intention to edit the previous command -- by
+;; moving around within it -- then the next self-inserting
+;; characters will insert *there*, instead of at the bottom of the
+;; buffer.
+;;
+;; @ If you show an intention to review old commands, such as M-p or
+;; M-r, point will jump to the bottom of the buffer before invoking
+;; that command.
+;;
+;; @ If none of the above has happened yet (i.e., your point is just
+;; sitting on the previous command), you can use SPACE and BACKSPACE
+;; (or DELETE) to page forward and backward *through the output of
+;; the last command only*. It will constrain the movement of the
+;; point and window so that the maximum amount of output is always
+;; displayed at all times.
+;;
+;; @ While output is being generated from a command, the window will
+;; be constantly reconfigured (until it would otherwise make no
+;; difference) in order to always show you the most output from the
+;; command possible. This happens if you change window sizes,
+;; scroll, etc.
+;;
+;; @ Like I said, it's not really comprehensible until you try it! ;)
+
+;;; User Variables:
+
+(defcustom eshell-smart-load-hook '(eshell-smart-initialize)
+ "*A list of functions to call when loading `eshell-smart'."
+ :type 'hook
+ :group 'eshell-smart)
+
+(defcustom eshell-smart-unload-hook
+ (list
+ (function
+ (lambda ()
+ (remove-hook 'window-configuration-change-hook
+ 'eshell-refresh-windows))))
+ "*A hook that gets run when `eshell-smart' is unloaded."
+ :type 'hook
+ :group 'eshell-smart)
+
+(defcustom eshell-review-quick-commands nil
+ "*If nil, point does not stay on quick commands.
+A quick command is one that produces no output, and exits
+successfully."
+ :type 'boolean
+ :group 'eshell-smart)
+
+(defcustom eshell-smart-display-navigate-list
+ '(insert-parentheses
+ mouse-yank-at-click
+ mouse-yank-secondary
+ yank-pop
+ yank-rectangle
+ yank)
+ "*A list of commands which cause Eshell to jump to the end of buffer."
+ :type '(repeat function)
+ :group 'eshell-smart)
+
+(defcustom eshell-smart-space-goes-to-end t
+ "*If non-nil, space will go to end of buffer when point-max is visible.
+That is, if a command is running and the user presses SPACE at a time
+when the end of the buffer is visible, point will go to the end of the
+buffer and smart-display will be turned off (that is, subsequently
+pressing backspace will not cause the buffer to scroll down).
+
+This feature is provided to make it very easy to watch the output of a
+long-running command, such as make, where it's more desirable to see
+the output go by than to review it afterward.
+
+Setting this variable to nil means that space and backspace will
+always have a consistent behavior, which is to move back and forth
+through displayed output. But it also means that enabling output
+tracking requires the user to manually move point to the end of the
+buffer using \\[end-of-buffer]."
+ :type 'boolean
+ :group 'eshell-smart)
+
+(defcustom eshell-where-to-jump 'begin
+ "*This variable indicates where point should jump to after a command.
+The options are `begin', `after' or `end'."
+ :type '(radio (const :tag "Beginning of command" begin)
+ (const :tag "After command word" after)
+ (const :tag "End of command" end))
+ :group 'eshell-smart)
+
+;;; Internal Variables:
+
+(defvar eshell-smart-displayed nil)
+(defvar eshell-smart-command-done nil)
+
+;;; Functions:
+
+(defun eshell-smart-initialize ()
+ "Setup Eshell smart display."
+ (unless eshell-non-interactive-p
+ ;; override a few variables, since they would interfere with the
+ ;; smart display functionality.
+ (set (make-local-variable 'eshell-scroll-to-bottom-on-output) nil)
+ (set (make-local-variable 'eshell-scroll-to-bottom-on-input) nil)
+ (set (make-local-variable 'eshell-scroll-show-maximum-output) t)
+
+ (make-local-hook 'window-scroll-functions)
+ (add-hook 'window-scroll-functions 'eshell-smart-scroll-window nil t)
+ (add-hook 'window-configuration-change-hook 'eshell-refresh-windows)
+
+ (make-local-hook 'eshell-output-filter-functions)
+ (add-hook 'eshell-output-filter-functions 'eshell-refresh-windows t t)
+
+ (make-local-hook 'pre-command-hook)
+ (make-local-hook 'after-change-functions)
+ (add-hook 'after-change-functions
+ 'eshell-disable-after-change nil t)
+
+ (make-local-hook 'eshell-input-filter-functions)
+ (add-hook 'eshell-input-filter-functions
+ 'eshell-smart-display-setup nil t)
+
+ (make-local-variable 'eshell-smart-command-done)
+ (make-local-hook 'eshell-post-command-hook)
+ (add-hook 'eshell-post-command-hook
+ (function
+ (lambda ()
+ (setq eshell-smart-command-done t))) t t)
+
+ (unless eshell-review-quick-commands
+ (add-hook 'eshell-post-command-hook
+ 'eshell-smart-maybe-jump-to-end nil t))))
+
+(defun eshell-smart-scroll-window (wind start)
+ "Scroll the given Eshell window accordingly."
+ (unless eshell-currently-handling-window
+ (let ((inhibit-point-motion-hooks t)
+ (eshell-currently-handling-window t))
+ (save-current-buffer
+ (save-selected-window
+ (select-window wind)
+ (eshell-smart-redisplay))))))
+
+(defun eshell-refresh-windows (&optional frame)
+ "Refresh all visible Eshell buffers."
+ (let (affected)
+ (walk-windows
+ (function
+ (lambda (wind)
+ (with-current-buffer (window-buffer wind)
+ (when eshell-mode
+ (let (window-scroll-functions)
+ (eshell-smart-scroll-window wind (window-start))
+ (setq affected t))))))
+ 0 frame)
+ (if affected
+ (let (window-scroll-functions)
+ (eshell-redisplay)))))
+
+(defun eshell-smart-display-setup ()
+ "Set the point to somewhere in the beginning of the last command."
+ (cond
+ ((eq eshell-where-to-jump 'begin)
+ (goto-char eshell-last-input-start))
+ ((eq eshell-where-to-jump 'after)
+ (goto-char (next-single-property-change
+ eshell-last-input-start 'arg-end))
+ (if (= (point) (- eshell-last-input-end 2))
+ (forward-char)))
+ ((eq eshell-where-to-jump 'end)
+ (goto-char (1- eshell-last-input-end)))
+ (t
+ (error "Invalid value for `eshell-where-to-jump'")))
+ (setq eshell-smart-command-done nil)
+ (add-hook 'pre-command-hook 'eshell-smart-display-move nil t)
+ (eshell-refresh-windows))
+
+(defun eshell-disable-after-change (b e l)
+ "Disable smart display mode if the buffer changes in any way."
+ (when eshell-smart-command-done
+ (remove-hook 'pre-command-hook 'eshell-smart-display-move t)
+ (setq eshell-smart-command-done nil)))
+
+(defun eshell-smart-maybe-jump-to-end ()
+ "Jump to the end of the input buffer.
+This is done whenever a command exits sucessfully that displayed no
+output."
+ (when (and (= eshell-last-command-status 0)
+ (= (count-lines eshell-last-input-end
+ eshell-last-output-end) 0))
+ (goto-char (point-max))
+ (remove-hook 'pre-command-hook 'eshell-smart-display-move t)))
+
+(defun eshell-smart-redisplay ()
+ "Display as much output as possible, smartly."
+ (if (eobp)
+ (recenter -1)
+ (and (memq 'eshell-smart-display-move pre-command-hook)
+ (>= (point) eshell-last-input-start)
+ (< (point) eshell-last-input-end)
+ (set-window-start (selected-window)
+ (line-beginning-position) t))
+ (if (pos-visible-in-window-p (point-max))
+ (save-excursion
+ (goto-char (point-max))
+ (recenter -1)))))
+
+(defun eshell-smart-goto-end ()
+ "Like `end-of-buffer', but do not push a mark."
+ (interactive)
+ (goto-char (point-max)))
+
+(defun eshell-smart-display-move ()
+ "Handle self-inserting or movement commands intelligently."
+ (let (clear)
+ (if (or current-prefix-arg
+ (and (> (point) eshell-last-input-start)
+ (< (point) eshell-last-input-end))
+ (>= (point) eshell-last-output-end))
+ (setq clear t)
+ (cond
+ ((eq this-command 'self-insert-command)
+ (if (eq last-command-char ? )
+ (if (and eshell-smart-space-goes-to-end
+ eshell-current-command)
+ (if (not (pos-visible-in-window-p (point-max)))
+ (setq this-command 'scroll-up)
+ (setq this-command 'eshell-smart-goto-end))
+ (setq this-command 'scroll-up))
+ (setq clear t)
+ (goto-char (point-max))))
+ ((eq this-command 'delete-backward-char)
+ (setq this-command 'ignore)
+ (if (< (point) eshell-last-input-start)
+ (eshell-show-output)
+ (if (pos-visible-in-window-p eshell-last-input-start)
+ (progn
+ (ignore-errors
+ (scroll-down))
+ (eshell-show-output))
+ (scroll-down)
+ (if (pos-visible-in-window-p eshell-last-input-end)
+ (eshell-show-output)))))
+ ((or (memq this-command eshell-smart-display-navigate-list)
+ (and (eq this-command 'eshell-send-input)
+ (not (and (>= (point) eshell-last-input-start)
+ (< (point) eshell-last-input-end)))))
+ (setq clear t)
+ (goto-char (point-max)))))
+ (if clear
+ (remove-hook 'pre-command-hook 'eshell-smart-display-move t))))
+
+;;; Code:
+
+;;; em-smart.el ends here
--- /dev/null
+;;; em-term --- running visual commands
+
+;; Copyright (C) 1999, 2000 Free Sofware Foundation
+
+;; 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 2, 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+(provide 'em-term)
+
+(eval-when-compile (require 'esh-maint))
+
+(defgroup eshell-term nil
+ "This module causes visual commands (e.g., 'vi') to be executed by
+the `term' package, which comes with Emacs. This package handles most
+of the ANSI control codes, allowing curses-based applications to run
+within an Emacs window. The variable `eshell-visual-commands' defines
+which commands are considered visual in nature."
+ :tag "Running visual commands"
+ :group 'eshell-module)
+
+;;; Commentary:
+
+;; At the moment, eshell is stream-based in its interactive input and
+;; output. This means that full-screen commands, such as "vi" or
+;; "lynx", will not display correctly. These are therefore thought of
+;; as "visual" programs. In order to run these progrem under Emacs,
+;; Eshell uses the term.el package, and invokes them in a separate
+;; buffer, giving the illusion that Eshell itself is allowing these
+;; visual processes to execute.
+
+(require 'term)
+
+;;; User Variables:
+
+(defcustom eshell-term-load-hook '(eshell-term-initialize)
+ "*A list of functions to call when loading `eshell-term'."
+ :type 'hook
+ :group 'eshell-term)
+
+(defcustom eshell-visual-commands
+ '("vi" ; what is going on??
+ "screen" "top" ; ok, a valid program...
+ "less" "more" ; M-x view-file
+ "lynx" "ncftp" ; w3.el, ange-ftp
+ "pine" "tin" "trn" "elm") ; GNUS!!
+ "*A list of commands that present their output in a visual fashion."
+ :type '(repeat string)
+ :group 'eshell-term)
+
+(defcustom eshell-term-name "eterm"
+ "*Name to use for the TERM variable when running visual commands.
+See `term-term-name' in term.el for more information on how this is
+used."
+ :type 'string
+ :group 'eshell-term)
+
+(defcustom eshell-escape-control-x t
+ "*If non-nil, allow <C-x> to be handled by Emacs key in visual buffers.
+See the variable `eshell-visual-commands'. If this variable is set to
+nil, <C-x> will send that control character to the invoked process."
+ :type 'boolean
+ :group 'eshell-term)
+
+;;; Internal Variables:
+
+(defvar eshell-parent-buffer)
+
+;;; Functions:
+
+(defun eshell-term-initialize ()
+ "Initialize the `term' interface code."
+ (make-local-variable 'eshell-interpreter-alist)
+ (setq eshell-interpreter-alist
+ (cons (cons (function
+ (lambda (command)
+ (member (file-name-nondirectory command)
+ eshell-visual-commands)))
+ 'eshell-exec-visual)
+ eshell-interpreter-alist)))
+
+(defun eshell-exec-visual (&rest args)
+ "Run the specified PROGRAM in a terminal emulation buffer.
+ARGS are passed to the program. At the moment, no piping of input is
+allowed."
+ (let* (eshell-interpreter-alist
+ (interp (eshell-find-interpreter (car args)))
+ (program (car interp))
+ (args (eshell-flatten-list
+ (eshell-stringify-list (append (cdr interp)
+ (cdr args)))))
+ (term-buf
+ (generate-new-buffer
+ (concat "*" (file-name-nondirectory program) "*")))
+ (eshell-buf (current-buffer)))
+ (save-current-buffer
+ (switch-to-buffer term-buf)
+ (term-mode)
+ (set (make-local-variable 'term-term-name) eshell-term-name)
+ (make-local-variable 'eshell-parent-buffer)
+ (setq eshell-parent-buffer eshell-buf)
+ (term-exec term-buf program program nil args)
+ (let ((proc (get-buffer-process term-buf)))
+ (if (and proc (eq 'run (process-status proc)))
+ (set-process-sentinel proc 'eshell-term-sentinel)
+ (error "Failed to invoke visual command")))
+ (term-char-mode)
+ (if eshell-escape-control-x
+ (term-set-escape-char ?\C-x))))
+ nil)
+
+(defun eshell-term-sentinel (proc string)
+ "Destroy the buffer visiting PROC."
+ (let ((proc-buf (process-buffer proc)))
+ (when (and proc-buf (buffer-live-p proc-buf)
+ (not (eq 'run (process-status proc)))
+ (= (process-exit-status proc) 0))
+ (if (eq (current-buffer) proc-buf)
+ (let ((buf (and (boundp 'eshell-parent-buffer)
+ eshell-parent-buffer
+ (buffer-live-p eshell-parent-buffer)
+ eshell-parent-buffer)))
+ (if buf
+ (switch-to-buffer buf))))
+ (kill-buffer proc-buf))))
+
+;; jww (1999-09-17): The code below will allow Eshell to send input
+;; characters directly to the currently running interactive process.
+;; However, since this would introduce other problems that would need
+;; solutions, I'm going to let it wait until after 2.1.
+
+; (defvar eshell-term-raw-map nil
+; "Keyboard map for sending characters directly to the inferior process.")
+; (defvar eshell-term-escape-char nil
+; "Escape character for char-sub-mode of term mode.
+; Do not change it directly; use term-set-escape-char instead.")
+; (defvar eshell-term-raw-escape-map nil)
+
+; (defun eshell-term-send-raw-string (chars)
+; (goto-char eshell-last-output-end)
+; (process-send-string (eshell-interactive-process) chars))
+
+; (defun eshell-term-send-raw ()
+; "Send the last character typed through the terminal-emulator
+; without any interpretation."
+; (interactive)
+; ;; Convert `return' to C-m, etc.
+; (if (and (symbolp last-input-char)
+; (get last-input-char 'ascii-character))
+; (setq last-input-char (get last-input-char 'ascii-character)))
+; (eshell-term-send-raw-string (make-string 1 last-input-char)))
+
+; (defun eshell-term-send-raw-meta ()
+; (interactive)
+; (if (symbolp last-input-char)
+; ;; Convert `return' to C-m, etc.
+; (let ((tmp (get last-input-char 'event-symbol-elements)))
+; (if tmp
+; (setq last-input-char (car tmp)))
+; (if (symbolp last-input-char)
+; (progn
+; (setq tmp (get last-input-char 'ascii-character))
+; (if tmp (setq last-input-char tmp))))))
+; (eshell-term-send-raw-string (if (and (numberp last-input-char)
+; (> last-input-char 127)
+; (< last-input-char 256))
+; (make-string 1 last-input-char)
+; (format "\e%c" last-input-char))))
+
+; (defun eshell-term-mouse-paste (click arg)
+; "Insert the last stretch of killed text at the position clicked on."
+; (interactive "e\nP")
+; (if (boundp 'xemacs-logo)
+; (eshell-term-send-raw-string
+; (or (condition-case () (x-get-selection) (error ()))
+; (x-get-cutbuffer)
+; (error "No selection or cut buffer available")))
+; ;; Give temporary modes such as isearch a chance to turn off.
+; (run-hooks 'mouse-leave-buffer-hook)
+; (setq this-command 'yank)
+; (eshell-term-send-raw-string
+; (current-kill (cond ((listp arg) 0)
+; ((eq arg '-) -1)
+; (t (1- arg)))))))
+
+; ;; Which would be better: "\e[A" or "\eOA"? readline accepts either.
+; ;; For my configuration it's definitely better \eOA but YMMV. -mm
+; ;; For example: vi works with \eOA while elm wants \e[A ...
+; (defun eshell-term-send-up () (interactive) (eshell-term-send-raw-string "\eOA"))
+; (defun eshell-term-send-down () (interactive) (eshell-term-send-raw-string "\eOB"))
+; (defun eshell-term-send-right () (interactive) (eshell-term-send-raw-string "\eOC"))
+; (defun eshell-term-send-left () (interactive) (eshell-term-send-raw-string "\eOD"))
+; (defun eshell-term-send-home () (interactive) (eshell-term-send-raw-string "\e[1~"))
+; (defun eshell-term-send-end () (interactive) (eshell-term-send-raw-string "\e[4~"))
+; (defun eshell-term-send-prior () (interactive) (eshell-term-send-raw-string "\e[5~"))
+; (defun eshell-term-send-next () (interactive) (eshell-term-send-raw-string "\e[6~"))
+; (defun eshell-term-send-del () (interactive) (eshell-term-send-raw-string "\C-?"))
+; (defun eshell-term-send-backspace () (interactive) (eshell-term-send-raw-string "\C-H"))
+
+; (defun eshell-term-set-escape-char (c)
+; "Change term-escape-char and keymaps that depend on it."
+; (if eshell-term-escape-char
+; (define-key eshell-term-raw-map eshell-term-escape-char 'eshell-term-send-raw))
+; (setq c (make-string 1 c))
+; (define-key eshell-term-raw-map c eshell-term-raw-escape-map)
+; ;; Define standard bindings in eshell-term-raw-escape-map
+; (define-key eshell-term-raw-escape-map "\C-x"
+; (lookup-key (current-global-map) "\C-x"))
+; (define-key eshell-term-raw-escape-map "\C-v"
+; (lookup-key (current-global-map) "\C-v"))
+; (define-key eshell-term-raw-escape-map "\C-u"
+; (lookup-key (current-global-map) "\C-u"))
+; (define-key eshell-term-raw-escape-map c 'eshell-term-send-raw))
+
+; (defun eshell-term-char-mode ()
+; "Switch to char (\"raw\") sub-mode of term mode.
+; Each character you type is sent directly to the inferior without
+; intervention from Emacs, except for the escape character (usually C-c)."
+; (interactive)
+; (if (not eshell-term-raw-map)
+; (let* ((map (make-keymap))
+; (esc-map (make-keymap))
+; (i 0))
+; (while (< i 128)
+; (define-key map (make-string 1 i) 'eshell-term-send-raw)
+; (define-key esc-map (make-string 1 i) 'eshell-term-send-raw-meta)
+; (setq i (1+ i)))
+; (define-key map "\e" esc-map)
+; (setq eshell-term-raw-map map)
+; (setq eshell-term-raw-escape-map
+; (copy-keymap (lookup-key (current-global-map) "\C-x")))
+; (if (boundp 'xemacs-logo)
+; (define-key eshell-term-raw-map [button2] 'eshell-term-mouse-paste)
+; (define-key eshell-term-raw-map [mouse-2] 'eshell-term-mouse-paste))
+; (define-key eshell-term-raw-map [up] 'eshell-term-send-up)
+; (define-key eshell-term-raw-map [down] 'eshell-term-send-down)
+; (define-key eshell-term-raw-map [right] 'eshell-term-send-right)
+; (define-key eshell-term-raw-map [left] 'eshell-term-send-left)
+; (define-key eshell-term-raw-map [delete] 'eshell-term-send-del)
+; (define-key eshell-term-raw-map [backspace] 'eshell-term-send-backspace)
+; (define-key eshell-term-raw-map [home] 'eshell-term-send-home)
+; (define-key eshell-term-raw-map [end] 'eshell-term-send-end)
+; (define-key eshell-term-raw-map [prior] 'eshell-term-send-prior)
+; (define-key eshell-term-raw-map [next] 'eshell-term-send-next)
+; (eshell-term-set-escape-char ?\C-c))))
+
+; (defun eshell-term-line-mode ()
+; "Switch to line (\"cooked\") sub-mode of eshell-term mode."
+; (use-local-map term-old-mode-map))
+
+;;; Code:
+
+;;; em-term.el ends here
--- /dev/null
+;;; em-unix --- UNIX command aliases
+
+;; Copyright (C) 1999, 2000 Free Sofware Foundation
+
+;; 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 2, 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+(provide 'em-unix)
+
+(eval-when-compile (require 'esh-maint))
+
+(defgroup eshell-unix nil
+ "This module defines many of the more common UNIX utilities as
+aliases implemented in Lisp. These include mv, ln, cp, rm, etc. If
+the user passes arguments which are too complex, or are unrecognized
+by the Lisp variant, the external version will be called (if
+available). The only reason not to use them would be because they are
+usually much slower. But in several cases their tight integration
+with Eshell makes them more versatile than their traditional cousins
+\(such as being able to use `kill' to kill Eshell background processes
+by name)."
+ :tag "UNIX commands in Lisp"
+ :group 'eshell-module)
+
+;;; Commentary:
+
+;; This file contains implementations of several UNIX command in Emacs
+;; Lisp, for several reasons:
+;;
+;; 1) it makes them available on all platforms where the Lisp
+;; functions used are available
+;;
+;; 2) it makes their functionality accessible and modified by the
+;; Lisp programmer.
+;;
+;; 3) it allows Eshell to refrain from having to invoke external
+;; processes for common operations.
+
+(defcustom eshell-unix-load-hook '(eshell-unix-initialize)
+ "*A list of functions to run when `eshell-unix' is loaded."
+ :type 'hook
+ :group 'eshell-unix)
+
+(defcustom eshell-plain-grep-behavior nil
+ "*If non-nil, standalone \"grep\" commands will behave normally.
+Standalone in this context means not redirected, and not on the
+receiving side of a command pipeline."
+ :type 'boolean
+ :group 'eshell-unix)
+
+(defcustom eshell-no-grep-available (not (eshell-search-path "grep"))
+ "*If non-nil, no grep is available on the current machine."
+ :type 'boolean
+ :group 'eshell-unix)
+
+(defcustom eshell-plain-diff-behavior nil
+ "*If non-nil, standalone \"diff\" commands will behave normally.
+Standalone in this context means not redirected, and not on the
+receiving side of a command pipeline."
+ :type 'boolean
+ :group 'eshell-unix)
+
+(defcustom eshell-plain-locate-behavior nil
+ "*If non-nil, standalone \"locate\" commands will behave normally.
+Standalone in this context means not redirected, and not on the
+receiving side of a command pipeline."
+ :type 'boolean
+ :group 'eshell-unix)
+
+(defcustom eshell-rm-removes-directories nil
+ "*If non-nil, `rm' will remove directory entries.
+Otherwise, `rmdir' is required."
+ :type 'boolean
+ :group 'eshell-unix)
+
+(defcustom eshell-rm-interactive-query (= (user-uid) 0)
+ "*If non-nil, `rm' will query before removing anything."
+ :type 'boolean
+ :group 'eshell-unix)
+
+(defcustom eshell-mv-interactive-query (= (user-uid) 0)
+ "*If non-nil, `mv' will query before overwriting anything."
+ :type 'boolean
+ :group 'eshell-unix)
+
+(defcustom eshell-mv-overwrite-files t
+ "*If non-nil, `mv' will overwrite files without warning."
+ :type 'boolean
+ :group 'eshell-unix)
+
+(defcustom eshell-cp-interactive-query (= (user-uid) 0)
+ "*If non-nil, `cp' will query before overwriting anything."
+ :type 'boolean
+ :group 'eshell-unix)
+
+(defcustom eshell-cp-overwrite-files t
+ "*If non-nil, `cp' will overwrite files without warning."
+ :type 'boolean
+ :group 'eshell-unix)
+
+(defcustom eshell-ln-interactive-query (= (user-uid) 0)
+ "*If non-nil, `ln' will query before overwriting anything."
+ :type 'boolean
+ :group 'eshell-unix)
+
+(defcustom eshell-ln-overwrite-files t
+ "*If non-nil, `ln' will overwrite files without warning."
+ :type 'boolean
+ :group 'eshell-unix)
+
+(require 'esh-opt)
+
+;;; Functions:
+
+(defun eshell-unix-initialize ()
+ "Initialize the UNIX support/emulation code."
+ (make-local-hook 'eshell-post-command-hook)
+ (when (eshell-using-module 'eshell-cmpl)
+ (make-local-hook 'pcomplete-try-first-hook)
+ (add-hook 'pcomplete-try-first-hook
+ 'eshell-complete-host-reference nil t)))
+
+(defalias 'eshell/date 'current-time-string)
+(defalias 'eshell/basename 'file-name-nondirectory)
+(defalias 'eshell/dirname 'file-name-directory)
+
+(eval-when-compile
+ (defvar interactive)
+ (defvar preview)
+ (defvar recursive)
+ (defvar verbose))
+
+(defun eshell/man (&rest args)
+ "Invoke man, flattening the arguments appropriately."
+ (funcall 'man (apply 'eshell-flatten-and-stringify args)))
+
+(defun eshell-remove-entries (path files &optional top-level)
+ (while files
+ (if (string-match "\\`\\.\\.?\\'"
+ (file-name-nondirectory (car files)))
+ (if top-level
+ (eshell-error "rm: cannot remove `.' or `..'\n"))
+ (if (and (file-directory-p (car files))
+ (not (file-symlink-p (car files))))
+ (let ((dir (file-name-as-directory (car files))))
+ (eshell-remove-entries dir
+ (mapcar
+ (function
+ (lambda (file)
+ (concat dir file)))
+ (directory-files dir)))
+ (if verbose
+ (eshell-printn (format "rm: removing directory `%s'"
+ (car files))))
+ (unless
+ (or preview
+ (and interactive
+ (not (y-or-n-p
+ (format "rm: remove directory `%s'? "
+ (car files))))))
+ (eshell-funcalln 'delete-directory (car files))))
+ (if verbose
+ (eshell-printn (format "rm: removing file `%s'"
+ (car files))))
+ (unless (or preview
+ (and interactive
+ (not (y-or-n-p
+ (format "rm: remove `%s'? "
+ (car files))))))
+ (eshell-funcalln 'delete-file (car files)))))
+ (setq files (cdr files))))
+
+(defun eshell/rm (&rest args)
+ "Implementation of rm in Lisp.
+This is implemented to call either `delete-file', `kill-buffer',
+`kill-process', or `unintern', depending on the nature of the
+argument."
+ (setq args (eshell-flatten-list args))
+ (eshell-eval-using-options
+ "rm" args
+ '((?h "help" nil nil "show this usage screen")
+ (?f "force" nil force-removal "force removal")
+ (?i "interactive" nil interactive "prompt before any removal")
+ (?n "preview" nil preview "don't change anything on disk")
+ (?r "recursive" nil recursive
+ "remove the contents of directories recursively")
+ (?R nil nil recursive "(same)")
+ (?v "verbose" nil verbose "explain what is being done")
+ :preserve-args
+ :external "rm"
+ :show-usage
+ :usage "[OPTION]... FILE...
+Remove (unlink) the FILE(s).")
+ (unless interactive
+ (setq interactive eshell-rm-interactive-query))
+ (if (and force-removal interactive)
+ (setq interactive nil))
+ (while args
+ (let ((entry (if (stringp (car args))
+ (directory-file-name (car args))
+ (if (numberp (car args))
+ (number-to-string (car args))
+ (car args)))))
+ (cond
+ ((bufferp entry)
+ (if verbose
+ (eshell-printn (format "rm: removing buffer `%s'" entry)))
+ (unless (or preview
+ (and interactive
+ (not (y-or-n-p (format "rm: delete buffer `%s'? "
+ entry)))))
+ (eshell-funcalln 'kill-buffer entry)))
+ ((processp entry)
+ (if verbose
+ (eshell-printn (format "rm: killing process `%s'" entry)))
+ (unless (or preview
+ (and interactive
+ (not (y-or-n-p (format "rm: kill process `%s'? "
+ entry)))))
+ (eshell-funcalln 'kill-process entry)))
+ ((symbolp entry)
+ (if verbose
+ (eshell-printn (format "rm: uninterning symbol `%s'" entry)))
+ (unless
+ (or preview
+ (and interactive
+ (not (y-or-n-p (format "rm: unintern symbol `%s'? "
+ entry)))))
+ (eshell-funcalln 'unintern entry)))
+ ((stringp entry)
+ (if (and (file-directory-p entry)
+ (not (file-symlink-p entry)))
+ (if (or recursive
+ eshell-rm-removes-directories)
+ (if (or preview
+ (not interactive)
+ (y-or-n-p
+ (format "rm: descend into directory `%s'? "
+ entry)))
+ (eshell-remove-entries nil (list entry) t))
+ (eshell-error (format "rm: %s: is a directory\n" entry)))
+ (eshell-remove-entries nil (list entry) t)))))
+ (setq args (cdr args)))
+ nil))
+
+(defun eshell/mkdir (&rest args)
+ "Implementation of mkdir in Lisp."
+ (eshell-eval-using-options
+ "mkdir" args
+ '((?h "help" nil nil "show this usage screen")
+ :external "mkdir"
+ :show-usage
+ :usage "[OPTION] DIRECTORY...
+Create the DIRECTORY(ies), if they do not already exist.")
+ (while args
+ (eshell-funcalln 'make-directory (car args))
+ (setq args (cdr args)))
+ nil))
+
+(defun eshell/rmdir (&rest args)
+ "Implementation of rmdir in Lisp."
+ (eshell-eval-using-options
+ "rmdir" args
+ '((?h "help" nil nil "show this usage screen")
+ :external "rmdir"
+ :show-usage
+ :usage "[OPTION] DIRECTORY...
+Remove the DIRECTORY(ies), if they are empty.")
+ (while args
+ (eshell-funcalln 'delete-directory (car args))
+ (setq args (cdr args)))
+ nil))
+
+(eval-when-compile
+ (defvar no-dereference)
+ (defvar preview)
+ (defvar verbose))
+
+(defvar eshell-warn-dot-directories t)
+
+(defun eshell-shuffle-files (command action files target func deep &rest args)
+ "Shuffle around some filesystem entries, using FUNC to do the work."
+ (if (null target)
+ (error "%s: missing destination file" command))
+ (let ((attr-target (file-attributes target))
+ (is-dir (or (file-directory-p target)
+ (and preview (not eshell-warn-dot-directories))))
+ attr)
+ (if (and (not preview) (not is-dir)
+ (> (length files) 1))
+ (error "%s: when %s multiple files, last argument must be a directory"
+ command action))
+ (while files
+ (setcar files (directory-file-name (car files)))
+ (cond
+ ((string-match "\\`\\.\\.?\\'"
+ (file-name-nondirectory (car files)))
+ (if eshell-warn-dot-directories
+ (eshell-error (format "%s: %s: omitting directory\n"
+ command (car files)))))
+ ((and attr-target
+ (not (eshell-under-windows-p))
+ (setq attr (file-attributes (car files)))
+ (= (nth 10 attr-target) (nth 10 attr))
+ (= (nth 11 attr-target) (nth 11 attr)))
+ (eshell-error (format "%s: `%s' and `%s' are the same file\n"
+ command (car files) target)))
+ (t
+ (let ((source (car files))
+ (target (if is-dir
+ (expand-file-name
+ (file-name-nondirectory (car files)) target)
+ target))
+ link)
+ (if (and (file-directory-p source)
+ (or (not no-dereference)
+ (not (file-symlink-p source)))
+ (not (memq func '(make-symbolic-link
+ add-name-to-file))))
+ (if (and (eq func 'copy-file)
+ (not recursive))
+ (eshell-error (format "%s: %s: omitting directory\n"
+ command (car files)))
+ (let (eshell-warn-dot-directories)
+ (if (and (not deep)
+ (eq func 'rename-file)
+ (= (nth 11 (file-attributes
+ (file-name-directory
+ (expand-file-name source))))
+ (nth 11 (file-attributes
+ (file-name-directory
+ (expand-file-name target))))))
+ (apply 'eshell-funcalln func source target args)
+ (unless (file-directory-p target)
+ (if verbose
+ (eshell-printn
+ (format "%s: making directory %s"
+ command target)))
+ (unless preview
+ (eshell-funcalln 'make-directory target)))
+ (eshell-shuffle-files command action
+ (mapcar
+ (function
+ (lambda (file)
+ (concat source "/" file)))
+ (directory-files source))
+ target func t args)
+ (when (eq func 'rename-file)
+ (if verbose
+ (eshell-printn
+ (format "%s: deleting directory %s"
+ command source)))
+ (unless preview
+ (eshell-funcalln 'delete-directory source))))))
+ (if verbose
+ (eshell-printn (format "%s: %s -> %s" command
+ source target)))
+ (unless preview
+ (if (and no-dereference
+ (setq link (file-symlink-p source)))
+ (progn
+ (apply 'eshell-funcalln 'make-symbolic-link
+ link target args)
+ (if (eq func 'rename-file)
+ (if (and (file-directory-p source)
+ (not (file-symlink-p source)))
+ (eshell-funcalln 'delete-directory source)
+ (eshell-funcalln 'delete-file source))))
+ (apply 'eshell-funcalln func source target args)))))))
+ (setq files (cdr files)))))
+
+(defun eshell-shorthand-tar-command (command args)
+ "Rewrite `cp -v dir a.tar.gz' to `tar cvzf a.tar.gz dir'."
+ (let* ((archive (car (last args)))
+ (tar-args
+ (cond ((string-match "z2" archive) "If")
+ ((string-match "gz" archive) "zf")
+ ((string-match "\\(az\\|Z\\)" archive) "Zf")
+ (t "f"))))
+ (if (file-exists-p archive)
+ (setq tar-args (concat "u" tar-args))
+ (setq tar-args (concat "c" tar-args)))
+ (if verbose
+ (setq tar-args (concat "v" tar-args)))
+ (if (equal command "mv")
+ (setq tar-args (concat "--remove-files -" tar-args)))
+ ;; truncate the archive name from the arguments
+ (setcdr (last args 2) nil)
+ (throw 'eshell-replace-command
+ (eshell-parse-command
+ (format "tar %s %s" tar-args archive) args))))
+
+;; this is to avoid duplicating code...
+(defmacro eshell-mvcp-template
+ (command action func query-var force-var &optional preserve)
+ `(if (and (string-match eshell-tar-regexp (car (last args)))
+ (or (> (length args) 2)
+ (and (file-directory-p (car args))
+ (or (not no-dereference)
+ (not (file-symlink-p (car args)))))))
+ (eshell-shorthand-tar-command ,command args)
+ (let (target)
+ (if (> (length args) 1)
+ (progn
+ (setq target (car (last args)))
+ (setcdr (last args 2) nil))
+ (setq args nil))
+ (eshell-shuffle-files
+ ,command ,action args target ,func nil
+ ,@(append
+ `((if (and (or interactive
+ ,query-var)
+ (not force))
+ 1 (or force ,force-var)))
+ (if preserve
+ (list preserve)))))
+ nil))
+
+(defun eshell/mv (&rest args)
+ "Implementation of mv in Lisp."
+ (eshell-eval-using-options
+ "mv" args
+ '((?f "force" nil force
+ "remove existing destinations, never prompt")
+ (?i "interactive" nil interactive
+ "request confirmation if target already exists")
+ (?n "preview" nil preview
+ "don't change anything on disk")
+ (?v "verbose" nil verbose
+ "explain what is being done")
+ (nil "help" nil nil "show this usage screen")
+ :external "mv"
+ :show-usage
+ :usage "[OPTION]... SOURCE DEST
+ or: mv [OPTION]... SOURCE... DIRECTORY
+Rename SOURCE to DEST, or move SOURCE(s) to DIRECTORY.
+\[OPTION] DIRECTORY...")
+ (let ((no-dereference t))
+ (eshell-mvcp-template "mv" "moving" 'rename-file
+ eshell-mv-interactive-query
+ eshell-mv-overwrite-files))))
+
+(defun eshell/cp (&rest args)
+ "Implementation of cp in Lisp."
+ (eshell-eval-using-options
+ "cp" args
+ '((?a "archive" nil archive
+ "same as -dpR")
+ (?d "no-dereference" nil no-dereference
+ "preserve links")
+ (?f "force" nil force
+ "remove existing destinations, never prompt")
+ (?i "interactive" nil interactive
+ "request confirmation if target already exists")
+ (?n "preview" nil preview
+ "don't change anything on disk")
+ (?p "preserve" nil preserve
+ "preserve file attributes if possible")
+ (?R "recursive" nil recursive
+ "copy directories recursively")
+ (?v "verbose" nil verbose
+ "explain what is being done")
+ (nil "help" nil nil "show this usage screen")
+ :external "cp"
+ :show-usage
+ :usage "[OPTION]... SOURCE DEST
+ or: cp [OPTION]... SOURCE... DIRECTORY
+Copy SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY.")
+ (if archive
+ (setq preserve t no-dereference t recursive t))
+ (eshell-mvcp-template "cp" "copying" 'copy-file
+ eshell-cp-interactive-query
+ eshell-cp-overwrite-files preserve)))
+
+(defun eshell/ln (&rest args)
+ "Implementation of ln in Lisp."
+ (eshell-eval-using-options
+ "ln" args
+ '((?h "help" nil nil "show this usage screen")
+ (?s "symbolic" nil symbolic
+ "make symbolic links instead of hard links")
+ (?i "interactive" nil interactive "request confirmation if target already exists")
+ (?f "force" nil force "remove existing destinations, never prompt")
+ (?n "preview" nil preview
+ "don't change anything on disk")
+ (?v "verbose" nil verbose "explain what is being done")
+ :external "ln"
+ :show-usage
+ :usage "[OPTION]... TARGET [LINK_NAME]
+ or: ln [OPTION]... TARGET... DIRECTORY
+Create a link to the specified TARGET with optional LINK_NAME. If there is
+more than one TARGET, the last argument must be a directory; create links
+in DIRECTORY to each TARGET. Create hard links by default, symbolic links
+with '--symbolic'. When creating hard links, each TARGET must exist.")
+ (let (target no-dereference)
+ (if (> (length args) 1)
+ (progn
+ (setq target (car (last args)))
+ (setcdr (last args 2) nil))
+ (setq args nil))
+ (eshell-shuffle-files "ln" "linking" args target
+ (if symbolic
+ 'make-symbolic-link
+ 'add-name-to-file) nil
+ (if (and (or interactive
+ eshell-ln-interactive-query)
+ (not force))
+ 1 (or force eshell-ln-overwrite-files))))
+ nil))
+
+(defun eshell/cat (&rest args)
+ "Implementation of cat in Lisp."
+ (if eshell-in-pipeline-p
+ (throw 'eshell-replace-command
+ (eshell-parse-command "*cat" args))
+ (eshell-init-print-buffer)
+ (eshell-eval-using-options
+ "cat" args
+ '((?h "help" nil nil "show this usage screen")
+ :external "cat"
+ :show-usage
+ :usage "[OPTION] FILE...
+Concatenate FILE(s), or standard input, to standard output.")
+ (eshell-for file args
+ (if (string= file "-")
+ (throw 'eshell-external
+ (eshell-external-command "cat" args))))
+ (let ((curbuf (current-buffer)))
+ (eshell-for file args
+ (with-temp-buffer
+ (insert-file-contents file)
+ (goto-char (point-min))
+ (while (not (eobp))
+ (let ((str (buffer-substring
+ (point) (min (1+ (line-end-position))
+ (point-max)))))
+ (with-current-buffer curbuf
+ (eshell-buffered-print str)))
+ (forward-line)))))
+ (eshell-flush)
+ ;; if the file does not end in a newline, do not emit one
+ (setq eshell-ensure-newline-p nil))))
+
+;; special front-end functions for compilation-mode buffers
+
+(defun eshell/make (&rest args)
+ "Use `compile' to do background makes."
+ (if (and eshell-current-subjob-p
+ (eshell-interactive-output-p))
+ (let ((compilation-process-setup-function
+ (list 'lambda nil
+ (list 'setq 'process-environment
+ (list 'quote (eshell-copy-environment))))))
+ (compile (concat "make " (eshell-flatten-and-stringify args))))
+ (throw 'eshell-replace-command
+ (eshell-parse-command "*make" args))))
+
+(defun eshell-occur-mode-goto-occurrence ()
+ "Go to the occurrence the current line describes."
+ (interactive)
+ (let ((pos (occur-mode-find-occurrence)))
+ (pop-to-buffer (marker-buffer pos))
+ (goto-char (marker-position pos))))
+
+(defun eshell-occur-mode-mouse-goto (event)
+ "In Occur mode, go to the occurrence whose line you click on."
+ (interactive "e")
+ (let (buffer pos)
+ (save-excursion
+ (set-buffer (window-buffer (posn-window (event-end event))))
+ (save-excursion
+ (goto-char (posn-point (event-end event)))
+ (setq pos (occur-mode-find-occurrence))
+ (setq buffer occur-buffer)))
+ (pop-to-buffer (marker-buffer pos))
+ (goto-char (marker-position pos))))
+
+(defun eshell-poor-mans-grep (args)
+ "A poor version of grep that opens every file and uses `occur'.
+This eats up memory, since it leaves the buffers open (to speed future
+searches), and it's very slow. But, if your system has no grep
+available..."
+ (save-selected-window
+ (let ((default-dir default-directory))
+ (with-current-buffer (get-buffer-create "*grep*")
+ (let ((inhibit-read-only t)
+ (default-directory default-dir))
+ (erase-buffer)
+ (occur-mode)
+ (let ((files (eshell-flatten-list (cdr args)))
+ (inhibit-redisplay t)
+ string)
+ (when (car args)
+ (if (get-buffer "*Occur*")
+ (kill-buffer (get-buffer "*Occur*")))
+ (setq string nil)
+ (while files
+ (with-current-buffer (find-file-noselect (car files))
+ (save-excursion
+ (ignore-errors
+ (occur (car args))))
+ (if (get-buffer "*Occur*")
+ (with-current-buffer (get-buffer "*Occur*")
+ (setq string (buffer-string))
+ (kill-buffer (current-buffer)))))
+ (if string (insert string))
+ (setq string nil
+ files (cdr files)))))
+ (setq occur-buffer (current-buffer))
+ (local-set-key [mouse-2] 'eshell-occur-mode-mouse-goto)
+ (local-set-key [(control ?c) (control ?c)]
+ 'eshell-occur-mode-goto-occurrence)
+ (local-set-key [(control ?m)]
+ 'eshell-occur-mode-goto-occurrence)
+ (local-set-key [return] 'eshell-occur-mode-goto-occurrence)
+ (pop-to-buffer (current-buffer) t)
+ (goto-char (point-min))
+ (resize-temp-buffer-window))))))
+
+(defun eshell-grep (command args &optional maybe-use-occur)
+ "Generic service function for the various grep aliases.
+It calls Emacs' grep utility if the command is not redirecting output,
+and if it's not part of a command pipeline. Otherwise, it calls the
+external command."
+ (if (and maybe-use-occur eshell-no-grep-available)
+ (eshell-poor-mans-grep args)
+ (if (or eshell-plain-grep-behavior
+ (not (and (eshell-interactive-output-p)
+ (not eshell-in-pipeline-p)
+ (not eshell-in-subcommand-p))))
+ (throw 'eshell-replace-command
+ (eshell-parse-command (concat "*" command) args))
+ (let* ((compilation-process-setup-function
+ (list 'lambda nil
+ (list 'setq 'process-environment
+ (list 'quote (eshell-copy-environment)))))
+ (args (mapconcat 'identity
+ (mapcar 'shell-quote-argument
+ (eshell-flatten-list args))
+ " "))
+ (cmd (progn
+ (set-text-properties 0 (length args)
+ '(invisible t) args)
+ (format "%s -n %s" command args)))
+ compilation-scroll-output)
+ (grep cmd)))))
+
+(defun eshell/grep (&rest args)
+ "Use Emacs grep facility instead of calling external grep."
+ (eshell-grep "grep" args t))
+
+(defun eshell/egrep (&rest args)
+ "Use Emacs grep facility instead of calling external egrep."
+ (eshell-grep "egrep" args t))
+
+(defun eshell/fgrep (&rest args)
+ "Use Emacs grep facility instead of calling external fgrep."
+ (eshell-grep "fgrep" args t))
+
+(defun eshell/agrep (&rest args)
+ "Use Emacs grep facility instead of calling external agrep."
+ (eshell-grep "agrep" args))
+
+(defun eshell/glimpse (&rest args)
+ "Use Emacs grep facility instead of calling external glimpse."
+ (let (null-device)
+ (eshell-grep "glimpse" (append '("-z" "-y") args))))
+
+;; completions rules for some common UNIX commands
+
+(defsubst eshell-complete-hostname ()
+ "Complete a command that wants a hostname for an argument."
+ (pcomplete-here (eshell-read-host-names)))
+
+(defun eshell-complete-host-reference ()
+ "If there is a host reference, complete it."
+ (let ((arg (pcomplete-actual-arg))
+ index)
+ (when (setq index (string-match "@[a-z.]*\\'" arg))
+ (setq pcomplete-stub (substring arg (1+ index))
+ pcomplete-last-completion-raw t)
+ (throw 'pcomplete-completions (eshell-read-host-names)))))
+
+(defalias 'pcomplete/ftp 'eshell-complete-hostname)
+(defalias 'pcomplete/ncftp 'eshell-complete-hostname)
+(defalias 'pcomplete/ping 'eshell-complete-hostname)
+(defalias 'pcomplete/rlogin 'eshell-complete-hostname)
+
+(defun pcomplete/telnet ()
+ (require 'pcmpl-unix)
+ (pcomplete-opt "xl(pcmpl-unix-user-names)")
+ (eshell-complete-hostname))
+
+(defun pcomplete/rsh ()
+ "Complete `rsh', which, after the user and hostname, is like xargs."
+ (require 'pcmpl-unix)
+ (pcomplete-opt "l(pcmpl-unix-user-names)")
+ (eshell-complete-hostname)
+ (pcomplete-here (funcall pcomplete-command-completion-function))
+ (funcall (or (pcomplete-find-completion-function (pcomplete-arg 1))
+ pcomplete-default-completion-function)))
+
+(defalias 'pcomplete/ssh 'pcomplete/rsh)
+
+(eval-when-compile
+ (defvar block-size)
+ (defvar by-bytes)
+ (defvar dereference-links)
+ (defvar grand-total)
+ (defvar human-readable)
+ (defvar max-depth)
+ (defvar only-one-filesystem)
+ (defvar show-all))
+
+(defsubst eshell-du-size-string (size)
+ (let* ((str (eshell-printable-size size human-readable block-size t))
+ (len (length str)))
+ (concat str (if (< len 8)
+ (make-string (- 8 len) ? )))))
+
+(defun eshell-du-sum-directory (path depth)
+ "Summarize PATH, and its member directories."
+ (let ((entries (eshell-directory-files-and-attributes path))
+ (size 0.0))
+ (while entries
+ (unless (string-match "\\`\\.\\.?\\'" (caar entries))
+ (let* ((entry (concat path (char-to-string directory-sep-char)
+ (caar entries)))
+ (symlink (and (stringp (cadr (car entries)))
+ (cadr (car entries)))))
+ (unless (or (and symlink (not dereference-links))
+ (and only-one-filesystem
+ (not (= only-one-filesystem
+ (nth 12 (car entries))))))
+ (if symlink
+ (setq entry symlink))
+ (setq size
+ (+ size
+ (if (eq t (cadr (car entries)))
+ (eshell-du-sum-directory entry (1+ depth))
+ (let ((file-size (nth 8 (car entries))))
+ (prog1
+ file-size
+ (if show-all
+ (eshell-print
+ (concat (eshell-du-size-string file-size)
+ entry "\n")))))))))))
+ (setq entries (cdr entries)))
+ (if (or (not max-depth)
+ (= depth max-depth)
+ (= depth 0))
+ (eshell-print (concat (eshell-du-size-string size)
+ (directory-file-name path) "\n")))
+ size))
+
+(defun eshell/du (&rest args)
+ "Implementation of \"du\" in Lisp, passing RAGS."
+ (if (eshell-search-path "du")
+ (throw 'eshell-replace-command
+ (eshell-parse-command "*du" args))
+ (eshell-eval-using-options
+ "du" args
+ '((?a "all" nil show-all
+ "write counts for all files, not just directories")
+ (nil "block-size" t block-size
+ "use SIZE-byte blocks (i.e., --block-size SIZE)")
+ (?b "bytes" nil by-bytes
+ "print size in bytes")
+ (?c "total" nil grand-total
+ "produce a grand total")
+ (?d "max-depth" t max-depth
+ "display data only this many levels of data")
+ (?h "human-readable" 1024 human-readable
+ "print sizes in human readable format")
+ (?H "is" 1000 human-readable
+ "likewise, but use powers of 1000 not 1024")
+ (?k "kilobytes" 1024 block-size
+ "like --block-size 1024")
+ (?L "dereference" nil dereference-links
+ "dereference all symbolic links")
+ (?m "megabytes" 1048576 block-size
+ "like --block-size 1048576")
+ (?s "summarize" 0 max-depth
+ "display only a total for each argument")
+ (?x "one-file-system" nil only-one-filesystem
+ "skip directories on different filesystems")
+ (nil "help" nil nil
+ "show this usage screen")
+ :external "du"
+ :usage "[OPTION]... FILE...
+Summarize disk usage of each FILE, recursively for directories.")
+ (unless by-bytes
+ (setq block-size (or block-size 1024)))
+ (if (and max-depth (stringp max-depth))
+ (setq max-depth (string-to-int max-depth)))
+ ;; filesystem support means nothing under Windows
+ (if (eshell-under-windows-p)
+ (setq only-one-filesystem nil))
+ (unless args
+ (setq args '(".")))
+ (let ((size 0.0))
+ (while args
+ (if only-one-filesystem
+ (setq only-one-filesystem
+ (nth 11 (file-attributes
+ (file-name-as-directory (car args))))))
+ (setq size (+ size (eshell-du-sum-directory
+ (directory-file-name (car args)) 0)))
+ (setq args (cdr args)))
+ (if grand-total
+ (eshell-print (concat (eshell-du-size-string size)
+ "total\n")))))))
+
+(defvar eshell-time-start nil)
+
+(defun eshell-show-elapsed-time ()
+ (let ((elapsed (format "%.3f secs\n"
+ (- (eshell-time-to-seconds (current-time))
+ eshell-time-start))))
+ (set-text-properties 0 (length elapsed) '(face bold) elapsed)
+ (eshell-interactive-print elapsed))
+ (remove-hook 'eshell-post-command-hook 'eshell-show-elapsed-time t))
+
+(defun eshell/time (&rest args)
+ "Implementation of \"time\" in Lisp."
+ (let ((time-args (copy-alist args))
+ (continue t)
+ last-arg)
+ (while (and continue args)
+ (if (not (string-match "^-" (car args)))
+ (progn
+ (if last-arg
+ (setcdr last-arg nil)
+ (setq args '("")))
+ (setq continue nil))
+ (setq last-arg args
+ args (cdr args))))
+ (eshell-eval-using-options
+ "time" args
+ '((?h "help" nil nil "show this usage screen")
+ :external "time"
+ :show-usage
+ :usage "COMMAND...
+Show wall-clock time elapsed during execution of COMMAND.")
+ (setq eshell-time-start (eshell-time-to-seconds (current-time)))
+ (add-hook 'eshell-post-command-hook 'eshell-show-elapsed-time nil t)
+ ;; after setting
+ (throw 'eshell-replace-command
+ (eshell-parse-command (car time-args) (cdr time-args))))))
+
+(defalias 'eshell/whoami 'user-login-name)
+
+(defvar eshell-diff-window-config nil)
+
+(defun eshell-diff-quit ()
+ "Restore the window configuration previous to diff'ing."
+ (interactive)
+ (if eshell-diff-window-config
+ (set-window-configuration eshell-diff-window-config)))
+
+(defun eshell/diff (&rest args)
+ "Alias \"diff\" to call Emacs `diff' function."
+ (if (or eshell-plain-diff-behavior
+ (not (and (eshell-interactive-output-p)
+ (not eshell-in-pipeline-p)
+ (not eshell-in-subcommand-p))))
+ (throw 'eshell-replace-command
+ (eshell-parse-command "*diff" args))
+ (setq args (eshell-flatten-list args))
+ (if (< (length args) 2)
+ (error "diff: missing operand"))
+ (let ((old (car (last args 2)))
+ (new (car (last args)))
+ (config (current-window-configuration)))
+ (if (= (length args) 2)
+ (setq args nil)
+ (setcdr (last args 3) nil))
+ (with-current-buffer
+ (diff old new (eshell-flatten-and-stringify args))
+ (when (fboundp 'diff-mode)
+ (diff-mode)
+ (set (make-local-variable 'eshell-diff-window-config) config)
+ (local-set-key [?q] 'eshell-diff-quit)
+ (if (fboundp 'turn-on-font-lock-if-enabled)
+ (turn-on-font-lock-if-enabled))))
+ (other-window 1)
+ (goto-char (point-min))
+ nil)))
+
+(defun eshell/locate (&rest args)
+ "Alias \"locate\" to call Emacs `locate' function."
+ (if (or eshell-plain-locate-behavior
+ (not (and (eshell-interactive-output-p)
+ (not eshell-in-pipeline-p)
+ (not eshell-in-subcommand-p)))
+ (and (stringp (car args))
+ (string-match "^-" (car args))))
+ (throw 'eshell-replace-command
+ (eshell-parse-command "*locate" args))
+ (save-selected-window
+ (let ((locate-history-list (list (car args))))
+ (locate-with-filter (car args) (cadr args))))))
+
+(defun eshell/occur (&rest args)
+ "Alias \"occur\" to call Emacs `occur' function."
+ (let ((inhibit-read-only t))
+ (if args
+ (error "usage: occur: (REGEXP)")
+ (occur (car args)))))
+
+;;; Code:
+
+;;; em-unix.el ends here
--- /dev/null
+;;; em-xtra --- extra alias functions
+
+;; Copyright (C) 1999, 2000 Free Sofware Foundation
+
+;; 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 2, 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+(provide 'em-xtra)
+
+(eval-when-compile (require 'esh-maint))
+
+(defgroup eshell-xtra nil
+ "This module defines some extra alias functions which are entirely
+optional. They can be viewed as samples for how to write Eshell alias
+functions, or as aliases which make some of Emacs' behavior more
+naturally accessible within Emacs."
+ :tag "Extra alias functions"
+ :group 'eshell-module)
+
+;;; Commentary:
+
+(require 'compile)
+
+;;; Functions:
+
+(defun eshell/expr (&rest args)
+ "Implementation of expr, using the calc package."
+ (if (not (fboundp 'calc-eval))
+ (throw 'eshell-replace-command
+ (eshell-parse-command "*expr" args))
+ ;; to fool the byte-compiler...
+ (let ((func 'calc-eval))
+ (funcall func (eshell-flatten-and-stringify args)))))
+
+(defun eshell/substitute (&rest args)
+ "Easy front-end to `intersection', for comparing lists of strings."
+ (apply 'substitute (car args) (cadr args) :test 'equal
+ (cddr args)))
+
+(defun eshell/count (&rest args)
+ "Easy front-end to `intersection', for comparing lists of strings."
+ (apply 'count (car args) (cadr args) :test 'equal
+ (cddr args)))
+
+(defun eshell/mismatch (&rest args)
+ "Easy front-end to `intersection', for comparing lists of strings."
+ (apply 'mismatch (car args) (cadr args) :test 'equal
+ (cddr args)))
+
+(defun eshell/union (&rest args)
+ "Easy front-end to `intersection', for comparing lists of strings."
+ (apply 'union (car args) (cadr args) :test 'equal
+ (cddr args)))
+
+(defun eshell/intersection (&rest args)
+ "Easy front-end to `intersection', for comparing lists of strings."
+ (apply 'intersection (car args) (cadr args) :test 'equal
+ (cddr args)))
+
+(defun eshell/set-difference (&rest args)
+ "Easy front-end to `intersection', for comparing lists of strings."
+ (apply 'set-difference (car args) (cadr args) :test 'equal
+ (cddr args)))
+
+(defun eshell/set-exclusive-or (&rest args)
+ "Easy front-end to `intersection', for comparing lists of strings."
+ (apply 'set-exclusive-or (car args) (cadr args) :test 'equal
+ (cddr args)))
+
+(defalias 'eshell/ff 'find-name-dired)
+(defalias 'eshell/gf 'find-grep-dired)
+
+(defun pcomplete/bcc32 ()
+ "Completion function for Borland's C++ compiler."
+ (let ((cur (pcomplete-arg 0)))
+ (cond
+ ((string-match "\\`-w\\([^;]+;\\)*\\([^;]*\\)\\'" cur)
+ (pcomplete-here
+ '("ali" "amb" "amp" "asc" "asm" "aus" "bbf" "bei" "big" "ccc"
+ "cln" "cod" "com" "cpt" "csu" "def" "dig" "dpu" "dsz" "dup"
+ "eas" "eff" "ext" "hch" "hid" "ias" "ibc" "ifr" "ill" "nil"
+ "lin" "lvc" "mcs" "mes" "mpc" "mpd" "msg" "nak" "ncf" "nci"
+ "ncl" "nfd" "ngu" "nin" "nma" "nmu" "nod" "nop" "npp" "nsf"
+ "nst" "ntd" "nto" "nvf" "obi" "obs" "ofp" "osh" "ovf" "par"
+ "pch" "pck" "pia" "pin" "pow" "prc" "pre" "pro" "rch" "ret"
+ "rng" "rpt" "rvl" "sig" "spa" "stl" "stu" "stv" "sus" "tai"
+ "tes" "thr" "ucp" "use" "voi" "zdi") (match-string 2 cur)))
+ ((string-match "\\`-[LIn]\\([^;]+;\\)*\\([^;]*\\)\\'" cur)
+ (pcomplete-here (pcomplete-dirs) (match-string 2 cur)))
+ ((string-match "\\`-[Ee]\\(.*\\)\\'" cur)
+ (pcomplete-here (pcomplete-dirs-or-entries "\\.[Ee][Xx][Ee]\\'")
+ (match-string 1 cur)))
+ ((string-match "\\`-o\\(.*\\)\\'" cur)
+ (pcomplete-here (pcomplete-dirs-or-entries "\\.[Oo][Bb][Jj]\\'")
+ (match-string 1 cur)))
+ (t
+ (pcomplete-opt "3456ABCDEHIKLMNOPRSTUVXabcdefgijklnoptuvwxyz"))))
+ (while (pcomplete-here
+ (pcomplete-dirs-or-entries "\\.[iCc]\\([Pp][Pp]\\)?\\'"))))
+
+(defalias 'pcomplete/bcc 'pcomplete/bcc32)
+
+;;; Code:
+
+;;; em-xtra.el ends here
--- /dev/null
+;;; esh-arg --- argument processing
+
+;; Copyright (C) 1999, 2000 Free Sofware Foundation
+
+;; 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 2, 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+(provide 'esh-arg)
+
+(eval-when-compile (require 'esh-maint))
+
+(defgroup eshell-arg nil
+ "Argument parsing involves transforming the arguments passed on the
+command line into equivalent Lisp forms that, when evaluated, will
+yield the values intended."
+ :tag "Argument parsing"
+ :group 'eshell)
+
+;;; Commentary:
+
+;; Parsing of arguments can be extended by adding functions to the
+;; hook `eshell-parse-argument-hook'. For a good example of this, see
+;; `eshell-parse-drive-letter', defined in eshell-dirs.el.
+
+(defcustom eshell-parse-argument-hook
+ (list
+ ;; a term such as #<buffer NAME>, or #<process NAME> is a buffer
+ ;; or process reference
+ 'eshell-parse-special-reference
+
+ ;; numbers convert to numbers if they stand alone
+ (function
+ (lambda ()
+ (when (and (not eshell-current-argument)
+ (not eshell-current-quoted)
+ (looking-at eshell-number-regexp)
+ (eshell-arg-delimiter (match-end 0)))
+ (goto-char (match-end 0))
+ (string-to-number (match-string 0)))))
+
+ ;; parse any non-special characters, based on the current context
+ (function
+ (lambda ()
+ (unless eshell-inside-quote-regexp
+ (setq eshell-inside-quote-regexp
+ (format "[^%s]+"
+ (apply 'string eshell-special-chars-inside-quoting))))
+ (unless eshell-outside-quote-regexp
+ (setq eshell-outside-quote-regexp
+ (format "[^%s]+"
+ (apply 'string eshell-special-chars-outside-quoting))))
+ (when (looking-at (if eshell-current-quoted
+ eshell-inside-quote-regexp
+ eshell-outside-quote-regexp))
+ (goto-char (match-end 0))
+ (let ((str (match-string 0)))
+ (if str
+ (set-text-properties 0 (length str) nil str))
+ str))))
+
+ ;; whitespace or a comment is an argument delimiter
+ (function
+ (lambda ()
+ (let (comment-p)
+ (when (or (looking-at "[ \t]+")
+ (and (not eshell-current-argument)
+ (looking-at "#\\([^<'].*\\|$\\)")
+ (setq comment-p t)))
+ (if comment-p
+ (add-text-properties (match-beginning 0) (match-end 0)
+ '(comment t)))
+ (goto-char (match-end 0))
+ (eshell-finish-arg)))))
+
+ ;; backslash before a special character means escape it
+ 'eshell-parse-backslash
+
+ ;; text beginning with ' is a literally quoted
+ 'eshell-parse-literal-quote
+
+ ;; text beginning with " is interpolably quoted
+ 'eshell-parse-double-quote
+
+ ;; argument delimiter
+ 'eshell-parse-delimiter)
+ "*Define how to process Eshell command line arguments.
+When each function on this hook is called, point will be at the
+current position within the argument list. The function should either
+return nil, meaning that it did no argument parsing, or it should
+return the result of the parse as a sexp. It is also responsible for
+moving the point forward to reflect the amount of input text that was
+parsed.
+
+If no function handles the current character at point, it will be
+treated as a literal character."
+ :type 'hook
+ :group 'eshell-arg)
+
+;;; Code:
+
+;;; User Variables:
+
+(defcustom eshell-arg-load-hook '(eshell-arg-initialize)
+ "*A hook that gets run when `eshell-arg' is loaded."
+ :type 'hook
+ :group 'eshell-arg)
+
+(defcustom eshell-delimiter-argument-list '(?\; ?& ?\| ?\> ? ?\t ?\n)
+ "List of characters to recognize as argument separators."
+ :type '(repeat character)
+ :group 'eshell-arg)
+
+(defcustom eshell-special-chars-inside-quoting '(?\\ ?\")
+ "*Characters which are still special inside double quotes."
+ :type '(repeat character)
+ :group 'eshell-arg)
+
+(defcustom eshell-special-chars-outside-quoting
+ (append eshell-delimiter-argument-list '(?# ?! ?\\ ?\" ?\'))
+ "*Characters that require escaping outside of double quotes.
+Without escaping them, they will introduce a change in the argument."
+ :type '(repeat character)
+ :group 'eshell-arg)
+
+;;; Internal Variables:
+
+(defvar eshell-current-argument nil)
+(defvar eshell-current-modifiers nil)
+(defvar eshell-arg-listified nil)
+(defvar eshell-nested-argument nil)
+(defvar eshell-current-quoted nil)
+(defvar eshell-inside-quote-regexp nil)
+(defvar eshell-outside-quote-regexp nil)
+
+;;; Functions:
+
+(defun eshell-arg-initialize ()
+ "Initialize the argument parsing code."
+ (define-key eshell-command-map [(meta ?b)] 'eshell-insert-buffer-name)
+ (set (make-local-variable 'eshell-inside-quote-regexp) nil)
+ (set (make-local-variable 'eshell-outside-quote-regexp) nil))
+
+(defun eshell-insert-buffer-name (buffer-name)
+ "Insert BUFFER-NAME into the current buffer at point."
+ (interactive "BName of buffer: ")
+ (insert-and-inherit "#<buffer " buffer-name ">"))
+
+(defsubst eshell-escape-arg (string)
+ "Return STRING with the `escaped' property on it."
+ (if (stringp string)
+ (add-text-properties 0 (length string) '(escaped t) string))
+ string)
+
+(defun eshell-resolve-current-argument ()
+ "If there are pending modifications to be made, make them now."
+ (when eshell-current-argument
+ (when eshell-arg-listified
+ (let ((parts eshell-current-argument))
+ (while parts
+ (unless (stringp (car parts))
+ (setcar parts
+ (list 'eshell-to-flat-string (car parts))))
+ (setq parts (cdr parts)))
+ (setq eshell-current-argument
+ (list 'eshell-convert
+ (append (list 'concat) eshell-current-argument))))
+ (setq eshell-arg-listified nil))
+ (while eshell-current-modifiers
+ (setq eshell-current-argument
+ (list (car eshell-current-modifiers) eshell-current-argument)
+ eshell-current-modifiers (cdr eshell-current-modifiers))))
+ (setq eshell-current-modifiers nil))
+
+(defun eshell-finish-arg (&optional argument)
+ "Finish the current argument being processed."
+ (if argument
+ (setq eshell-current-argument argument))
+ (throw 'eshell-arg-done t))
+
+(defsubst eshell-arg-delimiter (&optional pos)
+ "Return non-nil if POS is an argument delimiter.
+If POS is nil, the location of point is checked."
+ (let ((pos (or pos (point))))
+ (or (= pos (point-max))
+ (memq (char-after pos) eshell-delimiter-argument-list))))
+
+;; Argument parsing
+
+(defun eshell-parse-arguments (beg end)
+ "Parse all of the arguments at point from BEG to END.
+Returns the list of arguments in their raw form.
+Point is left at the end of the arguments."
+ (save-excursion
+ (save-restriction
+ (goto-char beg)
+ (narrow-to-region beg end)
+ (let ((inhibit-point-motion-hooks t)
+ (args (list t))
+ after-change-functions
+ delim)
+ (remove-text-properties (point-min) (point-max)
+ '(arg-begin nil arg-end nil))
+ (if (setq
+ delim
+ (catch 'eshell-incomplete
+ (while (not (eobp))
+ (let* ((here (point))
+ (arg (eshell-parse-argument)))
+ (if (= (point) here)
+ (error "Failed to parse argument '%s'"
+ (buffer-substring here (point-max))))
+ (and arg (nconc args (list arg)))))))
+ (if (listp delim)
+ (throw 'eshell-incomplete delim)
+ (throw 'eshell-incomplete
+ (list delim (point) (cdr args)))))
+ (cdr args)))))
+
+(defun eshell-parse-argument ()
+ "Get the next argument. Leave point after it."
+ (let* ((outer (null eshell-nested-argument))
+ (arg-begin (and outer (point)))
+ (eshell-nested-argument t)
+ eshell-current-argument
+ eshell-current-modifiers
+ eshell-arg-listified)
+ (catch 'eshell-arg-done
+ (while (not (eobp))
+ (let ((result
+ (or (run-hook-with-args-until-success
+ 'eshell-parse-argument-hook)
+ (prog1
+ (char-to-string (char-after))
+ (forward-char)))))
+ (if (not eshell-current-argument)
+ (setq eshell-current-argument result)
+ (unless eshell-arg-listified
+ (setq eshell-current-argument
+ (list eshell-current-argument)
+ eshell-arg-listified t))
+ (nconc eshell-current-argument (list result))))))
+ (when (and outer eshell-current-argument)
+ (add-text-properties arg-begin (1+ arg-begin)
+ '(arg-begin t rear-nonsticky
+ (arg-begin arg-end)))
+ (add-text-properties (1- (point)) (point)
+ '(arg-end t rear-nonsticky
+ (arg-end arg-begin))))
+ (eshell-resolve-current-argument)
+ eshell-current-argument))
+
+(defsubst eshell-operator (&rest args)
+ "A stub function that generates an error if a floating operator is found."
+ (error "Unhandled operator in input text"))
+
+(defsubst eshell-looking-at-backslash-return (pos)
+ "Test whether a backslash-return sequence occurs at POS."
+ (and (eq (char-after pos) ?\\)
+ (or (= (1+ pos) (point-max))
+ (and (eq (char-after (1+ pos)) ?\n)
+ (= (+ pos 2) (point-max))))))
+
+(defun eshell-quote-backslash (string &optional index)
+ "Intelligently backslash the character occuring in STRING at INDEX.
+If the character is itself a backslash, it needs no escaping."
+ (let ((char (aref string index)))
+ (if (eq char ?\\)
+ (char-to-string char)
+ (if (memq char eshell-special-chars-outside-quoting)
+ (string ?\\ char)))))
+
+(defun eshell-parse-backslash ()
+ "Parse a single backslash (\) character, which might mean escape.
+It only means escape if the character immediately following is a
+special character that is not itself a backslash."
+ (when (eq (char-after) ?\\)
+ (if (eshell-looking-at-backslash-return (point))
+ (throw 'eshell-incomplete ?\\)
+ (if (and (not (eq (char-after (1+ (point))) ?\\))
+ (if eshell-current-quoted
+ (memq (char-after (1+ (point)))
+ eshell-special-chars-inside-quoting)
+ (memq (char-after (1+ (point)))
+ eshell-special-chars-outside-quoting)))
+ (progn
+ (forward-char 2)
+ (list 'eshell-escape-arg
+ (char-to-string (char-before))))
+ ;; allow \\<RET> to mean a literal "\" character followed by a
+ ;; normal return, rather than a backslash followed by a line
+ ;; continuator (i.e., "\\ + \n" rather than "\ + \\n"). This
+ ;; is necessary because backslashes in Eshell are not special
+ ;; unless they either precede something special, or precede a
+ ;; backslash that precedes something special. (Mainly this is
+ ;; done to make using backslash on Windows systems more
+ ;; natural-feeling).
+ (if (eshell-looking-at-backslash-return (1+ (point)))
+ (forward-char))
+ (forward-char)
+ "\\"))))
+
+(defun eshell-parse-literal-quote ()
+ "Parse a literally quoted string. Nothing has special meaning!"
+ (if (eq (char-after) ?\')
+ (let ((end (eshell-find-delimiter ?\' ?\')))
+ (if (not end)
+ (throw 'eshell-incomplete ?\')
+ (let ((string (buffer-substring-no-properties (1+ (point)) end)))
+ (goto-char (1+ end))
+ (while (string-match "''" string)
+ (setq string (replace-match "'" t t string)))
+ (list 'eshell-escape-arg string))))))
+
+(defun eshell-parse-double-quote ()
+ "Parse a double quoted string, which allows for variable interpolation."
+ (when (eq (char-after) ?\")
+ (forward-char)
+ (let* ((end (eshell-find-delimiter ?\" ?\" nil nil t))
+ (eshell-current-quoted t))
+ (if (not end)
+ (throw 'eshell-incomplete ?\")
+ (prog1
+ (save-restriction
+ (narrow-to-region (point) end)
+ (list 'eshell-escape-arg
+ (eshell-parse-argument)))
+ (goto-char (1+ end)))))))
+
+(defun eshell-parse-special-reference ()
+ "Parse a special syntax reference, of the form '#<type arg>'."
+ (if (and (not eshell-current-argument)
+ (not eshell-current-quoted)
+ (looking-at "#<\\(buffer\\|process\\)\\s-"))
+ (let ((here (point)))
+ (goto-char (match-end 0))
+ (let* ((buffer-p (string= (match-string 1) "buffer"))
+ (end (eshell-find-delimiter ?\< ?\>)))
+ (if (not end)
+ (throw 'eshell-incomplete ?\<)
+ (if (eshell-arg-delimiter (1+ end))
+ (prog1
+ (list (if buffer-p 'get-buffer-create 'get-process)
+ (buffer-substring-no-properties (point) end))
+ (goto-char (1+ end)))
+ (ignore (goto-char here))))))))
+
+(defun eshell-parse-delimiter ()
+ "Parse an argument delimiter, which is essentially a command operator."
+ ;; this `eshell-operator' keyword gets parsed out by
+ ;; `eshell-separate-commands'. Right now the only possibility for
+ ;; error is an incorrect output redirection specifier.
+ (when (looking-at "[&|;\n]\\s-*")
+ (let ((end (match-end 0)))
+ (if eshell-current-argument
+ (eshell-finish-arg)
+ (eshell-finish-arg
+ (prog1
+ (list 'eshell-operator
+ (cond
+ ((eq (char-after end) ?\&)
+ (setq end (1+ end)) "&&")
+ ((eq (char-after end) ?\|)
+ (setq end (1+ end)) "||")
+ ((eq (char-after) ?\n) ";")
+ (t
+ (char-to-string (char-after)))))
+ (goto-char end)))))))
+
+;;; esh-arg.el ends here
--- /dev/null
+;;; esh-ext --- commands external to Eshell
+
+;; Copyright (C) 1999, 2000 Free Sofware Foundation
+
+;; 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 2, 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+(provide 'esh-ext)
+
+(eval-when-compile (require 'esh-maint))
+
+(defgroup eshell-ext nil
+ "External commands are invoked when operating system executables are
+loaded into memory, thus beginning a new process."
+ :tag "External commands"
+ :group 'eshell)
+
+;;; Commentary:
+
+;; To force a command to invoked external, either provide an explicit
+;; pathname for the command argument, or prefix the command name with
+;; an asterix character. Example:
+;;
+;; grep ; make invoke `grep' Lisp function, or `eshell/grep'
+;; /bin/grep ; will definitely invoke /bin/grep
+;; *grep ; will also invoke /bin/grep
+
+;;; User Variables:
+
+(defcustom eshell-ext-load-hook '(eshell-ext-initialize)
+ "*A hook that gets run when `eshell-ext' is loaded."
+ :type 'hook
+ :group 'eshell-ext)
+
+(defcustom eshell-binary-suffixes
+ (if (eshell-under-windows-p)
+ '(".exe" ".com" ".bat" ".cmd" "")
+ '(""))
+ "*A list of suffixes used when searching for executable files."
+ :type '(repeat string)
+ :group 'eshell-ext)
+
+(defcustom eshell-force-execution nil
+ "*If non-nil, try to execute binary files regardless of permissions.
+This can be useful on systems like Windows, where the operating system
+doesn't happen to honor the permission bits in certain cases; or in
+cases where you want to associate an interpreter with a particular
+kind of script file, but the language won't let you but a '#!'
+interpreter line in the file, and you don't want to make it executable
+since nothing else but Eshell will be able to understand
+`eshell-interpreter-alist'."
+ :type 'boolean
+ :group 'eshell-ext)
+
+(defun eshell-search-path (name)
+ "Search the environment path for NAME."
+ (if (file-name-absolute-p name)
+ name
+ (let ((list (parse-colon-path (getenv "PATH")))
+ suffixes n1 n2 file)
+ (while list
+ (setq n1 (concat (car list) name))
+ (setq suffixes eshell-binary-suffixes)
+ (while suffixes
+ (setq n2 (concat n1 (car suffixes)))
+ (if (and (or (file-executable-p n2)
+ (and eshell-force-execution
+ (file-readable-p n2)))
+ (not (file-directory-p n2)))
+ (setq file n2 suffixes nil list nil))
+ (setq suffixes (cdr suffixes)))
+ (setq list (cdr list)))
+ file)))
+
+(defcustom eshell-windows-shell-file
+ (if (eshell-under-windows-p)
+ (if (string-match "\\(\\`cmdproxy\\|sh\\)\\.\\(com\\|exe\\)"
+ shell-file-name)
+ (or (eshell-search-path "cmd.exe")
+ (eshell-search-path "command.exe"))
+ shell-file-name))
+ "*The name of the shell command to use for DOS/Windows batch files.
+This defaults to nil on non-Windows systems, where this variable is
+wholly ignored."
+ :type 'file
+ :group 'eshell-ext)
+
+(defsubst eshell-invoke-batch-file (&rest args)
+ "Invoke a .BAT or .CMD file on DOS/Windows systems."
+ ;; since CMD.EXE can't handle forward slashes in the initial
+ ;; argument...
+ (setcar args (subst-char-in-string directory-sep-char
+ ?\\ (car args)))
+ (throw 'eshell-replace-command
+ (eshell-parse-command eshell-windows-shell-file
+ (cons "/c" args))))
+
+(defcustom eshell-interpreter-alist
+ (if (eshell-under-windows-p)
+ '(("\\.\\(bat\\|cmd\\)\\'" . eshell-invoke-batch-file)))
+ "*An alist defining interpreter substitutions.
+Each member is a cons cell of the form:
+
+ (MATCH . INTERPRETER)
+
+MATCH should be a regexp, which is matched against the command name,
+or a function. If either returns a non-nil value, then INTERPRETER
+will be used for that command.
+
+If INTERPRETER is a string, it will be called as the command name,
+with the original command name passed as the first argument, with all
+subsequent arguments following. If INTERPRETER is a function, it will
+be called with all of those arguments. Note that interpreter
+functions should throw `eshell-replace-command' with the alternate
+command form, or they should return a value compatible with the
+possible return values of `eshell-external-command', which see."
+ :type '(repeat (cons (choice regexp (function :tag "Predicate"))
+ (choice string (function :tag "Interpreter"))))
+ :group 'eshell-ext)
+
+(defcustom eshell-alternate-command-hook nil
+ "*A hook run whenever external command lookup fails.
+If a functions wishes to provide an alternate command, they must throw
+it using the tag `eshell-replace-command'. This is done because the
+substituted command need not be external at all, and therefore must be
+passed up to a higher level for re-evaluation.
+
+Or, if the function returns a filename, that filename will be invoked
+with the current command arguments rather than the command specified
+by the user on the command line."
+ :type 'hook
+ :group 'eshell-ext)
+
+(defcustom eshell-command-interpreter-max-length 256
+ "*The maximum length of any command interpreter string, plus args."
+ :type 'integer
+ :group 'eshell-ext)
+
+;;; Functions:
+
+(defun eshell-ext-initialize ()
+ "Initialize the external command handling code."
+ (make-local-hook 'eshell-named-command-hook)
+ (add-hook 'eshell-named-command-hook 'eshell-explicit-command nil t))
+
+(defun eshell-explicit-command (command args)
+ "If a command name begins with `*', call it externally always.
+This bypasses all Lisp functions and aliases."
+ (when (and (> (length command) 1)
+ (eq (aref command 0) ?*))
+ (let ((cmd (eshell-search-path (substring command 1))))
+ (if cmd
+ (or (eshell-external-command cmd args)
+ (error "%s: external command failed" cmd))
+ (error "%s: external command not found"
+ (substring command 1))))))
+
+(defun eshell-remote-command (handler command args)
+ "Insert output from a remote COMMAND, using ARGS.
+A remote command is something that executes on a different machine.
+An external command simply means external to Emacs.
+
+Note that this function is very crude at the moment. It gathers up
+all the output from the remote command, and sends it all at once,
+causing the user to wonder if anything's really going on..."
+ (let ((outbuf (generate-new-buffer " *eshell remote output*"))
+ (errbuf (generate-new-buffer " *eshell remote error*"))
+ (exitcode 1))
+ (unwind-protect
+ (progn
+ (setq exitcode
+ (funcall handler 'shell-command
+ (mapconcat 'shell-quote-argument
+ (append (list command) args) " ")
+ outbuf errbuf))
+ (eshell-print (save-excursion (set-buffer outbuf)
+ (buffer-string)))
+ (eshell-error (save-excursion (set-buffer errbuf)
+ (buffer-string))))
+ (eshell-close-handles exitcode 'nil)
+ (kill-buffer outbuf)
+ (kill-buffer errbuf))))
+
+(defun eshell-external-command (command args)
+ "Insert output from an external COMMAND, using ARGS."
+ (setq args (eshell-stringify-list (eshell-flatten-list args)))
+ (let ((handler
+ (unless (or (equal default-directory "/")
+ (and (eshell-under-windows-p)
+ (string-match "\\`[A-Za-z]:[/\\\\]\\'"
+ default-directory)))
+ (find-file-name-handler default-directory
+ 'shell-command))))
+ (if handler
+ (eshell-remote-command handler command args))
+ (let ((interp (eshell-find-interpreter command)))
+ (assert interp)
+ (if (functionp (car interp))
+ (apply (car interp) (append (cdr interp) args))
+ (eshell-gather-process-output
+ (car interp) (append (cdr interp) args))))))
+
+(defun eshell/addpath (&rest args)
+ "Add a set of paths to PATH."
+ (eshell-eval-using-options
+ "addpath" args
+ '((?b "begin" nil prepend "add path element at beginning")
+ (?h "help" nil nil "display this usage message")
+ :usage "[-b] PATH
+Adds the given PATH to $PATH.")
+ (if args
+ (progn
+ (if prepend
+ (setq args (nreverse args)))
+ (while args
+ (setenv "PATH"
+ (if prepend
+ (concat (car args) path-separator
+ (getenv "PATH"))
+ (concat (getenv "PATH") path-separator
+ (car args))))
+ (setq args (cdr args))))
+ (let ((paths (parse-colon-path (getenv "PATH"))))
+ (while paths
+ (eshell-printn (car paths))
+ (setq paths (cdr paths)))))))
+
+(defun eshell-script-interpreter (file)
+ "Extract the script to run from FILE, if it has #!<interp> in it.
+Return nil, or a list of the form:
+
+ (INTERPRETER [ARGS] FILE)"
+ (let ((maxlen eshell-command-interpreter-max-length))
+ (if (and (file-readable-p file)
+ (file-regular-p file))
+ (with-temp-buffer
+ (insert-file-contents-literally file nil 0 maxlen)
+ (if (looking-at "#!\\([^ \t\n]+\\)\\([ \t]+\\(.+\\)\\)?")
+ (if (match-string 3)
+ (list (match-string 1)
+ (match-string 3)
+ file)
+ (list (match-string 1)
+ file)))))))
+
+(defun eshell-find-interpreter (file &optional no-examine-p)
+ "Find the command interpreter with which to execute FILE.
+If NO-EXAMINE-P is non-nil, FILE will not be inspected for a script
+line of the form #!<interp>."
+ (let ((finterp
+ (catch 'found
+ (ignore
+ (eshell-for possible eshell-interpreter-alist
+ (cond
+ ((functionp (car possible))
+ (and (funcall (car possible) file)
+ (throw 'found (cdr possible))))
+ ((stringp (car possible))
+ (and (string-match (car possible) file)
+ (throw 'found (cdr possible))))
+ (t
+ (error "Invalid interpreter-alist test"))))))))
+ (if finterp ; first check
+ (list finterp file)
+ (let ((fullname (if (file-name-directory file) file
+ (eshell-search-path file)))
+ (suffixes eshell-binary-suffixes))
+ (if (and fullname (not (or eshell-force-execution
+ (file-executable-p fullname))))
+ (while suffixes
+ (let ((try (concat fullname (car suffixes))))
+ (if (or (file-executable-p try)
+ (and eshell-force-execution
+ (file-readable-p try)))
+ (setq fullname try suffixes nil)
+ (setq suffixes (cdr suffixes))))))
+ (cond ((not (and fullname (file-exists-p fullname)))
+ (let ((name (or fullname file)))
+ (unless (setq fullname
+ (run-hook-with-args-until-success
+ 'eshell-alternate-command-hook file))
+ (error "%s: command not found" name))))
+ ((not (or eshell-force-execution
+ (file-executable-p fullname)))
+ (error "%s: Permission denied" fullname)))
+ (let (interp)
+ (unless no-examine-p
+ (setq interp (eshell-script-interpreter fullname))
+ (if interp
+ (setq interp
+ (cons (car (eshell-find-interpreter (car interp) t))
+ (cdr interp)))))
+ (or interp (list fullname)))))))
+
+;;; Code:
+
+;;; esh-ext.el ends here
--- /dev/null
+;;; do not modify this file; it is auto-generated
+
+(defgroup eshell-alias nil
+ "Command aliases allow for easy definition of alternate commands."
+ :tag "Command aliases"
+ :link '(info-link "(eshell.info)Command aliases")
+ :group 'eshell-module)
+
+(defgroup eshell-banner nil
+ "This sample module displays a welcome banner at login.
+It exists so that others wishing to create their own Eshell extension
+modules may have a simple template to begin with."
+ :tag "Login banner"
+ :link '(info-link "(eshell.info)Login banner")
+ :group 'eshell-module)
+
+(defgroup eshell-basic nil
+ "The \"basic\" code provides a set of convenience functions which
+are traditionally considered shell builtins. Since all of the
+functionality provided by them is accessible through Lisp, they are
+not really builtins at all, but offer a command-oriented way to do the
+same thing."
+ :tag "Basic shell commands"
+ :group 'eshell-module)
+
+(defgroup eshell-cmpl nil
+ "This module provides a programmable completion function bound to
+the TAB key, which allows for completing command names, file names,
+variable names, arguments, etc."
+ :tag "Argument completion"
+ :group 'eshell-module)
+
+(defgroup eshell-dirs nil
+ "Directory navigation involves changing directories, examining the
+current directory, maintaining a directory stack, and also keeping
+track of a history of the last directory locations the user was in.
+Emacs does provide standard Lisp definitions of `pwd' and `cd', but
+they lack somewhat in feel from the typical shell equivalents."
+ :tag "Directory navigation"
+ :group 'eshell-module)
+
+(defgroup eshell-glob nil
+ "This module provides extended globbing syntax, similar what is used
+by zsh for filename generation."
+ :tag "Extended filename globbing"
+ :group 'eshell-module)
+
+(defgroup eshell-hist nil
+ "This module provides command history management."
+ :tag "History list management"
+ :group 'eshell-module)
+
+(defgroup eshell-ls nil
+ "This module implements the \"ls\" utility fully in Lisp. If it is
+passed any unrecognized command switches, it will revert to the
+operating system's version. This version of \"ls\" uses text
+properties to colorize its output based on the setting of
+`eshell-ls-use-colors'."
+ :tag "Implementation of `ls' in Lisp"
+ :group 'eshell-module)
+
+(defgroup eshell-pred nil
+ "This module allows for predicates to be applied to globbing
+patterns (similar to zsh), in addition to string modifiers which can
+be applied either to globbing results, variable references, or just
+ordinary strings."
+ :tag "Value modifiers and predicates"
+ :group 'eshell-module)
+
+(defgroup eshell-prompt nil
+ "This module provides command prompts, and navigation between them,
+as is common with most shells."
+ :tag "Command prompts"
+ :group 'eshell-module)
+
+(defgroup eshell-rebind nil
+ "This module allows for special keybindings that only take effect
+while the point is in a region of input text. By default, it binds
+C-a to move to the beginning of the input text (rather than just the
+beginning of the line), and C-p and C-n to move through the input
+history, C-u kills the current input text, etc. It also, if
+`eshell-confine-point-to-input' is non-nil, does not allow certain
+commands to cause the point to leave the input area, such as
+`backward-word', `previous-line', etc. This module intends to mimic
+the behavior of normal shells while the user editing new input text."
+ :tag "Rebind keys at input"
+ :group 'eshell-module)
+
+(defgroup eshell-script nil
+ "This module allows for the execution of files containing Eshell
+commands, as a script file."
+ :tag "Running script files."
+ :group 'eshell-module)
+
+(defgroup eshell-smart nil
+ "This module combines the facility of normal, modern shells with
+some of the edit/review concepts inherent in the design of Plan 9's
+9term. See the docs for more details.
+
+Most likely you will have to turn this option on and play around with
+it to get a real sense of how it works."
+ :tag "Smart display of output"
+ :link '(info-link "(eshell.info)Smart display of output")
+ :group 'eshell-module)
+
+(defgroup eshell-term nil
+ "This module causes visual commands (e.g., 'vi') to be executed by
+the `term' package, which comes with Emacs. This package handles most
+of the ANSI control codes, allowing curses-based applications to run
+within an Emacs window. The variable `eshell-visual-commands' defines
+which commands are considered visual in nature."
+ :tag "Running visual commands"
+ :group 'eshell-module)
+
+(defgroup eshell-unix nil
+ "This module defines many of the more common UNIX utilities as
+aliases implemented in Lisp. These include mv, ln, cp, rm, etc. If
+the user passes arguments which are too complex, or are unrecognized
+by the Lisp variant, the external version will be called (if
+available). The only reason not to use them would be because they are
+usually much slower. But in several cases their tight integration
+with Eshell makes them more versatile than their traditional cousins
+\(such as being able to use `kill' to kill Eshell background processes
+by name)."
+ :tag "UNIX commands in Lisp"
+ :group 'eshell-module)
+
+(defgroup eshell-xtra nil
+ "This module defines some extra alias functions which are entirely
+optional. They can be viewed as samples for how to write Eshell alias
+functions, or as aliases which make some of Emacs' behavior more
+naturally accessible within Emacs."
+ :tag "Extra alias functions"
+ :group 'eshell-module)
+
--- /dev/null
+;;; esh-io --- I/O management
+
+;; Copyright (C) 1999, 2000 Free Sofware Foundation
+
+;; 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 2, 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+(provide 'esh-io)
+
+(eval-when-compile (require 'esh-maint))
+
+(defgroup eshell-io nil
+ "Eshell's I/O management code provides a scheme for treating many
+different kinds of objects -- symbols, files, buffers, etc. -- as
+though they were files."
+ :tag "I/O management"
+ :group 'eshell)
+
+;;; Commentary:
+
+;; At the moment, only output redirection is supported in Eshell. To
+;; use input redirection, the following syntax will work, assuming
+;; that the command after the pipe is always an external command:
+;;
+;; cat <file> | <command>
+;;
+;; Otherwise, output redirection and piping are provided in a manner
+;; consistent with most shells. Therefore, only unique features are
+;; mentioned here.
+;;
+;;;_* Insertion
+;;
+;; To insert at the location of point in a buffer, use '>>>':
+;;
+;; echo alpha >>> #<buffer *scratch*>;
+;;
+;;;_* Pseudo-devices
+;;
+;; A few pseudo-devices are provided, since Emacs cannot write
+;; directly to a UNIX device file:
+;;
+;; echo alpha > /dev/null ; the bit bucket
+;; echo alpha > /dev/kill ; set the kill ring
+;; echo alpha >> /dev/clip ; append to the clipboard
+;;
+;;;_* Multiple output targets
+;;
+;; Eshell can write to multiple output targets, including pipes.
+;; Example:
+;;
+;; (+ 1 2) > a > b > c ; prints number to all three files
+;; (+ 1 2) > a | wc ; prints to 'a', and pipes to 'wc'
+
+;;; User Variables:
+
+(defcustom eshell-io-load-hook '(eshell-io-initialize)
+ "*A hook that gets run when `eshell-io' is loaded."
+ :type 'hook
+ :group 'eshell-io)
+
+(defcustom eshell-number-of-handles 3
+ "*The number of file handles that eshell supports.
+Currently this is standard input, output and error. But even all of
+these Emacs does not currently support with asynchronous processes
+\(which is what eshell uses so that you can continue doing work in
+other buffers) ."
+ :type 'integer
+ :group 'eshell-io)
+
+(defcustom eshell-output-handle 1
+ "*The index of the standard output handle."
+ :type 'integer
+ :group 'eshell-io)
+
+(defcustom eshell-error-handle 2
+ "*The index of the standard error handle."
+ :type 'integer
+ :group 'eshell-io)
+
+(defcustom eshell-buffer-shorthand nil
+ "*If non-nil, a symbol name can be used for a buffer in redirection.
+If nil, redirecting to a buffer requires buffer name syntax. If this
+variable is set, redirection directly to Lisp symbols will be
+impossible.
+
+Example:
+
+ echo hello > '*scratch* ; works if `eshell-buffer-shorthand' is t
+ echo hello > #<buffer *scratch*> ; always works"
+ :type 'boolean
+ :group 'eshell-io)
+
+(defcustom eshell-print-queue-size 5
+ "*The size of the print queue, for doing buffered printing.
+This is basically a speed enhancement, to avoid blocking the Lisp code
+from executing while Emacs is redisplaying."
+ :type 'integer
+ :group 'eshell-io)
+
+(defcustom eshell-virtual-targets
+ '(("/dev/eshell" eshell-interactive-print nil)
+ ("/dev/kill" (lambda (mode)
+ (if (eq mode 'overwrite)
+ (kill-new ""))
+ 'eshell-kill-append) t)
+ ("/dev/clip" (lambda (mode)
+ (if (eq mode 'overwrite)
+ (let ((x-select-enable-clipboard t))
+ (kill-new "")))
+ 'eshell-clipboard-append) t))
+ "*Map virtual devices name to Emacs Lisp functions.
+If the user specifies any of the filenames above as a redirection
+target, the function in the second element will be called.
+
+If the third element is non-nil, the redirection mode is passed as an
+argument (which is the symbol `overwrite', `append' or `insert'), and
+the function is expected to return another function -- which is the
+output function. Otherwise, the second element itself is the output
+function.
+
+The output function is then called repeatedly with a single strings,
+with represents success pieces of the output of the command, until nil
+is passed, meaning EOF.
+
+NOTE: /dev/null is handled specially as a virtual target, and should
+not be added to this variable."
+ :type '(repeat
+ (list (string :tag "Target")
+ function
+ (choice (const :tag "Func returns output-func" t)
+ (const :tag "Func is output-func" nil))))
+ :group 'eshell-io)
+
+(put 'eshell-virtual-targets 'risky-local-variable t)
+
+;;; Internal Variables:
+
+(defvar eshell-current-handles nil)
+
+(defvar eshell-last-command-status 0
+ "The exit code from the last command. 0 if successful.")
+
+(defvar eshell-last-command-result nil
+ "The result of the last command. Not related to success.")
+
+(defvar eshell-output-file-buffer nil
+ "If non-nil, the current buffer is a file output buffer.")
+
+(defvar eshell-print-count)
+(defvar eshell-current-redirections)
+
+;;; Functions:
+
+(defun eshell-io-initialize ()
+ "Initialize the I/O subsystem code."
+ (make-local-hook 'eshell-parse-argument-hook)
+ (add-hook 'eshell-parse-argument-hook
+ 'eshell-parse-redirection nil t)
+ (make-local-variable 'eshell-current-redirections)
+ (make-local-hook 'eshell-pre-rewrite-command-hook)
+ (add-hook 'eshell-pre-rewrite-command-hook
+ 'eshell-strip-redirections nil t)
+ (make-local-hook 'eshell-post-rewrite-command-hook)
+ (add-hook 'eshell-post-rewrite-command-hook
+ 'eshell-apply-redirections nil t))
+
+(defun eshell-parse-redirection ()
+ "Parse an output redirection, such as '2>'."
+ (if (and (not eshell-current-quoted)
+ (looking-at "\\([0-9]\\)?\\(<\\|>+\\)&?\\([0-9]\\)?\\s-*"))
+ (if eshell-current-argument
+ (eshell-finish-arg)
+ (let ((sh (match-string 1))
+ (oper (match-string 2))
+; (th (match-string 3))
+ )
+ (if (string= oper "<")
+ (error "Eshell does not support input redirection"))
+ (eshell-finish-arg
+ (prog1
+ (list 'eshell-set-output-handle
+ (or (and sh (string-to-int sh)) 1)
+ (list 'quote
+ (aref [overwrite append insert]
+ (1- (length oper)))))
+ (goto-char (match-end 0))))))))
+
+(defun eshell-strip-redirections (terms)
+ "Rewrite any output redirections in TERMS."
+ (setq eshell-current-redirections (list t))
+ (let ((tl terms)
+ (tt (cdr terms)))
+ (while tt
+ (if (not (and (consp (car tt))
+ (eq (caar tt) 'eshell-set-output-handle)))
+ (setq tt (cdr tt)
+ tl (cdr tl))
+ (unless (cdr tt)
+ (error "Missing redirection target"))
+ (nconc eshell-current-redirections
+ (list (list 'ignore
+ (append (car tt) (list (cadr tt))))))
+ (setcdr tl (cddr tt))
+ (setq tt (cddr tt))))
+ (setq eshell-current-redirections
+ (cdr eshell-current-redirections))))
+
+(defun eshell-apply-redirections (cmdsym)
+ "Apply any redirection which were specified for COMMAND."
+ (if eshell-current-redirections
+ (set cmdsym
+ (append (list 'progn)
+ eshell-current-redirections
+ (list (symbol-value cmdsym))))))
+
+(defun eshell-create-handles
+ (standard-output output-mode &optional standard-error error-mode)
+ "Create a new set of file handles for a command.
+The default location for standard output and standard error will go to
+STANDARD-OUTPUT and STANDARD-ERROR, respectively."
+ (let ((handles (make-vector eshell-number-of-handles nil))
+ (output-target (eshell-get-target standard-output output-mode))
+ (error-target (eshell-get-target standard-error error-mode)))
+ (aset handles eshell-output-handle (cons output-target 1))
+ (if standard-error
+ (aset handles eshell-error-handle (cons error-target 1))
+ (aset handles eshell-error-handle (cons output-target 1)))
+ handles))
+
+(defun eshell-protect-handles (handles)
+ "Protect the handles in HANDLES from a being closed."
+ (let ((idx 0))
+ (while (< idx eshell-number-of-handles)
+ (if (aref handles idx)
+ (setcdr (aref handles idx)
+ (1+ (cdr (aref handles idx)))))
+ (setq idx (1+ idx))))
+ handles)
+
+(defun eshell-close-target (target status)
+ "Close an output TARGET, passing STATUS as the result.
+STATUS should be non-nil on successful termination of the output."
+ (cond
+ ((symbolp target) nil)
+
+ ;; If we were redirecting to a file, save the file and close the
+ ;; buffer.
+ ((markerp target)
+ (let ((buf (marker-buffer target)))
+ (when buf ; somebody's already killed it!
+ (save-current-buffer
+ (set-buffer buf)
+ (when eshell-output-file-buffer
+ (save-buffer)
+ (when (eq eshell-output-file-buffer t)
+ (or status (set-buffer-modified-p nil))
+ (kill-buffer buf)))))))
+
+ ;; If we're redirecting to a process (via a pipe, or process
+ ;; redirection), send it EOF so that it knows we're finished.
+ ((processp target)
+ (if (eq (process-status target) 'run)
+ (process-send-eof target)))
+
+ ;; A plain function redirection needs no additional arguments
+ ;; passed.
+ ((functionp target)
+ (funcall target status))
+
+ ;; But a more complicated function redirection (which can only
+ ;; happen with aliases at the moment) has arguments that need to be
+ ;; passed along with it.
+ ((consp target)
+ (apply (car target) status (cdr target)))))
+
+(defun eshell-close-handles (exit-code &optional result handles)
+ "Close all of the current handles, taking refcounts into account.
+EXIT-CODE is the process exit code; mainly, it is zero, if the command
+completed successfully. RESULT is the quoted value of the last
+command. If nil, then the meta variables for keeping track of the
+last execution result should not be changed."
+ (let ((idx 0))
+ (assert (or (not result) (eq (car result) 'quote)))
+ (setq eshell-last-command-status exit-code
+ eshell-last-command-result (cadr result))
+ (while (< idx eshell-number-of-handles)
+ (let ((handles (or handles eshell-current-handles)))
+ (when (aref handles idx)
+ (setcdr (aref handles idx)
+ (1- (cdr (aref handles idx))))
+ (when (= (cdr (aref handles idx)) 0)
+ (let ((target (car (aref handles idx))))
+ (if (not (listp target))
+ (eshell-close-target target (= exit-code 0))
+ (while target
+ (eshell-close-target (car target) (= exit-code 0))
+ (setq target (cdr target)))))
+ (setcar (aref handles idx) nil))))
+ (setq idx (1+ idx)))
+ nil))
+
+(defun eshell-kill-append (string)
+ "Call `kill-append' with STRING, if it is indeed a string."
+ (if (stringp string)
+ (kill-append string nil)))
+
+(defun eshell-clipboard-append (string)
+ "Call `kill-append' with STRING, if it is indeed a string."
+ (if (stringp string)
+ (let ((x-select-enable-clipboard t))
+ (kill-append string nil))))
+
+(defun eshell-get-target (target &optional mode)
+ "Convert TARGET, which is a raw argument, into a valid output target.
+MODE is either `overwrite', `append' or `insert'."
+ (setq mode (or mode 'insert))
+ (cond
+ ((stringp target)
+ (let ((redir (assoc target eshell-virtual-targets)))
+ (if redir
+ (if (nth 2 redir)
+ (funcall (nth 1 redir) mode)
+ (nth 1 redir))
+ (let* ((exists (get-file-buffer target))
+ (buf (find-file-noselect target t)))
+ (with-current-buffer buf
+ (if buffer-read-only
+ (error "Cannot write to read-only file `%s'" target))
+ (set (make-local-variable 'eshell-output-file-buffer)
+ (if (eq exists buf) 0 t))
+ (cond ((eq mode 'overwrite)
+ (erase-buffer))
+ ((eq mode 'append)
+ (goto-char (point-max))))
+ (point-marker))))))
+ ((or (bufferp target)
+ (and (boundp 'eshell-buffer-shorthand)
+ (symbol-value 'eshell-buffer-shorthand)
+ (symbolp target)))
+ (let ((buf (if (bufferp target)
+ target
+ (get-buffer-create
+ (symbol-name target)))))
+ (with-current-buffer buf
+ (cond ((eq mode 'overwrite)
+ (erase-buffer))
+ ((eq mode 'append)
+ (goto-char (point-max))))
+ (point-marker))))
+ ((functionp target)
+ nil)
+ ((symbolp target)
+ (if (eq mode 'overwrite)
+ (set target nil))
+ target)
+ ((or (processp target)
+ (markerp target))
+ target)
+ (t
+ (error "Illegal redirection target: %s"
+ (eshell-stringify target)))))
+
+(eval-when-compile
+ (defvar grep-null-device))
+
+(defun eshell-set-output-handle (index mode &optional target)
+ "Set handle INDEX, using MODE, to point to TARGET."
+ (when target
+ (if (and (stringp target)
+ (or (cond
+ ((boundp 'null-device)
+ (string= target null-device))
+ ((boundp 'grep-null-device)
+ (string= target grep-null-device))
+ (t nil))
+ (string= target "/dev/null")))
+ (aset eshell-current-handles index nil)
+ (let ((where (eshell-get-target target mode))
+ (current (car (aref eshell-current-handles index))))
+ (if (and (listp current)
+ (not (member where current)))
+ (setq current (append current (list where)))
+ (setq current (list where)))
+ (if (not (aref eshell-current-handles index))
+ (aset eshell-current-handles index (cons nil 1)))
+ (setcar (aref eshell-current-handles index) current)))))
+
+(defun eshell-interactive-output-p ()
+ "Return non-nil if current handles are bound for interactive display."
+ (and (eq (car (aref eshell-current-handles
+ eshell-output-handle)) t)
+ (eq (car (aref eshell-current-handles
+ eshell-error-handle)) t)))
+
+(defvar eshell-print-queue nil)
+(defvar eshell-print-queue-count -1)
+
+(defun eshell-flush (&optional reset-p)
+ "Flush out any lines that have been queued for printing.
+Must be called before printing begins with -1 as its argument, and
+after all printing is over with no argument."
+ (ignore
+ (if reset-p
+ (setq eshell-print-queue nil
+ eshell-print-queue-count reset-p)
+ (if eshell-print-queue
+ (eshell-print eshell-print-queue))
+ (eshell-flush 0))))
+
+(defun eshell-init-print-buffer ()
+ "Initialize the buffered printing queue."
+ (eshell-flush -1))
+
+(defun eshell-buffered-print (&rest strings)
+ "A buffered print -- *for strings only*."
+ (if (< eshell-print-queue-count 0)
+ (progn
+ (eshell-print (apply 'concat strings))
+ (setq eshell-print-queue-count 0))
+ (if (= eshell-print-queue-count eshell-print-queue-size)
+ (eshell-flush))
+ (setq eshell-print-queue
+ (concat eshell-print-queue (apply 'concat strings))
+ eshell-print-queue-count (1+ eshell-print-queue-count))))
+
+(defsubst eshell-print (object)
+ "Output OBJECT to the error handle."
+ (eshell-output-object object eshell-output-handle))
+
+(defsubst eshell-error (object)
+ "Output OBJECT to the error handle."
+ (eshell-output-object object eshell-error-handle))
+
+(defsubst eshell-errorn (object)
+ "Output OBJECT to the error handle."
+ (eshell-error object)
+ (eshell-error "\n"))
+
+(defsubst eshell-printn (object)
+ "Output OBJECT to the error handle."
+ (eshell-print object)
+ (eshell-print "\n"))
+
+(defun eshell-output-object-to-target (object target)
+ "Insert OBJECT into TARGET.
+Returns what was actually sent, or nil if nothing was sent."
+ (cond
+ ((functionp target)
+ (funcall target object))
+
+ ((symbolp target)
+ (if (eq target t) ; means "print to display"
+ (eshell-output-filter nil (eshell-stringify object))
+ (if (not (symbol-value target))
+ (set target object)
+ (setq object (eshell-stringify object))
+ (if (not (stringp (symbol-value target)))
+ (set target (eshell-stringify
+ (symbol-value target))))
+ (set target (concat (symbol-value target) object)))))
+
+ ((markerp target)
+ (if (buffer-live-p (marker-buffer target))
+ (with-current-buffer (marker-buffer target)
+ (let ((moving (= (point) target)))
+ (save-excursion
+ (goto-char target)
+ (setq object (eshell-stringify object))
+ (insert-and-inherit object)
+ (set-marker target (point-marker)))
+ (if moving
+ (goto-char target))))))
+
+ ((processp target)
+ (when (eq (process-status target) 'run)
+ (setq object (eshell-stringify object))
+ (process-send-string target object)))
+
+ ((consp target)
+ (apply (car target) object (cdr target))))
+ object)
+
+(defun eshell-output-object (object &optional handle-index handles)
+ "Insert OBJECT, using HANDLE-INDEX specifically)."
+ (let ((target (car (aref (or handles eshell-current-handles)
+ (or handle-index eshell-output-handle)))))
+ (if (and target (not (listp target)))
+ (eshell-output-object-to-target object target)
+ (while target
+ (eshell-output-object-to-target object (car target))
+ (setq target (cdr target))))))
+
+;;; Code:
+
+;;; esh-io.el ends here
--- /dev/null
+;;; esh-maint --- init code for building eshell
+
+;; Copyright (C) 1999, 2000 Free Sofware Foundation
+
+;; 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 2, 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+;;; Commentary:
+
+;;; Code:
+
+(provide 'esh-maint)
+
+(and (fboundp 'font-lock-add-keywords)
+ (font-lock-add-keywords
+ 'emacs-lisp-mode
+ '(("(eshell-for\\>" . font-lock-keyword-face)
+ ("(eshell-deftest\\>" . font-lock-keyword-face)
+ ("(eshell-condition-case\\>" . font-lock-keyword-face))))
+
+(if (file-directory-p "../pcomplete")
+ (add-to-list 'load-path "../pcomplete"))
+
+(if (locate-library "pcomplete")
+ (require 'pcomplete))
+
+(eval-when-compile
+ (require 'cl)
+ (setq cl-optimize-speed 9))
+
+;; (defun eshell-generate-autoloads ()
+;; (interactive)
+;; (require 'autoload)
+;; (setq generated-autoload-file
+;; (expand-file-name (car command-line-args-left)))
+;; (setq command-line-args-left (cdr command-line-args-left))
+;; (batch-update-autoloads))
+
+(require 'eshell)
+(require 'esh-mode) ; brings in eshell-util
+(require 'esh-opt)
+(require 'esh-test)
+
+;; (defun eshell-generate-main-menu ()
+;; "Create the main menu for the eshell documentation."
+;; (insert "@menu
+;; * The Emacs shell:: eshell.
+
+;; Core Functionality\n")
+;; (eshell-for module
+;; (sort (eshell-subgroups 'eshell)
+;; (function
+;; (lambda (a b)
+;; (string-lessp (symbol-name a)
+;; (symbol-name b)))))
+;; (insert (format "* %-34s"
+;; (concat (get module 'custom-tag) "::"))
+;; (symbol-name module) ".\n"))
+;; (insert "\nOptional Functionality\n")
+;; (eshell-for module
+;; (sort (eshell-subgroups 'eshell-module)
+;; (function
+;; (lambda (a b)
+;; (string-lessp (symbol-name a)
+;; (symbol-name b)))))
+;; (insert (format "* %-34s"
+;; (concat (get module 'custom-tag) "::"))
+;; (symbol-name module) ".\n"))
+;; (insert "@end menu\n"))
+
+;; (defun eshell-make-texi ()
+;; "Make the eshell.texi file."
+;; (interactive)
+;; (require 'eshell-auto)
+;; (require 'texidoc)
+;; (require 'pcomplete)
+;; (apply 'texidoc-files 'eshell-generate-main-menu "eshell.doci"
+;; (append
+;; (list "eshell.el")
+;; (sort (mapcar
+;; (function
+;; (lambda (sym)
+;; (let ((name (symbol-name sym)))
+;; (if (string-match "\\`eshell-\\(.*\\)" name)
+;; (setq name (concat "esh-" (match-string 1 name))))
+;; (concat name ".el"))))
+;; (eshell-subgroups 'eshell))
+;; 'string-lessp)
+;; (sort (mapcar
+;; (function
+;; (lambda (sym)
+;; (let ((name (symbol-name sym)))
+;; (if (string-match "\\`eshell-\\(.*\\)" name)
+;; (setq name (concat "em-" (match-string 1 name))))
+;; (concat name ".el"))))
+;; (eshell-subgroups 'eshell-module))
+;; 'string-lessp)
+;; (list "eshell.texi"))))
+
+;; (defun eshell-make-readme ()
+;; "Make the README file from eshell.el."
+;; (interactive)
+;; (require 'eshell-auto)
+;; (require 'texidoc)
+;; (require 'pcomplete)
+;; (texidoc-files nil "eshell.doci" "eshell.el" "README.texi")
+;; (set-buffer (get-buffer "README.texi"))
+;; (goto-char (point-min))
+;; (search-forward "@chapter")
+;; (beginning-of-line)
+;; (forward-line -1)
+;; (kill-line 2)
+;; (re-search-forward "^@section User Options")
+;; (beginning-of-line)
+;; (delete-region (point) (point-max))
+;; (insert "@bye\n")
+;; (save-buffer)
+;; (with-temp-buffer
+;; (call-process "makeinfo" nil t nil "--no-headers" "README.texi")
+;; (goto-char (point-min))
+;; (search-forward "The Emacs Shell")
+;; (beginning-of-line)
+;; (delete-region (point-min) (point))
+;; (write-file "README"))
+;; (delete-file "README.texi")
+;; (kill-buffer "README.texi"))
+
+;;; esh-maint.el ends here
--- /dev/null
+;;; esh-module --- Eshell modules
+
+;; Copyright (C) 1999, 2000 Free Sofware Foundation
+
+;; 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 2, 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+(provide 'esh-module)
+
+(eval-when-compile (require 'esh-maint))
+
+(defgroup eshell-module nil
+ "The `eshell-module' group is for Eshell extension modules, which
+provide optional behavior which the user can enable or disable by
+customizing the variable `eshell-modules-list'."
+ :tag "Extension modules"
+ :group 'eshell)
+
+;;; Commentary:
+
+(require 'esh-util)
+
+(defun eshell-load-defgroups (&optional directory)
+ "Load `defgroup' statements from Eshell's module files."
+ (with-current-buffer
+ (find-file-noselect (expand-file-name "esh-groups.el" directory))
+ (erase-buffer)
+ (insert ";;; do not modify this file; it is auto-generated\n\n")
+ (let ((files (directory-files (or directory
+ (car command-line-args-left))
+ nil "\\`em-.*\\.el\\'")))
+ (while files
+ (message "Loading defgroup from `%s'" (car files))
+ (let (defgroup)
+ (catch 'handled
+ (with-current-buffer (find-file-noselect (car files))
+ (goto-char (point-min))
+ (while t
+ (forward-sexp)
+ (if (eobp) (throw 'handled t))
+ (backward-sexp)
+ (let ((begin (point))
+ (defg (looking-at "(defgroup")))
+ (forward-sexp)
+ (if defg
+ (setq defgroup (buffer-substring begin (point))))))))
+ (if defgroup
+ (insert defgroup "\n\n")))
+ (setq files (cdr files))))
+ (save-buffer)))
+
+;; load the defgroup's for the standard extension modules, so that
+;; documentation can be provided when the user customize's
+;; `eshell-modules-list'.
+(eval-when-compile
+ (when (equal (file-name-nondirectory byte-compile-current-file)
+ "esh-module.el")
+ (let* ((directory (file-name-directory byte-compile-current-file))
+ (elc-file (expand-file-name "esh-groups.elc" directory)))
+ (eshell-load-defgroups directory)
+ (if (file-exists-p elc-file) (delete-file elc-file)))))
+
+(load "esh-groups" t t)
+
+;;; User Variables:
+
+(defcustom eshell-module-unload-hook
+ '(eshell-unload-extension-modules)
+ "*A hook run when `eshell-module' is unloaded."
+ :type 'hook
+ :group 'eshell-module)
+
+(defcustom eshell-modules-list
+ '(eshell-alias
+ eshell-banner
+ eshell-basic
+ eshell-cmpl
+ eshell-dirs
+ eshell-glob
+ eshell-hist
+ eshell-ls
+ eshell-pred
+ eshell-prompt
+ eshell-script
+ eshell-term
+ eshell-unix)
+ "*A list of optional add-on modules to be loaded by Eshell.
+Changes will only take effect in future Eshell buffers."
+ :type (append
+ (list 'set ':tag "Supported modules")
+ (mapcar
+ (function
+ (lambda (modname)
+ (let ((modsym (intern modname)))
+ (list 'const
+ ':tag (format "%s -- %s" modname
+ (get modsym 'custom-tag))
+ ':link (caar (get modsym 'custom-links))
+ ':doc (concat "\n" (get modsym 'group-documentation)
+ "\n ")
+ modsym))))
+ (sort (mapcar 'symbol-name
+ (eshell-subgroups 'eshell-module))
+ 'string-lessp))
+ '((repeat :inline t :tag "Other modules" symbol)))
+ :group 'eshell-module)
+
+;;; Code:
+
+(defsubst eshell-using-module (module)
+ "Return non-nil if a certain Eshell MODULE is in use.
+The MODULE should be a symbol corresponding to that module's
+customization group. Example: `eshell-cmpl' for that module."
+ (memq module eshell-modules-list))
+
+(defun eshell-unload-extension-modules ()
+ "Unload any memory resident extension modules."
+ (eshell-for module (eshell-subgroups 'eshell-module)
+ (if (featurep module)
+ (ignore-errors
+ (message "Unloading %s..." (symbol-name module))
+ (unload-feature module)
+ (message "Unloading %s...done" (symbol-name module))))))
+
+;;; esh-module.el ends here
--- /dev/null
+;;; esh-opt --- command options processing
+
+;; Copyright (C) 1999, 2000 Free Sofware Foundation
+
+;; 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 2, 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+(provide 'esh-opt)
+
+(eval-when-compile (require 'esh-maint))
+
+(defgroup eshell-opt nil
+ "The options processing code handles command argument parsing for
+Eshell commands implemented in Lisp."
+ :tag "Command options processing"
+ :group 'eshell)
+
+;;; Commentary:
+
+;;; User Functions:
+
+(defmacro eshell-eval-using-options (name macro-args
+ options &rest body-forms)
+ "Process NAME's MACRO-ARGS using a set of command line OPTIONS.
+After doing so, settings will be stored in local symbols as declared
+by OPTIONS; FORMS will then be evaluated -- assuming all was OK.
+
+The syntax of OPTIONS is:
+
+ '((?C nil nil multi-column \"multi-column display\")
+ (nil \"help\" nil nil \"show this usage display\")
+ (?r \"reverse\" nil reverse-list \"reverse order while sorting\")
+ :external \"ls\"
+ :usage \"[OPTION]... [FILE]...
+ List information about the FILEs (the current directory by default).
+ Sort entries alphabetically across.\")
+
+`eshell-eval-using-options' returns the value of the last form in
+BODY-FORMS. If instead an external command is run, the tag
+`eshell-external' will be thrown with the new process for its value.
+
+Lastly, any remaining arguments will be available in a locally
+interned variable `args' (created using a `let' form)."
+ `(let ((temp-args
+ ,(if (memq ':preserve-args (cadr options))
+ macro-args
+ (list 'eshell-stringify-list
+ (list 'eshell-flatten-list macro-args)))))
+ (let ,(append (mapcar (function
+ (lambda (opt)
+ (or (and (listp opt) (nth 3 opt))
+ 'eshell-option-stub)))
+ (cadr options))
+ '(usage-msg last-value ext-command args))
+ (eshell-do-opt ,name ,options (quote ,body-forms)))))
+
+;;; Internal Functions:
+
+(eval-when-compile
+ (defvar temp-args)
+ (defvar last-value)
+ (defvar usage-msg)
+ (defvar ext-command)
+ (defvar args))
+
+(defun eshell-do-opt (name options body-forms)
+ "Helper function for `eshell-eval-using-options'.
+This code doesn't really need to be macro expanded everywhere."
+ (setq args temp-args)
+ (if (setq
+ ext-command
+ (catch 'eshell-ext-command
+ (when (setq
+ usage-msg
+ (catch 'eshell-usage
+ (setq last-value nil)
+ (if (and (= (length args) 0)
+ (memq ':show-usage options))
+ (throw 'eshell-usage
+ (eshell-show-usage name options)))
+ (setq args (eshell-process-args name args options)
+ last-value (eval (append (list 'progn)
+ body-forms)))
+ nil))
+ (error usage-msg))))
+ (throw 'eshell-external
+ (eshell-external-command ext-command args))
+ last-value))
+
+(defun eshell-show-usage (name options)
+ "Display the usage message for NAME, using OPTIONS."
+ (let ((usage (format "usage: %s %s\n\n" name
+ (cadr (memq ':usage options))))
+ (extcmd (memq ':external options))
+ (post-usage (memq ':post-usage options))
+ had-option)
+ (while options
+ (when (listp (car options))
+ (let ((opt (car options)))
+ (setq had-option t)
+ (cond ((and (nth 0 opt)
+ (nth 1 opt))
+ (setq usage
+ (concat usage
+ (format " %-20s %s\n"
+ (format "-%c, --%s" (nth 0 opt)
+ (nth 1 opt))
+ (nth 4 opt)))))
+ ((nth 0 opt)
+ (setq usage
+ (concat usage
+ (format " %-20s %s\n"
+ (format "-%c" (nth 0 opt))
+ (nth 4 opt)))))
+ ((nth 1 opt)
+ (setq usage
+ (concat usage
+ (format " %-20s %s\n"
+ (format " --%s" (nth 1 opt))
+ (nth 4 opt)))))
+ (t (setq had-option nil)))))
+ (setq options (cdr options)))
+ (if post-usage
+ (setq usage (concat usage (and had-option "\n")
+ (cadr post-usage))))
+ (when extcmd
+ (setq extcmd (eshell-search-path (cadr extcmd)))
+ (if extcmd
+ (setq usage
+ (concat usage
+ (format "
+This command is implemented in Lisp. If an unrecognized option is
+passed to this command, the external version '%s'
+will be called instead." extcmd)))))
+ (throw 'eshell-usage usage)))
+
+(defun eshell-set-option (name ai opt options)
+ "Using NAME's remaining args (index AI), set the OPT within OPTIONS.
+If the option consumes an argument for its value, the argument list
+will be modified."
+ (if (not (nth 3 opt))
+ (eshell-show-usage name options)
+ (if (eq (nth 2 opt) t)
+ (if (> ai (length args))
+ (error "%s: missing option argument" name)
+ (set (nth 3 opt) (nth ai args))
+ (if (> ai 0)
+ (setcdr (nthcdr (1- ai) args) (nthcdr (1+ ai) args))
+ (setq args (cdr args))))
+ (set (nth 3 opt) (or (nth 2 opt) t)))))
+
+(defun eshell-process-option (name switch kind ai options)
+ "For NAME, process SWITCH (of type KIND), from args at index AI.
+The SWITCH will be looked up in the set of OPTIONS.
+
+SWITCH should be either a string or character. KIND should be the
+integer 0 if it's a character, or 1 if it's a string.
+
+The SWITCH is then be matched against OPTIONS. If no matching handler
+is found, and an :external command is defined (and available), it will
+be called; otherwise, an error will be triggered to say that the
+switch is unrecognized."
+ (let* ((opts options)
+ found)
+ (while opts
+ (if (and (listp (car opts))
+ (nth kind (car opts))
+ (if (= kind 0)
+ (eq switch (nth kind (car opts)))
+ (string= switch (nth kind (car opts)))))
+ (progn
+ (eshell-set-option name ai (car opts) options)
+ (setq found t opts nil))
+ (setq opts (cdr opts))))
+ (unless found
+ (let ((extcmd (memq ':external options)))
+ (when extcmd
+ (setq extcmd (eshell-search-path (cadr extcmd)))
+ (if extcmd
+ (throw 'eshell-ext-command extcmd)
+ (if (char-valid-p switch)
+ (error "%s: unrecognized option -%c" name switch)
+ (error "%s: unrecognized option --%s" name switch))))))))
+
+(defun eshell-process-args (name args options)
+ "Process the given ARGS using OPTIONS.
+This assumes that symbols have been intern'd by `eshell-with-options'."
+ (let ((ai 0) arg)
+ (while (< ai (length args))
+ (setq arg (nth ai args))
+ (if (not (and (stringp arg)
+ (string-match "^-\\(-\\)?\\(.*\\)" arg)))
+ (setq ai (1+ ai))
+ (let* ((dash (match-string 1 arg))
+ (switch (match-string 2 arg)))
+ (if (= ai 0)
+ (setq args (cdr args))
+ (setcdr (nthcdr (1- ai) args) (nthcdr (1+ ai) args)))
+ (if dash
+ (if (> (length switch) 0)
+ (eshell-process-option name switch 1 ai options)
+ (setq ai (length args)))
+ (let ((len (length switch))
+ (index 0))
+ (while (< index len)
+ (eshell-process-option name (aref switch index) 0 ai options)
+ (setq index (1+ index)))))))))
+ args)
+
+;;; Code:
+
+;;; esh-opt.el ends here
--- /dev/null
+;;; esh-proc --- process management
+
+;; Copyright (C) 1999, 2000 Free Sofware Foundation
+
+;; 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 2, 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+(provide 'esh-proc)
+
+(eval-when-compile (require 'esh-maint))
+
+(defgroup eshell-proc nil
+ "When Eshell invokes external commands, it always does so
+asynchronously, so that Emacs isn't tied up waiting for the process to
+finish."
+ :tag "Process management"
+ :group 'eshell)
+
+;;; Commentary:
+
+;;; User Variables:
+
+(defcustom eshell-proc-load-hook '(eshell-proc-initialize)
+ "*A hook that gets run when `eshell-proc' is loaded."
+ :type 'hook
+ :group 'eshell-proc)
+
+(defcustom eshell-process-wait-seconds 0
+ "*The number of seconds to delay waiting for a synchronous process."
+ :type 'integer
+ :group 'eshell-proc)
+
+(defcustom eshell-process-wait-milliseconds 50
+ "*The number of milliseconds to delay waiting for a synchronous process."
+ :type 'integer
+ :group 'eshell-proc)
+
+(defcustom eshell-done-messages-in-minibuffer t
+ "*If non-nil, subjob \"Done\" messages will display in minibuffer."
+ :type 'boolean
+ :group 'eshell-proc)
+
+(defcustom eshell-delete-exited-processes t
+ "*If nil, process entries will stick around until `jobs' is run.
+This variable sets the buffer-local value of `delete-exited-processes'
+in Eshell buffers.
+
+This variable causes Eshell to mimic the behavior of bash when set to
+nil. It allows the user to view the exit status of a completed subjob
+\(process) at their leisure, because the process entry remains in
+memory until the user examines it using \\[list-processes].
+
+Otherwise, if `eshell-done-messages-in-minibuffer' is nil, and this
+variable is set to t, the only indication the user will have that a
+subjob is done is that it will no longer appear in the
+\\[list-processes\\] display.
+
+Note that Eshell will have to be restarted for a change in this
+variable's value to take effect."
+ :type 'boolean
+ :group 'eshell-proc)
+
+(defcustom eshell-reset-signals
+ "^\\(interrupt\\|killed\\|quit\\|stopped\\)"
+ "*If a termination signal matches this regexp, the terminal will be reset."
+ :type 'regexp
+ :group 'eshell-proc)
+
+(defcustom eshell-exec-hook nil
+ "*Called each time a process is exec'd by `eshell-gather-process-output'.
+It is passed one argument, which is the process that was just started.
+It is useful for things that must be done each time a process is
+executed in a eshell mode buffer (e.g., `process-kill-without-query').
+In contrast, `eshell-mode-hook' is only executed once when the buffer
+is created."
+ :type 'hook
+ :group 'eshell-proc)
+
+(defcustom eshell-kill-hook '(eshell-reset-after-proc)
+ "*Called when a process run by `eshell-gather-process-output' has ended.
+It is passed two arguments: the process that was just ended, and the
+termination status (as a string). Note that the first argument may be
+nil, in which case the user attempted to send a signal, but there was
+no relevant process. This can be used for displaying help
+information, for example."
+ :type 'hook
+ :group 'eshell-proc)
+
+;;; Internal Variables:
+
+(defvar eshell-current-subjob-p nil)
+
+(defvar eshell-process-list nil
+ "A list of the current status of subprocesses.")
+
+;;; Functions:
+
+(defun eshell-proc-initialize ()
+ "Initialize the process handling code."
+ (make-local-variable 'eshell-process-list)
+ (define-key eshell-command-map [(meta ?i)] 'eshell-insert-process)
+ (define-key eshell-command-map [(control ?c)] 'eshell-interrupt-process)
+ (define-key eshell-command-map [(control ?k)] 'eshell-kill-process)
+ (define-key eshell-command-map [(control ?d)] 'eshell-send-eof-to-process)
+ (define-key eshell-command-map [(control ?q)] 'eshell-continue-process)
+ (define-key eshell-command-map [(control ?s)] 'list-processes)
+ (define-key eshell-command-map [(control ?z)] 'eshell-stop-process)
+ (define-key eshell-command-map [(control ?\\)] 'eshell-quit-process))
+
+(defun eshell-reset-after-proc (proc status)
+ "Reset the command input location after a process terminates.
+The signals which will cause this to happen are matched by
+`eshell-reset-signals'."
+ (if (string-match eshell-reset-signals status)
+ (eshell-reset)))
+
+(defun eshell-wait-for-process (&rest procs)
+ "Wait until PROC has successfully completed."
+ (while procs
+ (let ((proc (car procs)))
+ (when (processp proc)
+ ;; NYI: If the process gets stopped here, that's bad.
+ (while (assq proc eshell-process-list)
+ (if (input-pending-p)
+ (discard-input))
+ (sit-for eshell-process-wait-seconds
+ eshell-process-wait-milliseconds))))
+ (setq procs (cdr procs))))
+
+(defalias 'eshell/wait 'eshell-wait-for-process)
+
+(defun eshell/jobs (&rest args)
+ "List processes, if there are any."
+ (and (process-list)
+ (list-processes)))
+
+(defun eshell/kill (&rest args)
+ "Kill processes, buffers, symbol or files."
+ (let ((ptr args)
+ (signum 'SIGINT))
+ (while ptr
+ (if (or (processp (car ptr))
+ (and (stringp (car ptr))
+ (string-match "^[A-Za-z/][A-Za-z0-9<>/]+$"
+ (car ptr))))
+ ;; What about when $lisp-variable is possible here?
+ ;; It could very well name a process.
+ (setcar ptr (get-process (car ptr))))
+ (setq ptr (cdr ptr)))
+ (while args
+ (let ((id (if (processp (car args))
+ (process-id (car args))
+ (car args))))
+ (when id
+ (cond
+ ((null id)
+ (error "kill: bad signal spec"))
+ ((and (numberp id) (= id 0))
+ (error "kill: bad signal spec `%d'" id))
+ ((and (stringp id)
+ (string-match "^-?[0-9]+$" id))
+ (setq signum (abs (string-to-number id))))
+ ((stringp id)
+ (let (case-fold-search)
+ (if (string-match "^-\\([A-Z]+\\)$" id)
+ (setq signum
+ (intern (concat "SIG" (match-string 1 id))))
+ (error "kill: bad signal spec `%s'" id))))
+ ((< id 0)
+ (setq signum (abs id)))
+ (t
+ (signal-process id signum)))))
+ (setq args (cdr args)))
+ nil))
+
+(defun eshell-read-process-name (prompt)
+ "Read the name of a process from the minibuffer, using completion.
+The prompt will be set to PROMPT."
+ (completing-read prompt
+ (mapcar
+ (function
+ (lambda (proc)
+ (cons (process-name proc) t)))
+ (process-list)) nil t))
+
+(defun eshell-insert-process (process)
+ "Insert the name of PROCESS into the current buffer at point."
+ (interactive
+ (list (get-process
+ (eshell-read-process-name "Name of process: "))))
+ (insert-and-inherit "#<process " (process-name process) ">"))
+
+(defsubst eshell-record-process-object (object)
+ "Record OBJECT as now running."
+ (if (and (processp object)
+ eshell-current-subjob-p)
+ (eshell-interactive-print
+ (format "[%s] %d\n" (process-name object) (process-id object))))
+ (setq eshell-process-list
+ (cons (list object eshell-current-handles
+ eshell-current-subjob-p nil nil)
+ eshell-process-list)))
+
+(defun eshell-remove-process-entry (entry)
+ "Record the process ENTRY as fully completed."
+ (if (and (processp (car entry))
+ (nth 2 entry)
+ eshell-done-messages-in-minibuffer)
+ (message (format "[%s]+ Done %s" (process-name (car entry))
+ (process-command (car entry)))))
+ (setq eshell-process-list
+ (delq entry eshell-process-list)))
+
+(defun eshell-gather-process-output (command args)
+ "Gather the output from COMMAND + ARGS."
+ (unless (and (file-executable-p command)
+ (file-regular-p command))
+ (error "%s: not an executable file" command))
+ (let* ((delete-exited-processes
+ (if eshell-current-subjob-p
+ eshell-delete-exited-processes
+ delete-exited-processes))
+ (process-environment (eshell-environment-variables))
+ (proc (apply 'start-process
+ (file-name-nondirectory command) nil
+ ;; `start-process' can't deal with relative
+ ;; filenames
+ (append (list (expand-file-name command)) args)))
+ decoding encoding changed)
+ (eshell-record-process-object proc)
+ (set-process-buffer proc (current-buffer))
+ (if (eshell-interactive-output-p)
+ (set-process-filter proc 'eshell-output-filter)
+ (set-process-filter proc 'eshell-insertion-filter))
+ (set-process-sentinel proc 'eshell-sentinel)
+ (run-hook-with-args 'eshell-exec-hook proc)
+ (when (fboundp 'process-coding-system)
+ (let ((coding-systems (process-coding-system proc)))
+ (setq decoding (car coding-systems)
+ encoding (cdr coding-systems)))
+ ;; If start-process decided to use some coding system for
+ ;; decoding data sent from the process and the coding system
+ ;; doesn't specify EOL conversion, we had better convert CRLF
+ ;; to LF.
+ (if (vectorp (coding-system-eol-type decoding))
+ (setq decoding (coding-system-change-eol-conversion decoding 'dos)
+ changed t))
+ ;; Even if start-process left the coding system for encoding
+ ;; data sent from the process undecided, we had better use the
+ ;; same one as what we use for decoding. But, we should
+ ;; suppress EOL conversion.
+ (if (and decoding (not encoding))
+ (setq encoding (coding-system-change-eol-conversion decoding 'unix)
+ changed t))
+ (if changed
+ (set-process-coding-system proc decoding encoding)))
+ proc))
+
+(defun eshell-insertion-filter (proc string)
+ "Insert a string into the eshell buffer, or a process/file/buffer.
+PROC is the process for which we're inserting output. STRING is the
+output."
+ (when (buffer-live-p (process-buffer proc))
+ (set-buffer (process-buffer proc))
+ (let ((entry (assq proc eshell-process-list)))
+ (when entry
+ (setcar (nthcdr 3 entry)
+ (concat (nth 3 entry) string))
+ (unless (nth 4 entry) ; already being handled?
+ (while (nth 3 entry)
+ (let ((data (nth 3 entry)))
+ (setcar (nthcdr 3 entry) nil)
+ (setcar (nthcdr 4 entry) t)
+ (eshell-output-object data nil (cadr entry))
+ (setcar (nthcdr 4 entry) nil))))))))
+
+(defun eshell-sentinel (proc string)
+ "Generic sentinel for command processes. Reports only signals.
+PROC is the process that's exiting. STRING is the exit message."
+ (when (buffer-live-p (process-buffer proc))
+ (set-buffer (process-buffer proc))
+ (unwind-protect
+ (let* ((entry (assq proc eshell-process-list)))
+; (if (not entry)
+; (error "Sentinel called for unowned process `%s'"
+; (process-name proc))
+ (when entry
+ (unwind-protect
+ (progn
+ (unless (string= string "run")
+ (unless (string-match "^\\(finished\\|exited\\)" string)
+ (eshell-insertion-filter proc string))
+ (eshell-close-handles (process-exit-status proc) 'nil
+ (cadr entry))))
+ (eshell-remove-process-entry entry))))
+ (run-hook-with-args 'eshell-kill-hook proc string))))
+
+(defun eshell-process-interact (func &optional all query)
+ "Interact with a process, using PROMPT if more than one, via FUNC.
+If ALL is non-nil, background processes will be interacted with as well.
+If QUERY is non-nil, query the user with QUERY before calling FUNC."
+ (let (defunct result)
+ (eshell-for entry eshell-process-list
+ (if (and (memq (process-status (car entry))
+ '(run stop open closed))
+ (or all
+ (not (nth 2 entry)))
+ (or (not query)
+ (y-or-n-p (format query (process-name (car entry))))))
+ (setq result (funcall func (car entry))))
+ (unless (memq (process-status (car entry))
+ '(run stop open closed))
+ (setq defunct (cons entry defunct))))
+ ;; clean up the process list; this can get dirty if an error
+ ;; occurred that brought the user into the debugger, and then they
+ ;; quit, so that the sentinel was never called.
+ (eshell-for d defunct
+ (eshell-remove-process-entry d))
+ result))
+
+(defcustom eshell-kill-process-wait-time 5
+ "*Seconds to wait between sending termination signals to a subprocess."
+ :type 'integer
+ :group 'eshell-proc)
+
+(defcustom eshell-kill-process-signals '(SIGINT SIGQUIT SIGKILL)
+ "*Signals used to kill processes when an Eshell buffer exits.
+Eshell calls each of these signals in order when an Eshell buffer is
+killed; if the process is still alive afterwards, Eshell waits a
+number of seconds defined by `eshell-kill-process-wait-time', and
+tries the next signal in the list."
+ :type '(repeat symbol)
+ :group 'eshell-proc)
+
+(defcustom eshell-kill-processes-on-exit nil
+ "*If non-nil, kill active processes when exiting an Eshell buffer.
+Emacs will only kill processes owned by that Eshell buffer.
+
+If nil, ownership of background and foreground processes reverts to
+Emacs itself, and will die only if the user exits Emacs, calls
+`kill-process', or terminates the processes externally.
+
+If `ask', Emacs prompts the user before killing any processes.
+
+If `every', it prompts once for every process.
+
+If t, it kills all buffer-owned processes without asking.
+
+Processes are first sent SIGHUP, then SIGINT, then SIGQUIT, then
+SIGKILL. The variable `eshell-kill-process-wait-time' specifies how
+long to delay between signals."
+ :type '(choice (const :tag "Kill all, don't ask" t)
+ (const :tag "Ask before killing" ask)
+ (const :tag "Ask for each process" every)
+ (const :tag "Don't kill subprocesses" nil))
+ :group 'eshell-proc)
+
+(defun eshell-round-robin-kill (&optional query)
+ "Kill current process by trying various signals in sequence.
+See the variable `eshell-kill-processes-on-exit'."
+ (let ((sigs eshell-kill-process-signals))
+ (while sigs
+ (eshell-process-interact
+ (function
+ (lambda (proc)
+ (signal-process (process-id proc) (car sigs)))) t query)
+ (setq query nil)
+ (if (not eshell-process-list)
+ (setq sigs nil)
+ (sleep-for eshell-kill-process-wait-time)
+ (setq sigs (cdr sigs))))))
+
+(defun eshell-query-kill-processes ()
+ "Kill processes belonging to the current Eshell buffer, possibly w/ query."
+ (when (and eshell-kill-processes-on-exit
+ eshell-process-list)
+ (save-window-excursion
+ (list-processes)
+ (if (or (not (eq eshell-kill-processes-on-exit 'ask))
+ (y-or-n-p (format "Kill processes owned by `%s'? "
+ (buffer-name))))
+ (eshell-round-robin-kill
+ (if (eq eshell-kill-processes-on-exit 'every)
+ "Kill Eshell child process `%s'? ")))
+ (let ((buf (get-buffer "*Process List*")))
+ (if (and buf (buffer-live-p buf))
+ (kill-buffer buf)))
+ (message nil))))
+
+(custom-add-option 'eshell-exit-hook 'eshell-query-kill-processes)
+
+(defun eshell-interrupt-process ()
+ "Interrupt a process."
+ (interactive)
+ (unless (eshell-process-interact 'interrupt-process)
+ (run-hook-with-args 'eshell-kill-hook nil "interrupt")))
+
+(defun eshell-kill-process ()
+ "Kill a process."
+ (interactive)
+ (unless (eshell-process-interact 'kill-process)
+ (run-hook-with-args 'eshell-kill-hook nil "killed")))
+
+(defun eshell-quit-process ()
+ "Send quit signal to process."
+ (interactive)
+ (unless (eshell-process-interact 'quit-process)
+ (run-hook-with-args 'eshell-kill-hook nil "quit")))
+
+(defun eshell-stop-process ()
+ "Send STOP signal to process."
+ (interactive)
+ (unless (eshell-process-interact 'stop-process)
+ (run-hook-with-args 'eshell-kill-hook nil "stopped")))
+
+(defun eshell-continue-process ()
+ "Send CONTINUE signal to process."
+ (interactive)
+ (unless (eshell-process-interact 'continue-process)
+ ;; jww (1999-09-17): this signal is not dealt with yet. For
+ ;; example, `eshell-reset' will be called, and so will
+ ;; `eshell-resume-eval'.
+ (run-hook-with-args 'eshell-kill-hook nil "continue")))
+
+(defun eshell-send-eof-to-process ()
+ "Send EOF to process."
+ (interactive)
+ (eshell-send-input nil nil t)
+ (eshell-process-interact 'process-send-eof))
+
+;;; Code:
+
+;;; esh-proc.el ends here
--- /dev/null
+;;; esh-test --- Eshell test suite
+
+;; Copyright (C) 1999, 2000 Free Sofware Foundation
+
+;; 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 2, 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+(provide 'esh-test)
+
+(eval-when-compile (require 'esh-maint))
+
+(defgroup eshell-test nil
+ "This module is meant to ensure that Eshell is working correctly."
+ :tag "Eshell test suite"
+ :group 'eshell)
+
+;;; Commentary:
+
+;; The purpose of this module is to verify that Eshell works as
+;; expected. To run it on your system, use the command
+;; \\[eshell-test].
+
+;;; Code:
+
+(require 'esh-mode)
+
+;;; User Variables:
+
+(defface eshell-test-ok-face
+ '((((class color) (background light)) (:foreground "Green" :bold t))
+ (((class color) (background dark)) (:foreground "Green" :bold t)))
+ "*The face used to highlight OK result strings."
+ :group 'eshell-test)
+
+(defface eshell-test-failed-face
+ '((((class color) (background light)) (:foreground "OrangeRed" :bold t))
+ (((class color) (background dark)) (:foreground "OrangeRed" :bold t))
+ (t (:bold t)))
+ "*The face used to highlight FAILED result strings."
+ :group 'eshell-test)
+
+(defcustom eshell-show-usage-metrics nil
+ "*If non-nil, display different usage metrics for each Eshell command."
+ :set (lambda (symbol value)
+ (if value
+ (add-hook 'eshell-mode-hook 'eshell-show-usage-metrics)
+ (remove-hook 'eshell-mode-hook 'eshell-show-usage-metrics))
+ (set symbol value))
+ :type '(choice (const :tag "No metrics" nil)
+ (const :tag "Cons cells consumed" t)
+ (const :tag "Time elapsed" 0))
+ :group 'eshell-test)
+
+;;; Code:
+
+(eval-when-compile
+ (defvar test-buffer))
+
+(defun eshell-insert-command (text &optional func)
+ "Insert a command at the end of the buffer."
+ (goto-char eshell-last-output-end)
+ (insert-and-inherit text)
+ (funcall (or func 'eshell-send-input)))
+
+(defun eshell-match-result (regexp)
+ "Insert a command at the end of the buffer."
+ (goto-char eshell-last-input-end)
+ (looking-at regexp))
+
+(defun eshell-command-result-p (text regexp &optional func)
+ "Insert a command at the end of the buffer."
+ (eshell-insert-command text func)
+ (eshell-match-result regexp))
+
+(defvar eshell-test-failures nil)
+
+(defun eshell-run-test (module funcsym label command)
+ "Test whether FORM evaluates to a non-nil value."
+ (when (let ((sym (intern-soft (concat "eshell-" (symbol-name module)))))
+ (or (memq sym (eshell-subgroups 'eshell))
+ (eshell-using-module sym)))
+ (with-current-buffer test-buffer
+ (insert-before-markers
+ (format "%-70s " (substring label 0 (min 70 (length label)))))
+ (insert-before-markers " ....")
+ (eshell-redisplay))
+ (let ((truth (eval command)))
+ (with-current-buffer test-buffer
+ (delete-backward-char 6)
+ (insert-before-markers
+ "[" (let (str)
+ (if truth
+ (progn
+ (setq str " OK ")
+ (put-text-property 0 6 'face
+ 'eshell-test-ok-face str))
+ (setq str "FAILED")
+ (setq eshell-test-failures (1+ eshell-test-failures))
+ (put-text-property 0 6 'face
+ 'eshell-test-failed-face str))
+ str) "]")
+ (add-text-properties (line-beginning-position) (point)
+ (list 'test-func funcsym))
+ (eshell-redisplay)))))
+
+(defun eshell-test-goto-func ()
+ "Jump to the function that defines a particular test."
+ (interactive)
+ (let ((fsym (get-text-property (point) 'test-func)))
+ (when fsym
+ (let* ((def (symbol-function fsym))
+ (library (locate-library (symbol-file fsym)))
+ (name (substring (symbol-name fsym)
+ (length "eshell-test--")))
+ (inhibit-redisplay t))
+ (find-file library)
+ (goto-char (point-min))
+ (re-search-forward (concat "^(eshell-deftest\\s-+\\w+\\s-+"
+ name))
+ (beginning-of-line)))))
+
+(defun eshell-run-one-test (&optional arg)
+ "Jump to the function that defines a particular test."
+ (interactive "P")
+ (let ((fsym (get-text-property (point) 'test-func)))
+ (when fsym
+ (beginning-of-line)
+ (delete-region (point) (line-end-position))
+ (let ((test-buffer (current-buffer)))
+ (set-buffer (let ((inhibit-redisplay t))
+ (save-window-excursion (eshell t))))
+ (funcall fsym)
+ (unless arg
+ (kill-buffer (current-buffer)))))))
+
+;;;###autoload
+(defun eshell-test (&optional arg)
+ "Test Eshell to verify that it works as expected."
+ (interactive "P")
+ (let* ((begin (eshell-time-to-seconds (current-time)))
+ (test-buffer (get-buffer-create "*eshell test*")))
+ (set-buffer (let ((inhibit-redisplay t))
+ (save-window-excursion (eshell t))))
+ (with-current-buffer test-buffer
+ (erase-buffer)
+ (setq major-mode 'eshell-test-mode)
+ (setq mode-name "EShell Test")
+ (set (make-local-variable 'eshell-test-failures) 0)
+ (local-set-key [(control ?c) (control ?c)] 'eshell-test-goto-func)
+ (local-set-key [(control ?c) (control ?r)] 'eshell-run-one-test)
+ (local-set-key [(control ?m)] 'eshell-test-goto-func)
+ (local-set-key [return] 'eshell-test-goto-func)
+
+ (insert "Testing Eshell under "
+ (format "GNU Emacs %s (%s%s)"
+ emacs-version
+ system-configuration
+ (cond ((featurep 'motif) ", Motif")
+ ((featurep 'x-toolkit) ", X toolkit")
+ (t ""))) "\n")
+ (switch-to-buffer test-buffer)
+ (delete-other-windows))
+ (eshell-for funcname
+ (sort (all-completions "eshell-test--" obarray 'functionp)
+ 'string-lessp)
+ (with-current-buffer test-buffer
+ (insert "\n"))
+ (funcall (intern-soft funcname)))
+ (with-current-buffer test-buffer
+ (insert (format "\n\n--- %s --- (completed in %d seconds)\n"
+ (current-time-string)
+ (- (eshell-time-to-seconds (current-time))
+ begin)))
+ (message "Eshell test suite completed: %s failure%s"
+ (if (> eshell-test-failures 0)
+ (number-to-string eshell-test-failures)
+ "No")
+ (if (= eshell-test-failures 1) "" "s"))))
+ (goto-char eshell-last-output-end)
+ (unless arg
+ (kill-buffer (current-buffer))))
+
+
+(defvar eshell-metric-before-command 0)
+(defvar eshell-metric-after-command 0)
+
+(defun eshell-show-usage-metrics ()
+ "If run at Eshell mode startup, metrics are shown after each command."
+ (set (make-local-variable 'eshell-metric-before-command)
+ (if (eq eshell-show-usage-metrics t)
+ 0
+ (current-time)))
+ (set (make-local-variable 'eshell-metric-after-command)
+ (if (eq eshell-show-usage-metrics t)
+ 0
+ (current-time)))
+
+ (make-local-hook 'eshell-pre-command-hook)
+ (add-hook 'eshell-pre-command-hook
+ (function
+ (lambda ()
+ (setq eshell-metric-before-command
+ (if (eq eshell-show-usage-metrics t)
+ (car (memory-use-counts))
+ (current-time))))) nil t)
+
+ (make-local-hook 'eshell-post-command-hook)
+ (add-hook 'eshell-post-command-hook
+ (function
+ (lambda ()
+ (setq eshell-metric-after-command
+ (if (eq eshell-show-usage-metrics t)
+ (car (memory-use-counts))
+ (current-time)))
+ (eshell-interactive-print
+ (concat
+ (int-to-string
+ (if (eq eshell-show-usage-metrics t)
+ (- eshell-metric-after-command
+ eshell-metric-before-command 7)
+ (- (eshell-time-to-seconds
+ eshell-metric-after-command)
+ (eshell-time-to-seconds
+ eshell-metric-before-command))))
+ "\n"))))
+ nil t))
+
+;;; esh-test.el ends here
--- /dev/null
+;;; esh-toggle --- toggle to and from the *eshell* buffer
+
+;; Copyright (C) 1997, 1998 Mikael Sjödin (mic@docs.uu.se)
+
+;; Author: Mikael Sjödin <mic@docs.uu.se>
+;; John Wiegley <johnw@gnu.org>
+;; Created: 19 Nov 1998
+;; Version: 2.0
+;; Keywords: processes
+;; X-URL: http://www.emacs.org/~johnw/eshell.html
+
+;; This program 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 2, or (at
+;; your option) any later version.
+
+;; This program 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+;;; Commentary:
+
+;; Provides the command eshell-toggle which toggles between the
+;; *eshell* buffer and whatever buffer you are editing.
+;;
+;; This is done in an "intelligent" way. Features are:
+;;
+;; - Starts a eshell if non is existing.
+;;
+;; - Minimum distortion of your window configuration.
+;;
+;; - When done in the eshell-buffer you are returned to the same
+;; window configuration you had before you toggled to the eshell.
+;;
+;; - If you desire, you automagically get a "cd" command in the
+;; eshell to the directory where your current buffers file exists;
+;; just call eshell-toggle-cd instead of eshell-toggle.
+;;
+;; - You can convinently choose if you want to have the eshell in
+;; another window or in the whole frame. Just invoke eshell-toggle
+;; again to get the eshell in the whole frame.
+;;
+;; This file has been tested under Emacs 20.2.
+;;
+;; To use, call the functions `eshell-toggle' or `eshell-toggle-cd'.
+;; It's most helpful to bind these to a key.
+
+;;; Thanks to:
+
+;; Christian Stern <Christian.Stern@physik.uni-regensburg.de> for
+;; helpful sugestions.
+
+;;; User Variables:
+
+(defvar eshell-toggle-goto-eob t
+ "*If non-nil `eshell-toggle' moves point to end of Eshell buffer.
+When `eshell-toggle-cd' is called the point is always moved to the
+end of the eshell-buffer")
+
+(defvar eshell-toggle-automatic-cd t
+ "*If non-nil `eshell-toggle-cd' will send a \"cd\" to Eshell.
+If nil `eshell-toggle-cd' will only insert the \"cd\" command in the
+eshell-buffer. Leaving it to the user to press RET to send the
+command to the eshell.")
+
+;;; User Functions:
+
+;;;###autoload
+(defun eshell-toggle-cd ()
+ "Calls `eshell-toggle' with a prefix argument.
+See the command `eshell-toggle'"
+ (interactive)
+ (eshell-toggle t))
+
+;;;###autoload
+(defun eshell-toggle (make-cd)
+ "Toggles between the *eshell* buffer and the current buffer.
+With a prefix ARG also insert a \"cd DIR\" command into the eshell,
+where DIR is the directory of the current buffer.
+
+Call twice in a row to get a full screen window for the *eshell*
+buffer.
+
+When called in the *eshell* buffer returns you to the buffer you were
+editing before caling the first time.
+
+Options: `eshell-toggle-goto-eob'"
+ (interactive "P")
+ ;; Try to descide on one of three possibilities:
+ ;; 1. If not in eshell-buffer, switch to it.
+ ;; 2. If in eshell-buffer and called twice in a row, delete other
+ ;; windows
+ ;; 3. If in eshell-buffer and not called twice in a row, return to
+ ;; state before going to the eshell-buffer
+ (if (eq major-mode 'eshell-mode)
+ (if (and (or (eq last-command 'eshell-toggle)
+ (eq last-command 'eshell-toggle-cd))
+ (not (eq (count-windows) 1)))
+ (delete-other-windows)
+ (eshell-toggle-buffer-return-from-eshell))
+ (eshell-toggle-buffer-goto-eshell make-cd)))
+
+;;; Internal Functions:
+
+(defvar eshell-toggle-pre-eshell-win-conf nil
+ "Contains window config before the *eshell* buffer was selected")
+
+(defun eshell-toggle-buffer-return-from-eshell ()
+ "Restores window config used before switching the *eshell* buffer.
+If no configuration has been stored, just bury the *eshell* buffer."
+ (if (window-configuration-p eshell-toggle-pre-eshell-win-conf)
+ (progn
+ (set-window-configuration eshell-toggle-pre-eshell-win-conf)
+ (setq eshell-toggle-pre-eshell-win-conf nil)
+ (bury-buffer (get-buffer "*eshell*")))
+ (bury-buffer)))
+
+(defun eshell-toggle-buffer-goto-eshell (make-cd)
+ "Switches other window to the *eshell* buffer.
+If no *eshell* buffer exists start a new eshell and switch to it in
+other window. If argument MAKE-CD is non-nil, insert a \"cd DIR\"
+command into the eshell, where DIR is the directory of the current
+buffer.
+Stores the window cofiguration before creating and/or switching window."
+ (setq eshell-toggle-pre-eshell-win-conf (current-window-configuration))
+ (let ((eshell-buffer (get-buffer "*eshell*"))
+ (cd-command
+ ;; Find out which directory we are in (the method differs for
+ ;; different buffers)
+ (or (and make-cd
+ (buffer-file-name)
+ (file-name-directory (buffer-file-name))
+ (concat "cd " (file-name-directory (buffer-file-name))))
+ (and make-cd
+ list-buffers-directory
+ (concat "cd " list-buffers-directory)))))
+ ;; Switch to an existin eshell if one exists, otherwise switch to
+ ;; another window and start a new eshell
+ (if eshell-buffer
+ (switch-to-buffer-other-window eshell-buffer)
+ (eshell-toggle-buffer-switch-to-other-window)
+ ;; Sometimes an error is generated when I call `eshell' (it has
+ ;; to do with my eshell-mode-hook which inserts text into the
+ ;; newly created eshell-buffer and thats not allways a good
+ ;; idea).
+ (condition-case the-error
+ (eshell)
+ (error (switch-to-buffer "*eshell*"))))
+ (if (or cd-command eshell-toggle-goto-eob)
+ (goto-char (point-max)))
+ (if cd-command
+ (progn
+ (insert cd-command)
+ (if eshell-toggle-automatic-cd
+ (eshell-send-input))))))
+
+(defun eshell-toggle-buffer-switch-to-other-window ()
+ "Switches to other window.
+If the current window is the only window in the current frame, create
+a new window and switch to it. (This is less intrusive to the current
+window configuration then `switch-buffer-other-window')"
+ (let ((this-window (selected-window)))
+ (other-window 1)
+ ;; If we did not switch window then we only have one window and
+ ;; need to create a new one.
+ (if (eq this-window (selected-window))
+ (progn
+ (split-window-vertically)
+ (other-window 1)))))
+
+(provide 'esh-toggle)
+
+;;; esh-toggle.el ends here
--- /dev/null
+;;; esh-var --- handling of variables
+
+;; Copyright (C) 1999, 2000 Free Sofware Foundation
+
+;; 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 2, 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+(provide 'esh-var)
+
+(eval-when-compile (require 'esh-maint))
+
+(defgroup eshell-var nil
+ "Variable interpolation is introduced whenever the '$' character
+appears unquoted in any argument (except when that argument is
+surrounded by single quotes) . It may be used to interpolate a
+variable value, a subcommand, or even the result of a Lisp form."
+ :tag "Variable handling"
+ :group 'eshell)
+
+;;; Commentary:
+
+;; These are the possible variable interpolation syntaxes. Also keep
+;; in mind that if an argument looks like a number, it will be
+;; converted to a number. This is not significant when invoking
+;; external commands, but it's important when calling Lisp functions.
+;;
+;; $VARIABLE
+;;
+;; Interval the value of an environment variable, or a Lisp variable
+;;
+;; $ALSO-VAR
+;;
+;; "-" is a legal part of a variable name.
+;;
+;; $<MYVAR>-TOO
+;;
+;; Only "MYVAR" is part of the variable name in this case.
+;;
+;; $#VARIABLE
+;;
+;; Returns the length of the value of VARIABLE. This could also be
+;; done using the `length' Lisp function.
+;;
+;; $(lisp)
+;;
+;; Returns result of lisp evaluation. Note: Used alone like this, it
+;; is identical to just saying (lisp); but with the variable expansion
+;; form, the result may be interpolated a larger string, such as
+;; '$(lisp)/other'.
+;;
+;; ${command}
+;;
+;; Returns the value of an eshell subcommand. See the note above
+;; regarding Lisp evaluations.
+;;
+;; $ANYVAR[10]
+;;
+;; Return the 10th element of ANYVAR. If ANYVAR's value is a string,
+;; it will be split in order to make it a list. The splitting will
+;; occur at whitespace.
+;;
+;; $ANYVAR[: 10]
+;;
+;; As above, except that splitting occurs at the colon now.
+;;
+;; $ANYVAR[: 10 20]
+;;
+;; As above, but instead of returning just a string, it now returns a
+;; list of two strings. If the result is being interpolated into a
+;; larger string, this list will be flattened into one big string,
+;; with each element separated by a space.
+;;
+;; $ANYVAR["\\\\" 10]
+;;
+;; Separate on backslash characters. Actually, the first argument --
+;; if it doesn't have the form of a number, or a plain variable name
+;; -- can be any regular expression. So to split on numbers, use
+;; '$ANYVAR["[0-9]+" 10 20]'.
+;;
+;; $ANYVAR[hello]
+;;
+;; Calls `assoc' on ANYVAR with 'hello', expecting it to be an alist.
+;;
+;; $#ANYVAR[hello]
+;;
+;; Returns the length of the cdr of the element of ANYVAR who car is
+;; equal to "hello".
+;;
+;; There are also a few special variables defined by Eshell. '$$' is
+;; the value of the last command (t or nil, in the case of an external
+;; command). This makes it possible to chain results:
+;;
+;; /tmp $ echo /var/spool/mail/johnw
+;; /var/spool/mail/johnw
+;; /tmp $ dirname $$
+;; /var/spool/mail/
+;; /tmp $ cd $$
+;; /var/spool/mail $
+;;
+;; '$_' refers to the last argument of the last command. And $?
+;; contains the exit code of the last command (0 or 1 for Lisp
+;; functions, based on successful completion).
+
+(require 'env)
+(require 'ring)
+
+;;; User Variables:
+
+(defcustom eshell-var-load-hook '(eshell-var-initialize)
+ "*A list of functions to call when loading `eshell-var'."
+ :type 'hook
+ :group 'eshell-var)
+
+(defcustom eshell-prefer-lisp-variables nil
+ "*If non-nil, prefer Lisp variables to environment variables."
+ :type 'boolean
+ :group 'eshell-var)
+
+(defcustom eshell-complete-export-definition t
+ "*If non-nil, completing names for `export' shows current definition."
+ :type 'boolean
+ :group 'eshell-var)
+
+(defcustom eshell-variable-name-regexp "[A-Za-z0-9_-]+"
+ "*A regexp identifying what constitutes a variable name reference.
+Note that this only applies for '$NAME'. If the syntax '$<NAME>' is
+used, then NAME can contain any character, including angle brackets,
+if they are quoted with a backslash."
+ :type 'regexp
+ :group 'eshell-var)
+
+(defcustom eshell-variable-aliases-list
+ '(;; for eshell.el
+ ("COLUMNS" (lambda (indices) (window-width)) t)
+ ("LINES" (lambda (indices) (window-height)) t)
+
+ ;; for eshell-cmd.el
+ ("_" (lambda (indices)
+ (if (not indices)
+ (car (last eshell-last-arguments))
+ (eshell-apply-indices eshell-last-arguments
+ indices))))
+ ("?" eshell-last-command-status)
+ ("$" eshell-last-command-result)
+ ("0" eshell-command-name)
+ ("1" (lambda (indices) (nth 0 eshell-command-arguments)))
+ ("2" (lambda (indices) (nth 1 eshell-command-arguments)))
+ ("3" (lambda (indices) (nth 2 eshell-command-arguments)))
+ ("4" (lambda (indices) (nth 3 eshell-command-arguments)))
+ ("5" (lambda (indices) (nth 4 eshell-command-arguments)))
+ ("6" (lambda (indices) (nth 5 eshell-command-arguments)))
+ ("7" (lambda (indices) (nth 6 eshell-command-arguments)))
+ ("8" (lambda (indices) (nth 7 eshell-command-arguments)))
+ ("9" (lambda (indices) (nth 8 eshell-command-arguments)))
+ ("*" (lambda (indices)
+ (if (not indices)
+ eshell-command-arguments
+ (eshell-apply-indices eshell-command-arguments
+ indices)))))
+ "*This list provides aliasing for variable references.
+It is very similar in concept to what `eshell-user-aliases-list' does
+for commands. Each member of this defines defines the name of a
+command, and the Lisp value to return for that variable if it is
+accessed via the syntax '$NAME'.
+
+If the value is a function, that function will be called with two
+arguments: the list of the indices that was used in the reference, and
+whether the user is requesting the length of the ultimate element.
+For example, a reference of '$NAME[10][20]' would result in the
+function for alias `NAME' being called (assuming it were aliased to a
+function), and the arguments passed to this function would be the list
+'(10 20)', and nil."
+ :type '(repeat (list string sexp
+ (choice (const :tag "Copy to environment" t)
+ (const :tag "Use only in Eshell" nil))))
+ :group 'eshell-var)
+
+(put 'eshell-variable-aliases-list 'risky-local-variable t)
+
+;;; Functions:
+
+(defun eshell-var-initialize ()
+ "Initialize the variable handle code."
+ ;; Break the association with our parent's environment. Otherwise,
+ ;; changing a variable will affect all of Emacs.
+ (set (make-local-variable 'process-environment) (eshell-copy-environment))
+
+ (define-key eshell-command-map [(meta ?v)] 'eshell-insert-envvar)
+
+ (set (make-local-variable 'eshell-special-chars-inside-quoting)
+ (append eshell-special-chars-inside-quoting '(?$)))
+ (set (make-local-variable 'eshell-special-chars-outside-quoting)
+ (append eshell-special-chars-outside-quoting '(?$)))
+
+ (make-local-hook 'eshell-parse-argument-hook)
+ (add-hook 'eshell-parse-argument-hook 'eshell-interpolate-variable t t)
+
+ (make-local-hook 'eshell-prepare-command-hook)
+ (add-hook 'eshell-prepare-command-hook
+ 'eshell-handle-local-variables nil t)
+
+ (when (eshell-using-module 'eshell-cmpl)
+ (make-local-hook 'pcomplete-try-first-hook)
+ (add-hook 'pcomplete-try-first-hook
+ 'eshell-complete-variable-reference nil t)
+ (add-hook 'pcomplete-try-first-hook
+ 'eshell-complete-variable-assignment nil t)))
+
+(defun eshell-handle-local-variables ()
+ "Allow for the syntax 'VAR=val <command> <args>'."
+ ;; strip off any null commands, which can only happen if a variable
+ ;; evaluates to nil, such as "$var x", where `var' is nil. The
+ ;; command name in that case becomes `x', for compatibility with
+ ;; most regular shells (the difference is that they do an
+ ;; interpolation pass before the argument parsing pass, but Eshell
+ ;; does both at the same time).
+ (while (and (not eshell-last-command-name)
+ eshell-last-arguments)
+ (setq eshell-last-command-name (car eshell-last-arguments)
+ eshell-last-arguments (cdr eshell-last-arguments)))
+ (let ((setvar "\\`\\([A-Za-z_][A-Za-z0-9_]*\\)=\\(.*\\)\\'")
+ (command (eshell-stringify eshell-last-command-name))
+ (args eshell-last-arguments))
+ ;; local variable settings (such as 'CFLAGS=-O2 make') are handled
+ ;; by making the whole command into a subcommand, and calling
+ ;; setenv immediately before the command is invoked. This means
+ ;; that 'BLAH=x cd blah' won't work exactly as expected, but that
+ ;; is by no means a typical use of local environment variables.
+ (if (and command (string-match setvar command))
+ (throw
+ 'eshell-replace-command
+ (list
+ 'eshell-as-subcommand
+ (append
+ (list 'progn)
+ (let ((l (list t)))
+ (while (string-match setvar command)
+ (nconc
+ l (list
+ (list 'setenv (match-string 1 command)
+ (match-string 2 command)
+ (= (length (match-string 2 command)) 0))))
+ (setq command (eshell-stringify (car args))
+ args (cdr args)))
+ (cdr l))
+ (list (list 'eshell-named-command
+ command (list 'quote args)))))))))
+
+(defun eshell-interpolate-variable ()
+ "Parse a variable interpolation.
+This function is explicit for adding to `eshell-parse-argument-hook'."
+ (when (and (eq (char-after) ?$)
+ (not (= (1+ (point)) (point-max))))
+ (forward-char)
+ (list 'eshell-escape-arg
+ (eshell-parse-variable))))
+
+(defun eshell/define (var-alias definition)
+ "Define an VAR-ALIAS using DEFINITION."
+ (if (not definition)
+ (setq eshell-variable-aliases-list
+ (delq (assoc var-alias eshell-variable-aliases-list)
+ eshell-variable-aliases-list))
+ (let ((def (assoc var-alias eshell-variable-aliases-list))
+ (alias-def
+ (list var-alias
+ (list 'quote (if (= (length definition) 1)
+ (car definition)
+ definition)))))
+ (if def
+ (setq eshell-variable-aliases-list
+ (delq (assoc var-alias eshell-variable-aliases-list)
+ eshell-variable-aliases-list)))
+ (setq eshell-variable-aliases-list
+ (cons alias-def
+ eshell-variable-aliases-list))))
+ nil)
+
+(defun eshell/export (&rest sets)
+ "This alias allows the 'export' command to act as bash users expect."
+ (while sets
+ (if (string-match "^\\([^=]+\\)=\\(.*\\)" (car sets))
+ (setenv (match-string 1 (car sets))
+ (match-string 2 (car sets))))
+ (setq sets (cdr sets))))
+
+(defun pcomplete/eshell-mode/export ()
+ "Completion function for Eshell's `export'."
+ (while (pcomplete-here
+ (if eshell-complete-export-definition
+ process-environment
+ (eshell-envvar-names)))))
+
+(defun eshell/setq (&rest args)
+ "Allow command-ish use of `setq'."
+ (let (last-value)
+ (while args
+ (let ((sym (intern (car args)))
+ (val (cadr args)))
+ (setq last-value (set sym val)
+ args (cddr args))))
+ last-value))
+
+(defun pcomplete/eshell-mode/setq ()
+ "Completion function for Eshell's `setq'."
+ (while (and (pcomplete-here (all-completions pcomplete-stub
+ obarray 'boundp))
+ (pcomplete-here))))
+
+(defun eshell/env (&rest args)
+ "Implemention of `env' in Lisp."
+ (eshell-init-print-buffer)
+ (eshell-eval-using-options
+ "env" args
+ '((?h "help" nil nil "show this usage screen")
+ :external "env"
+ :usage "<no arguments>")
+ (eshell-for setting (sort (eshell-environment-variables)
+ 'string-lessp)
+ (eshell-buffered-print setting "\n"))
+ (eshell-flush)))
+
+(defun eshell-insert-envvar (envvar-name)
+ "Insert ENVVAR-NAME into the current buffer at point."
+ (interactive
+ (list (read-envvar-name "Name of environment variable: " t)))
+ (insert-and-inherit "$" envvar-name))
+
+(defun eshell-envvar-names (&optional environment)
+ "Return a list of currently visible environment variable names."
+ (mapcar (function
+ (lambda (x)
+ (substring x 0 (string-match "=" x))))
+ (or environment process-environment)))
+
+(defun eshell-environment-variables ()
+ "Return a `process-environment', fully updated.
+This involves setting any variable aliases which affect the
+environment, as specified in `eshell-variable-aliases-list'."
+ (let ((process-environment (eshell-copy-environment)))
+ (eshell-for var-alias eshell-variable-aliases-list
+ (if (nth 2 var-alias)
+ (setenv (car var-alias)
+ (eshell-stringify
+ (or (eshell-get-variable (car var-alias)) "")))))
+ process-environment))
+
+(defun eshell-parse-variable ()
+ "Parse the next variable reference at point.
+The variable name could refer to either an environment variable, or a
+Lisp variable. The priority order depends on the setting of
+`eshell-prefer-lisp-variables'.
+
+Its purpose is to call `eshell-parse-variable-ref', and then to
+process any indices that come after the variable reference."
+ (let* ((get-len (when (eq (char-after) ?#)
+ (forward-char) t))
+ value indices)
+ (setq value (eshell-parse-variable-ref)
+ indices (and (not (eobp))
+ (eq (char-after) ?\[)
+ (eshell-parse-indices))
+ value (list 'let
+ (list (list 'indices
+ (list 'quote indices)))
+ value))
+ (if get-len
+ (list 'length value)
+ value)))
+
+(defun eshell-parse-variable-ref ()
+ "Eval a variable reference.
+Returns a Lisp form which, if evaluated, will return the value of the
+variable.
+
+Possible options are:
+
+ NAME an environment or Lisp variable value
+ <LONG-NAME> disambiguates the length of the name
+ {COMMAND} result of command is variable's value
+ (LISP-FORM) result of Lisp form is variable's value"
+ (let (end)
+ (cond
+ ((eq (char-after) ?{)
+ (let ((end (eshell-find-delimiter ?\{ ?\})))
+ (if (not end)
+ (throw 'eshell-incomplete ?\{)
+ (prog1
+ (list 'eshell-convert
+ (list 'eshell-command-to-value
+ (list 'eshell-as-subcommand
+ (eshell-parse-command
+ (cons (1+ (point)) end)))))
+ (goto-char (1+ end))))))
+ ((memq (char-after) '(?\' ?\"))
+ (let ((name (if (eq (char-after) ?\')
+ (eshell-parse-literal-quote)
+ (eshell-parse-double-quote))))
+ (if name
+ (list 'eshell-get-variable (eval name) 'indices))))
+ ((eq (char-after) ?<)
+ (let ((end (eshell-find-delimiter ?\< ?\>)))
+ (if (not end)
+ (throw 'eshell-incomplete ?\<)
+ (let* ((temp (make-temp-name temporary-file-directory))
+ (cmd (concat (buffer-substring (1+ (point)) end)
+ " > " temp)))
+ (prog1
+ (list
+ 'let (list (list 'eshell-current-handles
+ (list 'eshell-create-handles temp
+ (list 'quote 'overwrite))))
+ (list
+ 'progn
+ (list 'eshell-as-subcommand
+ (eshell-parse-command cmd))
+ (list 'ignore
+ (list 'nconc 'eshell-this-command-hook
+ (list 'list
+ (list 'function
+ (list 'lambda nil
+ (list 'delete-file temp))))))
+ (list 'quote temp)))
+ (goto-char (1+ end)))))))
+ ((eq (char-after) ?\()
+ (condition-case err
+ (list 'eshell-command-to-value
+ (list 'eshell-lisp-command
+ (list 'quote (read (current-buffer)))))
+ (end-of-file
+ (throw 'eshell-incomplete ?\())))
+ ((assoc (char-to-string (char-after))
+ eshell-variable-aliases-list)
+ (forward-char)
+ (list 'eshell-get-variable
+ (char-to-string (char-before)) 'indices))
+ ((looking-at eshell-variable-name-regexp)
+ (prog1
+ (list 'eshell-get-variable (match-string 0) 'indices)
+ (goto-char (match-end 0))))
+ (t
+ (error "Invalid variable reference")))))
+
+(eshell-deftest var interp-cmd
+ "Interpolate command result"
+ (eshell-command-result-p "+ ${+ 1 2} 3" "6\n"))
+
+(eshell-deftest var interp-lisp
+ "Interpolate Lisp form evalution"
+ (eshell-command-result-p "+ $(+ 1 2) 3" "6\n"))
+
+(eshell-deftest var interp-concat
+ "Interpolate and concat command"
+ (eshell-command-result-p "+ ${+ 1 2}3 3" "36\n"))
+
+(eshell-deftest var interp-concat-lisp
+ "Interpolate and concat Lisp form"
+ (eshell-command-result-p "+ $(+ 1 2)3 3" "36\n"))
+
+(eshell-deftest var interp-concat2
+ "Interpolate and concat two commands"
+ (eshell-command-result-p "+ ${+ 1 2}${+ 1 2} 3" "36\n"))
+
+(eshell-deftest var interp-concat-lisp2
+ "Interpolate and concat two Lisp forms"
+ (eshell-command-result-p "+ $(+ 1 2)$(+ 1 2) 3" "36\n"))
+
+(defun eshell-parse-indices ()
+ "Parse and return a list of list of indices."
+ (let (indices)
+ (while (eq (char-after) ?\[)
+ (let ((end (eshell-find-delimiter ?\[ ?\])))
+ (if (not end)
+ (throw 'eshell-incomplete ?\[)
+ (forward-char)
+ (let (eshell-glob-function)
+ (setq indices (cons (eshell-parse-arguments (point) end)
+ indices)))
+ (goto-char (1+ end)))))
+ (nreverse indices)))
+
+(defun eshell-get-variable (name &optional indices)
+ "Get the value for the variable NAME."
+ (let* ((alias (assoc name eshell-variable-aliases-list))
+ (var (if alias
+ (cadr alias)
+ name)))
+ (if (and alias (functionp var))
+ (funcall var indices)
+ (eshell-apply-indices
+ (cond
+ ((stringp var)
+ (let ((sym (intern-soft var)))
+ (if (and sym (boundp sym)
+ (or eshell-prefer-lisp-variables
+ (not (getenv var))))
+ (symbol-value sym)
+ (getenv var))))
+ ((symbolp var)
+ (symbol-value var))
+ (t
+ (error "Unknown variable `%s'" (eshell-stringify var))))
+ indices))))
+
+(defun eshell-apply-indices (value indices)
+ "Apply to VALUE all of the given INDICES, returning the sub-result.
+The format of INDICES is:
+
+ ((INT-OR-NAME-OR-OTHER INT-OR-NAME INT-OR-NAME ...)
+ ...)
+
+Each member of INDICES represents a level of nesting. If the first
+member of a sublist is not an integer or name, and the value it's
+reference is a string, that will be used as the regexp with which is
+to divide the string into sub-parts. The default is whitespace.
+Otherwise, each INT-OR-NAME refers to an element of the list value.
+Integers imply a direct index, and names, an associate lookup using
+`assoc'.
+
+For example, to retrieve the second element of a user's record in
+'/etc/passwd', the variable reference would look like:
+
+ ${egrep johnw /etc/passwd}[: 2]"
+ (while indices
+ (let ((refs (car indices)))
+ (when (stringp value)
+ (let (separator)
+ (if (not (or (not (stringp (caar indices)))
+ (string-match
+ (concat "^" eshell-variable-name-regexp "$")
+ (caar indices))))
+ (setq separator (caar indices)
+ refs (cdr refs)))
+ (setq value
+ (mapcar 'eshell-convert
+ (split-string value separator)))))
+ (cond
+ ((< (length refs) 0)
+ (error "Illegal array variable index: %s"
+ (eshell-stringify refs)))
+ ((= (length refs) 1)
+ (setq value (eshell-index-value value (car refs))))
+ (t
+ (let ((new-value (list t)))
+ (while refs
+ (nconc new-value
+ (list (eshell-index-value value
+ (car refs))))
+ (setq refs (cdr refs)))
+ (setq value (cdr new-value))))))
+ (setq indices (cdr indices)))
+ value)
+
+(defun eshell-index-value (value index)
+ "Reference VALUE using the given INDEX."
+ (if (stringp index)
+ (cdr (assoc index value))
+ (cond
+ ((ring-p value)
+ (if (> index (ring-length value))
+ (error "Index exceeds length of ring")
+ (ring-ref value index)))
+ ((listp value)
+ (if (> index (length value))
+ (error "Index exceeds length of list")
+ (nth index value)))
+ ((vectorp value)
+ (if (> index (length value))
+ (error "Index exceeds length of vector")
+ (aref value index)))
+ (t
+ (error "Invalid data type for indexing")))))
+
+;;;_* Variable name completion
+
+(defun eshell-complete-variable-reference ()
+ "If there is a variable reference, complete it."
+ (let ((arg (pcomplete-actual-arg)) index)
+ (when (setq index
+ (string-match
+ (concat "\\$\\(" eshell-variable-name-regexp
+ "\\)?\\'") arg))
+ (setq pcomplete-stub (substring arg (1+ index)))
+ (throw 'pcomplete-completions (eshell-variables-list)))))
+
+(defun eshell-variables-list ()
+ "Generate list of applicable variables."
+ (let ((argname pcomplete-stub)
+ completions)
+ (eshell-for alias eshell-variable-aliases-list
+ (if (string-match (concat "^" argname) (car alias))
+ (setq completions (cons (car alias) completions))))
+ (sort
+ (append
+ (mapcar
+ (function
+ (lambda (varname)
+ (let ((value (eshell-get-variable varname)))
+ (if (and value
+ (stringp value)
+ (file-directory-p value))
+ (concat varname (char-to-string directory-sep-char))
+ varname))))
+ (eshell-envvar-names (eshell-environment-variables)))
+ (all-completions argname obarray 'boundp)
+ completions)
+ 'string-lessp)))
+
+(defun eshell-complete-variable-assignment ()
+ "If there is a variable assignment, allow completion of entries."
+ (let ((arg (pcomplete-actual-arg)) pos)
+ (when (string-match (concat "\\`" eshell-variable-name-regexp "=") arg)
+ (setq pos (match-end 0))
+ (if (string-match "\\(:\\)[^:]*\\'" arg)
+ (setq pos (match-end 1)))
+ (setq pcomplete-stub (substring arg pos))
+ (throw 'pcomplete-completions (pcomplete-entries)))))
+
+;;; Code:
+
+;;; esh-var.el ends here
--- /dev/null
+;;; eshell --- the Emacs command shell
+
+;; Copyright (C) 1999, 2000 Free Sofware Foundation
+
+;; Author: John Wiegley <johnw@gnu.org>
+;; Keywords: processes
+;; X-URL: http://www.emacs.org/~johnw/eshell.html
+
+;; 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 2, 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+(provide 'eshell)
+
+(eval-when-compile (require 'esh-maint))
+
+(defgroup eshell nil
+ "Eshell is a command shell implemented entirely in Emacs Lisp. It
+invokes no external processes beyond those requested by the user. It
+is intended to be a functional replacement for command shells such as
+bash, zsh, rc, 4dos; since Emacs itself is capable of handling most of
+the tasks accomplished by such tools."
+ :tag "The Emacs shell"
+ :link '(info-link "(eshell.info)The Emacs shell")
+ :group 'applications)
+
+;;; 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
+;; @ Psuedo-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...
+;;
+;;;_* Eshell is free software
+;;
+;; Eshell 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 2, or (at your option)
+;; any later version.
+;;
+;; This program 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 Eshell; see the file COPYING. If not, write to the Free
+;; Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+;; 02111-1307, USA.
+;;
+;;;_* How to begin
+;;
+;; To start using Eshell, add the following to your .emacs file:
+;;
+;; (load "eshell-auto")
+;;
+;; This will define all of the necessary autoloads.
+;;
+;; Now type `M-x eshell'. See the INSTALL file for full installation
+;; instructions.
+;;
+;;;_* 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
+
+;;;_* User Options
+;;
+;; The following user options modify the behavior of Eshell overall.
+
+(load "esh-util" nil t)
+
+(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 "~/.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)))
+
+(defcustom eshell-prefer-to-shell nil
+ "*If non-nil, \\[shell-command] will use Eshell instead of shell-mode."
+ :set (lambda (symbol value)
+ ;; modifying the global keymap directly is odious, but how
+ ;; else to achieve the takeover?
+ (if value
+ (progn
+ (define-key global-map [(meta ?!)] 'eshell-command)
+;;; (define-key global-map [(meta ?|)] 'eshell-command-on-region)
+ )
+ (define-key global-map [(meta ?!)] 'shell-command)
+;;; (define-key global-map [(meta ?|)] 'shell-command-on-region)
+ )
+ (set symbol value))
+ :type 'boolean
+ :require 'eshell
+ :group 'eshell)
+
+;;;_* 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 new session is always created if the the prefix
+argument ARG is specified. Returns the buffer selected (or created)."
+ (interactive "P")
+ (assert eshell-buffer-name)
+ (let ((buf (if arg
+ (generate-new-buffer eshell-buffer-name)
+ (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 (fboundp 'eshell-mode)
+ (error "`eshell-auto' must be loaded before Eshell can be used"))
+ (unless (eq major-mode 'eshell-mode)
+ (eshell-mode))
+ (assert (eq major-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))
+
+;;;###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)
+ (setq arg current-prefix-arg)
+ (unwind-protect
+ (let ((eshell-non-interactive-p t))
+ (add-hook 'minibuffer-setup-hook 'eshell-mode)
+ (add-hook 'eshell-mode-hook 'eshell-return-exits-minibuffer)
+ (setq command (read-from-minibuffer "Emacs shell command: ")))
+ (remove-hook 'eshell-mode-hook 'eshell-return-exits-minibuffer)
+ (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
+ (require 'esh-mode)
+ (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 (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
+ (require 'esh-mode)
+ (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
+;;
+;; Since Eshell has not yet been in use by a wide audience, and since
+;; the number of possible configurations is quite large, it is certain
+;; that many bugs slipped past the rigors of testing it was put
+;; through. 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.
+
+(defconst eshell-report-bug-address "johnw@gnu.org"
+ "E-mail address to send Eshell bug reports to.")
+
+;;;###autoload
+(defun eshell-report-bug (topic)
+ "Report a bug in Eshell.
+Prompts for the TOPIC. Leaves you in a mail buffer.
+Please include any configuration details that might be involved."
+ (interactive "sBug Subject: ")
+ (compose-mail eshell-report-bug-address topic)
+ (goto-char (point-min))
+ (re-search-forward (concat "^" (regexp-quote mail-header-separator) "$"))
+ (forward-line 1)
+ (let ((signature (buffer-substring (point) (point-max))))
+ ;; Discourage users from writing non-English text.
+ (set-buffer-multibyte nil)
+ (delete-region (point) (point-max))
+ (insert signature)
+ (backward-char (length signature)))
+ (insert "emacs-version: " (emacs-version))
+ (insert "\n\nThere appears to be a bug in Eshell.\n\n"
+ "Please describe exactly what actions "
+ "triggered the bug and the precise\n"
+ "symptoms of the bug:\n\n")
+ ;; This is so the user has to type something in order to send
+ ;; the report easily.
+ (use-local-map (nconc (make-sparse-keymap) (current-local-map))))
+
+;;; 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)
+
+;;; eshell.el ends here
--- /dev/null
+;;; pcomplete --- programmable completion
+
+;; Copyright (C) 1999, 2000 Free Sofware Foundation
+
+;; Author: John Wiegley <johnw@gnu.org>
+;; Keywords: processes
+;; X-URL: http://www.emacs.org/~johnw/emacs.html
+
+;; 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 2, 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; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+;;; Commentary:
+
+;; This module provides a programmable completion facility using
+;; "completion functions". Each completion function is responsible
+;; for producing a list of possible completions relevant to the current
+;; argument position.
+;;
+;; To use pcomplete with shell-mode, for example, you will need the
+;; following in your .emacs file:
+;;
+;; (load "pcmpl-auto")
+;; (add-hook 'shell-mode-hook 'pcomplete-shell-setup)
+;;
+;; Most of the code below simply provides support mechanisms for
+;; writing completion functions. Completion functions themselves are
+;; very easy to write. They have few requirements beyond those of
+;; regular Lisp functions.
+;;
+;; Consider the following example, which will complete against
+;; filenames for the first two arguments, and directories for all
+;; remaining arguments:
+;;
+;; (defun pcomplete/my-command ()
+;; (pcomplete-here (pcomplete-entries))
+;; (pcomplete-here (pcomplete-entries))
+;; (while (pcomplete-here (pcomplete-dirs))))
+;;
+;; Here are the requirements for completion functions:
+;;
+;; @ They must be called "pcomplete/MAJOR-MODE/NAME", or
+;; "pcomplete/NAME". This is how they are looked up, using the NAME
+;; specified in the command argument (the argument in first
+;; position).
+;;
+;; @ They must be callable with no arguments.
+;;
+;; @ Their return value is ignored. If they actually return normally,
+;; it means no completions were available.
+;;
+;; @ In order to provide completions, they must throw the tag
+;; `pcomplete-completions'. The value must be the list of possible
+;; completions for the final argument.
+;;
+;; @ To simplify completion function logic, the tag `pcompleted' may
+;; be thrown with a value of nil in order to abort the function. It
+;; means that there were no completions available.
+;;
+;; When a completion function is called, the variable `pcomplete-args'
+;; is in scope, and contains all of the arguments specified on the
+;; command line. The variable `pcomplete-last' is the index of the
+;; last argument in that list.
+;;
+;; The variable `pcomplete-index' is used by the completion code to
+;; know which argument the completion function is currently examining.
+;; It always begins at 1, meaning the first argument after the command
+;; name.
+;;
+;; To facilitate writing completion logic, a special macro,
+;; `pcomplete-here', has been provided which does several things:
+;;
+;; 1. It will throw `pcompleted' (with a value of nil) whenever
+;; `pcomplete-index' exceeds `pcomplete-last'.
+;;
+;; 2. It will increment `pcomplete-index' if the final argument has
+;; not been reached yet.
+;;
+;; 3. It will evaluate the form passed to it, and throw the result
+;; using the `pcomplete-completions' tag, if it is called when
+;; `pcomplete-index' is pointing to the final argument.
+;;
+;; Sometimes a completion function will want to vary the possible
+;; completions for an argument based on the previous one. To
+;; facilitate tests like this, the function `pcomplete-test' and
+;; `pcomplete-match' are provided. Called with one argument, they
+;; test the value of the previous command argument. Otherwise, a
+;; relative index may be given as an optional second argument, where 0
+;; refers to the current argument, 1 the previous, 2 the one before
+;; that, etc. The symbols `first' and `last' specify absolute
+;; offsets.
+;;
+;; Here is an example which will only complete against directories for
+;; the second argument if the first argument is also a directory:
+;;
+;; (defun pcomplete/example ()
+;; (pcomplete-here (pcomplete-entries))
+;; (if (pcomplete-test 'file-directory-p)
+;; (pcomplete-here (pcomplete-dirs))
+;; (pcomplete-here (pcomplete-entries))))
+;;
+;; For generating completion lists based on directory contents, see
+;; the functions `pcomplete-entries', `pcomplete-dirs',
+;; `pcomplete-executables' and `pcomplete-all-entries'.
+;;
+;; Consult the documentation for `pcomplete-here' for information
+;; about its other arguments.
+
+;;; Code:
+
+(provide 'pcomplete)
+
+(defgroup pcomplete nil
+ "Programmable completion."
+ :group 'processes)
+
+;;; User Variables:
+
+(defcustom pcomplete-file-ignore nil
+ "*A regexp of filenames to be disregarded during file completion."
+ :type 'regexp
+ :group 'pcomplete)
+
+(defcustom pcomplete-dir-ignore nil
+ "*A regexp of names to be disregarded during directory completion."
+ :type 'regexp
+ :group 'pcomplete)
+
+(defcustom pcomplete-ignore-case (memq system-type '(ms-dos windows-nt))
+ "*If non-nil, ignore case when doing filename completion."
+ :type 'boolean
+ :group 'pcomplete)
+
+(defcustom pcomplete-autolist nil
+ "*If non-nil, automatically list possibilities on partial completion.
+This mirrors the optional behavior of tcsh."
+ :type 'boolean
+ :group 'pcomplete)
+
+(defcustom pcomplete-suffix-list (list directory-sep-char ?:)
+ "*A list of characters which constitute a proper suffix."
+ :type '(repeat character)
+ :group 'pcomplete)
+
+(defcustom pcomplete-recexact nil
+ "*If non-nil, use shortest completion if characters cannot be added.
+This mirrors the optional behavior of tcsh.
+
+A non-nil value is useful if `pcomplete-autolist' is non-nil too."
+ :type 'boolean
+ :group 'pcomplete)
+
+(defcustom pcomplete-arg-quote-list nil
+ "*List of characters to quote when completing an argument."
+ :type '(choice (repeat character)
+ (const :tag "Don't quote" nil))
+ :group 'pcomplete)
+
+(defcustom pcomplete-quote-arg-hook nil
+ "*A hook which is run to quote a character within a filename.
+Each function is passed both the filename to be quoted, and the index
+to be considered. If the function wishes to provide an alternate
+quoted form, it need only return the replacement string. If no
+function provides a replacement, quoting shall proceed as normal,
+using a backslash to quote any character which is a member of
+`pcomplete-arg-quote-list'."
+ :type 'hook
+ :group 'pcomplete)
+
+(defcustom pcomplete-man-function 'man
+ "*A function to that will be called to display a manual page.
+It will be passed the name of the command to document."
+ :type 'function
+ :group 'pcomplete)
+
+(defcustom pcomplete-compare-entry-function 'string-lessp
+ "*This function is used to order file entries for completion.
+The behavior of most all shells is to sort alphabetically."
+ :type '(radio (function-item string-lessp)
+ (function-item file-newer-than-file-p)
+ (function :tag "Other"))
+ :group 'pcomplete)
+
+(defcustom pcomplete-help nil
+ "*A string or function (or nil) used for context-sensitive help.
+If a string, it should name an Info node that will be jumped to.
+If non-nil, it must a sexp that will be evaluated, and whose
+result will be shown in the minibuffer.
+If nil, the function `pcomplete-man-function' will be called with the
+current command argument."
+ :type '(choice string sexp (const :tag "Use man page" nil))
+ :group 'pcomplete)
+
+(defcustom pcomplete-expand-before-complete nil
+ "*If non-nil, expand the current argument before completing it.
+This means that typing something such as '$HOME/bi' followed by
+\\[pcomplete-argument] will cause the variable reference to be
+resolved first, and the resultant value that will be completed against
+to be inserted in the buffer. Note that exactly what gets expanded
+and how is entirely up to the behavior of the
+`pcomplete-parse-arguments-function'."
+ :type 'boolean
+ :group 'pcomplete)
+
+(defcustom pcomplete-parse-arguments-function
+ 'pcomplete-parse-buffer-arguments
+ "*A function to call to parse the current line's arguments.
+It should be called with no parameters, and with point at the position
+of the argument that is to be completed.
+
+It must either return nil, or a cons cell of the form:
+
+ ((ARG...) (BEG-POS...))
+
+The two lists must be identical in length. The first gives the final
+value of each command line argument (which need not match the textual
+representation of that argument), and BEG-POS gives the beginning
+position of each argument, as it is seen by the user. The establishes
+a relationship between the fully resolved value of the argument, and
+the textual representation of the argument."
+ :type 'function
+ :group 'pcomplete)
+
+(defcustom pcomplete-cycle-completions t
+ "*If non-nil, hitting the TAB key cycles through the completion list.
+Typical Emacs behavior is to complete as much as possible, then pause
+waiting for further input. Then if TAB is hit again, show a list of
+possible completions. When `pcomplete-cycle-completions' is non-nil,
+it acts more like zsh or 4nt, showing the first maximal match first,
+followed by any further matches on each subsequent pressing of the TAB
+key. \\[pcomplete-list] is the key to press if the user wants to see
+the list of possible completions."
+ :type 'boolean
+ :group 'pcomplete)
+
+(defcustom pcomplete-cycle-cutoff-length 5
+ "*If the number of completions is greater than this, don't cycle.
+This variable is a compromise between the traditional Emacs style of
+completion, and the \"cycling\" style. Basically, if there are more
+than this number of completions possible, don't automatically pick the
+first one and then expect the user to press TAB to cycle through them.
+Typically, when there are a large number of completion possibilities,
+the user wants to see them in a list buffer so that they can know what
+options are available. But if the list is small, it means the user
+has already entered enough input to disambiguate most of the
+possibilities, and therefore they are probably most interested in
+cycling through the candidates. Set this value to nil if you want
+cycling to always be enabled."
+ :type '(choice integer (const :tag "Always cycle" nil))
+ :group 'pcomplete)
+
+(defcustom pcomplete-restore-window-delay 1
+ "*The number of seconds to wait before restoring completion windows.
+Once the completion window has been displayed, if the user then goes
+on to type something else, that completion window will be removed from
+the display (actually, the original window configuration before it was
+displayed will be restored), after this many seconds of idle time. If
+set to nil, completion windows will be left on second until the user
+removes them manually. If set to 0, they will disappear immediately
+after the user enters a key other than TAB."
+ :type '(choice integer (const :tag "Never restore" nil))
+ :group 'pcomplete)
+
+(defcustom pcomplete-try-first-hook nil
+ "*A list of functions which are called before completing an argument.
+This can be used, for example, for completing things which might apply
+to all arguments, such as variable names after a $."
+ :type 'hook
+ :group 'pcomplete)
+
+(defcustom pcomplete-command-completion-function
+ (function
+ (lambda ()
+ (pcomplete-here (pcomplete-executables))))
+ "*Function called for completing the initial command argument."
+ :type 'function
+ :group 'pcomplete)
+
+(defcustom pcomplete-command-name-function 'pcomplete-command-name
+ "*Function called for determining the current command name."
+ :type 'function
+ :group 'pcomplete)
+
+(defcustom pcomplete-default-completion-function
+ (function
+ (lambda ()
+ (while (pcomplete-here (pcomplete-entries)))))
+ "*Function called when no completion rule can be found.
+This function is used to generate completions for every argument."
+ :type 'function
+ :group 'pcomplete)
+
+;;; Internal Variables:
+
+;; for cycling completion support
+(defvar pcomplete-current-completions nil)
+(defvar pcomplete-last-completion-length)
+(defvar pcomplete-last-completion-stub)
+(defvar pcomplete-last-completion-raw)
+(defvar pcomplete-last-window-config nil)
+(defvar pcomplete-window-restore-timer nil)
+
+(make-variable-buffer-local 'pcomplete-current-completions)
+(make-variable-buffer-local 'pcomplete-last-completion-length)
+(make-variable-buffer-local 'pcomplete-last-completion-stub)
+(make-variable-buffer-local 'pcomplete-last-completion-raw)
+(make-variable-buffer-local 'pcomplete-last-window-config)
+(make-variable-buffer-local 'pcomplete-window-restore-timer)
+
+;; used for altering pcomplete's behavior. These global variables
+;; should always be nil.
+(defvar pcomplete-show-help nil)
+(defvar pcomplete-show-list nil)
+(defvar pcomplete-expand-only-p nil)
+
+;;; User Functions:
+
+;;;###autoload
+(defun pcomplete ()
+ "Support extensible programmable completion.
+To use this function, just bind the TAB key to it, or add it to your
+completion functions list (it should occur fairly early in the list)."
+ (interactive)
+ (if (and (interactive-p)
+ pcomplete-cycle-completions
+ pcomplete-current-completions
+ (memq last-command '(pcomplete
+ pcomplete-expand-and-complete
+ pcomplete-reverse)))
+ (progn
+ (delete-backward-char pcomplete-last-completion-length)
+ (if (eq this-command 'pcomplete-reverse)
+ (progn
+ (setq pcomplete-current-completions
+ (cons (car (last pcomplete-current-completions))
+ pcomplete-current-completions))
+ (setcdr (last pcomplete-current-completions 2) nil))
+ (nconc pcomplete-current-completions
+ (list (car pcomplete-current-completions)))
+ (setq pcomplete-current-completions
+ (cdr pcomplete-current-completions)))
+ (pcomplete-insert-entry pcomplete-last-completion-stub
+ (car pcomplete-current-completions)
+ nil pcomplete-last-completion-raw))
+ (setq pcomplete-current-completions nil
+ pcomplete-last-completion-raw nil)
+ (catch 'pcompleted
+ (let* ((pcomplete-stub)
+ pcomplete-seen pcomplete-norm-func
+ pcomplete-args pcomplete-last pcomplete-index
+ (pcomplete-autolist pcomplete-autolist)
+ (pcomplete-suffix-list pcomplete-suffix-list)
+ (completions (pcomplete-completions))
+ (result (pcomplete-do-complete pcomplete-stub completions)))
+ (and result
+ (not (eq (car result) 'listed))
+ (cdr result)
+ (pcomplete-insert-entry pcomplete-stub (cdr result)
+ (memq (car result)
+ '(sole shortest))
+ pcomplete-last-completion-raw))))))
+
+;;;###autoload
+(defun pcomplete-reverse ()
+ "If cycling completion is in use, cycle backwards."
+ (interactive)
+ (call-interactively 'pcomplete))
+
+;;;###autoload
+(defun pcomplete-expand-and-complete ()
+ "Expand the textual value of the current argument.
+This will modify the current buffer."
+ (interactive)
+ (let ((pcomplete-expand-before-complete t))
+ (pcomplete)))
+
+;;;###autoload
+(defun pcomplete-continue ()
+ "Complete without reference to any cycling completions."
+ (interactive)
+ (setq pcomplete-current-completions nil
+ pcomplete-last-completion-raw nil)
+ (call-interactively 'pcomplete))
+
+;;;###autoload
+(defun pcomplete-expand ()
+ "Expand the textual value of the current argument.
+This will modify the current buffer."
+ (interactive)
+ (let ((pcomplete-expand-before-complete t)
+ (pcomplete-expand-only-p t))
+ (pcomplete)
+ (when (and pcomplete-current-completions
+ (> (length pcomplete-current-completions) 0))
+ (delete-backward-char pcomplete-last-completion-length)
+ (while pcomplete-current-completions
+ (unless (pcomplete-insert-entry
+ "" (car pcomplete-current-completions) t
+ pcomplete-last-completion-raw)
+ (insert-and-inherit " "))
+ (setq pcomplete-current-completions
+ (cdr pcomplete-current-completions))))))
+
+;;;###autoload
+(defun pcomplete-help ()
+ "Display any help information relative to the current argument."
+ (interactive)
+ (let ((pcomplete-show-help t))
+ (pcomplete)))
+
+;;;###autoload
+(defun pcomplete-list ()
+ "Show the list of possible completions for the current argument."
+ (interactive)
+ (when (and pcomplete-cycle-completions
+ pcomplete-current-completions
+ (eq last-command 'pcomplete-argument))
+ (delete-backward-char pcomplete-last-completion-length)
+ (setq pcomplete-current-completions nil
+ pcomplete-last-completion-raw nil))
+ (let ((pcomplete-show-list t))
+ (pcomplete)))
+
+;;; Internal Functions:
+
+;; argument handling
+
+;; for the sake of the bye-compiler, when compiling other files that
+;; contain completion functions
+(defvar pcomplete-args nil)
+(defvar pcomplete-begins nil)
+(defvar pcomplete-last nil)
+(defvar pcomplete-index nil)
+(defvar pcomplete-stub nil)
+(defvar pcomplete-seen nil)
+(defvar pcomplete-norm-func nil)
+
+(defun pcomplete-arg (&optional index offset)
+ "Return the textual content of the INDEXth argument.
+INDEX is based from the current processing position. If INDEX is
+positive, values returned are closer to the command argument; if
+negative, they are closer to the last argument. If the INDEX is
+outside of the argument list, nil is returned. The default value for
+INDEX is 0, meaning the current argument being examined.
+
+The special indices `first' and `last' may be used to access those
+parts of the list.
+
+The OFFSET argument is added to/taken away from the index that will be
+used. This is really only useful with `first' and `last', for
+accessing absolute argument positions."
+ (setq index
+ (if (eq index 'first)
+ 0
+ (if (eq index 'last)
+ pcomplete-last
+ (- pcomplete-index (or index 0)))))
+ (if offset
+ (setq index (+ index offset)))
+ (nth index pcomplete-args))
+
+(defun pcomplete-begin (&optional index offset)
+ "Return the beginning position of the INDEXth argument.
+See the documentation for `pcomplete-arg'."
+ (setq index
+ (if (eq index 'first)
+ 0
+ (if (eq index 'last)
+ pcomplete-last
+ (- pcomplete-index (or index 0)))))
+ (if offset
+ (setq index (+ index offset)))
+ (nth index pcomplete-begins))
+
+(defsubst pcomplete-actual-arg (&optional index offset)
+ "Return the actual text representation of the last argument.
+This different from `pcomplete-arg', which returns the textual value
+that the last argument evaluated to. This function returns what the
+user actually typed in."
+ (buffer-substring (pcomplete-begin index offset) (point)))
+
+(defsubst pcomplete-next-arg ()
+ "Move the various pointers to the next argument."
+ (setq pcomplete-index (1+ pcomplete-index)
+ pcomplete-stub (pcomplete-arg))
+ (if (> pcomplete-index pcomplete-last)
+ (progn
+ (message "No completions")
+ (throw 'pcompleted nil))))
+
+(defun pcomplete-command-name ()
+ "Return the command name of the first argument."
+ (file-name-nondirectory (pcomplete-arg 'first)))
+
+(defun pcomplete-match (regexp &optional index offset start)
+ "Like `string-match', but on the current completion argument."
+ (let ((arg (pcomplete-arg (or index 1) offset)))
+ (if arg
+ (string-match regexp arg start)
+ (throw 'pcompleted nil))))
+
+(defun pcomplete-match-string (which &optional index offset)
+ "Like `string-match', but on the current completion argument."
+ (let ((arg (pcomplete-arg (or index 1) offset)))
+ (if arg
+ (match-string which arg)
+ (throw 'pcompleted nil))))
+
+(defalias 'pcomplete-match-beginning 'match-beginning)
+(defalias 'pcomplete-match-end 'match-end)
+
+(defsubst pcomplete--test (pred arg)
+ "Perform a programmable completion predicate match."
+ (and pred
+ (cond ((eq pred t) t)
+ ((functionp pred)
+ (funcall pred arg))
+ ((stringp pred)
+ (string-match (concat "^" pred "$") arg)))
+ pred))
+
+(defun pcomplete-test (predicates &optional index offset)
+ "Predicates to test the current programmable argument with."
+ (let ((arg (pcomplete-arg (or index 1) offset)))
+ (unless (null predicates)
+ (if (not (listp predicates))
+ (pcomplete--test predicates arg)
+ (let ((pred predicates)
+ found)
+ (while (and pred (not found))
+ (setq found (pcomplete--test (car pred) arg)
+ pred (cdr pred)))
+ found)))))
+
+(defun pcomplete-parse-buffer-arguments ()
+ "Parse whitespace separated arguments in the current region."
+ (let ((begin (point-min))
+ (end (point-max))
+ begins args)
+ (save-excursion
+ (goto-char begin)
+ (while (< (point) end)
+ (skip-chars-forward " \t\n")
+ (setq begins (cons (point) begins))
+ (skip-chars-forward "^ \t\n")
+ (setq args (cons (buffer-substring-no-properties
+ (car begins) (point))
+ args)))
+ (cons (reverse args) (reverse begins)))))
+
+;;;###autoload
+(defun pcomplete-comint-setup (completef-sym)
+ "Setup a comint buffer to use pcomplete.
+COMPLETEF-SYM should be the symbol where the
+dynamic-complete-functions are kept. For comint mode itself, this is
+`comint-dynamic-complete-functions'."
+ (set (make-local-variable 'pcomplete-parse-arguments-function)
+ 'pcomplete-parse-comint-arguments)
+ (make-local-variable completef-sym)
+ (let ((elem (memq 'comint-dynamic-complete-filename
+ (symbol-value completef-sym))))
+ (if elem
+ (setcar elem 'pcomplete)
+ (nconc (symbol-value completef-sym)
+ (list 'pcomplete)))))
+
+;;;###autoload
+(defun pcomplete-shell-setup ()
+ "Setup shell-mode to use pcomplete."
+ (pcomplete-comint-setup 'shell-dynamic-complete-functions))
+
+(defun pcomplete-parse-comint-arguments ()
+ "Parse whitespace separated arguments in the current region."
+ (let ((begin (save-excursion (comint-bol nil) (point)))
+ (end (point))
+ begins args)
+ (save-excursion
+ (goto-char begin)
+ (while (< (point) end)
+ (skip-chars-forward " \t\n")
+ (setq begins (cons (point) begins))
+ (let ((skip t))
+ (while skip
+ (skip-chars-forward "^ \t\n")
+ (if (eq (char-before) ?\\)
+ (skip-chars-forward " \t\n")
+ (setq skip nil))))
+ (setq args (cons (buffer-substring-no-properties
+ (car begins) (point))
+ args)))
+ (cons (reverse args) (reverse begins)))))
+
+(defun pcomplete-parse-arguments (&optional expand-p)
+ "Parse the command line arguments. Most completions need this info."
+ (let ((results (funcall pcomplete-parse-arguments-function)))
+ (when results
+ (setq pcomplete-args (or (car results) (list ""))
+ pcomplete-begins (or (cdr results) (list (point)))
+ pcomplete-last (1- (length pcomplete-args))
+ pcomplete-index 0
+ pcomplete-stub (pcomplete-arg 'last))
+ (let ((begin (pcomplete-begin 'last)))
+ (if (and pcomplete-cycle-completions
+ (listp pcomplete-stub)
+ (not pcomplete-expand-only-p))
+ (let* ((completions pcomplete-stub)
+ (common-stub (car completions))
+ (c completions)
+ (len (length common-stub)))
+ (while (and c (> len 0))
+ (while (and (> len 0)
+ (not (string=
+ (substring common-stub 0 len)
+ (substring (car c) 0
+ (min (length (car c))
+ len)))))
+ (setq len (1- len)))
+ (setq c (cdr c)))
+ (setq pcomplete-stub (substring common-stub 0 len)
+ pcomplete-autolist t)
+ (when (and begin (not pcomplete-show-list))
+ (delete-region begin (point))
+ (pcomplete-insert-entry "" pcomplete-stub))
+ (throw 'pcomplete-completions completions))
+ (when expand-p
+ (if (stringp pcomplete-stub)
+ (when begin
+ (delete-region begin (point))
+ (insert-and-inherit pcomplete-stub))
+ (if (and (listp pcomplete-stub)
+ pcomplete-expand-only-p)
+ ;; this is for the benefit of `pcomplete-expand'
+ (setq pcomplete-last-completion-length (- (point) begin)
+ pcomplete-current-completions pcomplete-stub)
+ (error "Cannot expand argument"))))
+ (if pcomplete-expand-only-p
+ (throw 'pcompleted t)
+ pcomplete-args))))))
+
+(defun pcomplete-quote-argument (filename)
+ "Return FILENAME with magic characters quoted.
+Magic characters are those in `pcomplete-arg-quote-list'."
+ (if (null pcomplete-arg-quote-list)
+ filename
+ (let ((len (length filename))
+ (index 0)
+ (result "")
+ replacement char)
+ (while (< index len)
+ (setq replacement (run-hook-with-args-until-success
+ 'pcomplete-quote-arg-hook filename index))
+ (cond
+ (replacement
+ (setq result (concat result replacement)))
+ ((and (setq char (aref filename index))
+ (memq char pcomplete-arg-quote-list))
+ (setq result (concat result "\\" (char-to-string char))))
+ (t
+ (setq result (concat result (char-to-string char)))))
+ (setq index (1+ index)))
+ result)))
+
+;; file-system completion lists
+
+(defsubst pcomplete-dirs-or-entries (&optional regexp predicate)
+ "Return either directories, or qualified entries."
+ (append (let ((pcomplete-stub pcomplete-stub))
+ (pcomplete-entries regexp predicate))
+ (pcomplete-entries nil 'file-directory-p)))
+
+(defun pcomplete-entries (&optional regexp predicate)
+ "Complete against a list of directory candidates.
+This function always uses the last argument as the basis for
+completion.
+If REGEXP is non-nil, it is a regular expression used to refine the
+match (files not matching the REGEXP will be excluded).
+If PREDICATE is non-nil, it will also be used to refine the match
+\(files for which the PREDICATE returns nil will be excluded).
+If PATH is non-nil, it will be used for completion instead of
+consulting the last argument."
+ (let* ((name pcomplete-stub)
+ (default-directory (expand-file-name
+ (or (file-name-directory name)
+ default-directory)))
+ above-cutoff)
+ (setq name (file-name-nondirectory name)
+ pcomplete-stub name)
+ (let ((completions
+ (file-name-all-completions name default-directory)))
+ (if regexp
+ (setq completions
+ (pcomplete-pare-list
+ completions nil
+ (function
+ (lambda (file)
+ (not (string-match regexp file)))))))
+ (if predicate
+ (setq completions
+ (pcomplete-pare-list
+ completions nil
+ (function
+ (lambda (file)
+ (not (funcall predicate file)))))))
+ (if (or pcomplete-file-ignore pcomplete-dir-ignore)
+ (setq completions
+ (pcomplete-pare-list
+ completions nil
+ (function
+ (lambda (file)
+ (if (eq (aref file (1- (length file)))
+ directory-sep-char)
+ (and pcomplete-dir-ignore
+ (string-match pcomplete-dir-ignore file))
+ (and pcomplete-file-ignore
+ (string-match pcomplete-file-ignore file))))))))
+ (setq above-cutoff (> (length completions)
+ pcomplete-cycle-cutoff-length))
+ (sort completions
+ (function
+ (lambda (l r)
+ ;; for the purposes of comparison, remove the
+ ;; trailing slash from directory names.
+ ;; Otherwise, "foo.old/" will come before "foo/",
+ ;; since . is earlier in the ASCII alphabet than
+ ;; /
+ (let ((left (if (eq (aref l (1- (length l)))
+ directory-sep-char)
+ (substring l 0 (1- (length l)))
+ l))
+ (right (if (eq (aref r (1- (length r)))
+ directory-sep-char)
+ (substring r 0 (1- (length r)))
+ r)))
+ (if above-cutoff
+ (string-lessp left right)
+ (funcall pcomplete-compare-entry-function
+ left right)))))))))
+
+(defsubst pcomplete-all-entries (&optional regexp predicate)
+ "Like `pcomplete-entries', but doesn't ignore any entries."
+ (let (pcomplete-file-ignore
+ pcomplete-dir-ignore)
+ (pcomplete-entries regexp predicate)))
+
+(defsubst pcomplete-dirs (&optional regexp)
+ "Complete amongst a list of directories."
+ (pcomplete-entries regexp 'file-directory-p))
+
+(defsubst pcomplete-executables (&optional regexp)
+ "Complete amongst a list of directories and executables."
+ (pcomplete-entries regexp 'file-executable-p))
+
+;; generation of completion lists
+
+(defun pcomplete-find-completion-function (command)
+ "Find the completion function to call for the given COMMAND."
+ (let ((sym (intern-soft
+ (concat "pcomplete/" (symbol-name major-mode) "/" command))))
+ (unless sym
+ (setq sym (intern-soft (concat "pcomplete/" command))))
+ (and sym (fboundp sym) sym)))
+
+(defun pcomplete-completions ()
+ "Return a list of completions for the current argument position."
+ (catch 'pcomplete-completions
+ (when (pcomplete-parse-arguments pcomplete-expand-before-complete)
+ (if (= pcomplete-index pcomplete-last)
+ (funcall pcomplete-command-completion-function)
+ (let ((sym (or (pcomplete-find-completion-function
+ (funcall pcomplete-command-name-function))
+ pcomplete-default-completion-function)))
+ (ignore
+ (pcomplete-next-arg)
+ (funcall sym)))))))
+
+(defun pcomplete-opt (options &optional prefix no-ganging args-follow)
+ "Complete a set of OPTIONS, each beginning with PREFIX (?- by default).
+PREFIX may be t, in which case no PREFIX character is necessary.
+If REQUIRED is non-nil, the options must be present.
+If NO-GANGING is non-nil, each option is separate. -xy is not allowed.
+If ARGS-FOLLOW is non-nil, then options which arguments which take may
+have the argument appear after a ganged set of options. This is how
+tar behaves, for example."
+ (if (and (= pcomplete-index pcomplete-last)
+ (string= (pcomplete-arg) "-"))
+ (let ((len (length options))
+ (index 0)
+ char choices)
+ (while (< index len)
+ (setq char (aref options index))
+ (if (eq char ?\()
+ (let ((result (read-from-string options index)))
+ (setq index (cdr result)))
+ (unless (memq char '(?/ ?* ?? ?.))
+ (setq choices (cons (char-to-string char) choices)))
+ (setq index (1+ index))))
+ (throw 'pcomplete-completions
+ (mapcar
+ (function
+ (lambda (opt)
+ (concat "-" opt)))
+ (pcomplete-uniqify-list choices))))
+ (let ((arg (pcomplete-arg)))
+ (when (and (> (length arg) 1)
+ (stringp arg)
+ (eq (aref arg 0) (or prefix ?-)))
+ (pcomplete-next-arg)
+ (let ((char (aref arg 1))
+ (len (length options))
+ (index 0)
+ opt-char arg-char result)
+ (while (< (1+ index) len)
+ (setq opt-char (aref options index)
+ arg-char (aref options (1+ index)))
+ (if (eq arg-char ?\()
+ (setq result
+ (read-from-string options (1+ index))
+ index (cdr result)
+ result (car result))
+ (setq result nil))
+ (when (and (eq char opt-char)
+ (memq arg-char '(?\( ?/ ?* ?? ?.)))
+ (if (< pcomplete-index pcomplete-last)
+ (pcomplete-next-arg)
+ (throw 'pcomplete-completions
+ (cond ((eq arg-char ?/) (pcomplete-dirs))
+ ((eq arg-char ?*) (pcomplete-executables))
+ ((eq arg-char ??) nil)
+ ((eq arg-char ?.) (pcomplete-entries))
+ ((eq arg-char ?\() (eval result))))))
+ (setq index (1+ index))))))))
+
+(defun pcomplete--here (&optional form stub paring form-only)
+ "Complete aganst the current argument, if at the end.
+See the documentation for `pcomplete-here'."
+ (if (< pcomplete-index pcomplete-last)
+ (progn
+ (if (eq paring 0)
+ (setq pcomplete-seen nil)
+ (unless (eq paring t)
+ (let ((arg (pcomplete-arg)))
+ (unless (not (stringp arg))
+ (setq pcomplete-seen
+ (cons (if paring
+ (funcall paring arg)
+ (file-truename arg))
+ pcomplete-seen))))))
+ (pcomplete-next-arg)
+ t)
+ (when pcomplete-show-help
+ (pcomplete--help)
+ (throw 'pcompleted t))
+ (if stub
+ (setq pcomplete-stub stub))
+ (if (or (eq paring t) (eq paring 0))
+ (setq pcomplete-seen nil)
+ (setq pcomplete-norm-func (or paring 'file-truename)))
+ (unless form-only
+ (run-hooks 'pcomplete-try-first-hook))
+ (throw 'pcomplete-completions (eval form))))
+
+(defmacro pcomplete-here (&optional form stub paring form-only)
+ "Complete aganst the current argument, if at the end.
+If completion is to be done here, evaluate FORM to generate the list
+of strings which will be used for completion purposes. If STUB is a
+string, use it as the completion stub instead of the default (which is
+the entire text of the current argument).
+
+For an example of when you might want to use STUB: if the current
+argument text is 'long-path-name/', you don't want the completions
+list display to be cluttered by 'long-path-name/' appearing at the
+beginning of every alternative. Not only does this make things less
+intelligle, but it is also inefficient. Yet, if the completion list
+does not begin with this string for every entry, the current argument
+won't complete correctly.
+
+The solution is to specify a relative stub. It allows you to
+substitute a different argument from the current argument, almost
+always for the sake of efficiency.
+
+If PARING is nil, this argument will be pared against previous
+arguments using the function `file-truename' to normalize them.
+PARING may be a function, in which case that function is for
+normalization. If PARING is the value t, the argument dealt with by
+this call will not participate in argument paring. If it the integer
+0, all previous arguments that have been seen will be cleared.
+
+If FORM-ONLY is non-nil, only the result of FORM will be used to
+generate the completions list. This means that the hook
+`pcomplete-try-first-hook' will not be run."
+ `(pcomplete--here (quote ,form) ,stub ,paring ,form-only))
+
+(defmacro pcomplete-here* (&optional form stub form-only)
+ "An alternate form which does not participate in argument paring."
+ `(pcomplete-here ,form ,stub t ,form-only))
+
+;; display support
+
+(defun pcomplete-restore-windows ()
+ "If the only window change was due to Completions, restore things."
+ (if pcomplete-last-window-config
+ (let* ((cbuf (get-buffer "*Completions*"))
+ (cwin (and cbuf (get-buffer-window cbuf))))
+ (when (and cwin (window-live-p cwin))
+ (bury-buffer cbuf)
+ (set-window-configuration pcomplete-last-window-config))))
+ (setq pcomplete-last-window-config nil
+ pcomplete-window-restore-timer nil))
+
+;; Abstractions so that the code below will work for both Emacs 20 and
+;; XEmacs 21
+
+(unless (fboundp 'event-matches-key-specifier-p)
+ (defalias 'event-matches-key-specifier-p 'eq))
+
+(unless (fboundp 'read-event)
+ (defsubst read-event (&optional prompt)
+ (aref (read-key-sequence prompt) 0)))
+
+(unless (fboundp 'event-basic-type)
+ (defalias 'event-basic-type 'event-key))
+
+(defun pcomplete-show-completions (completions)
+ "List in help buffer sorted COMPLETIONS.
+Typing SPC flushes the help buffer."
+ (let* ((curbuf (current-buffer)))
+ (when pcomplete-window-restore-timer
+ (cancel-timer pcomplete-window-restore-timer)
+ (setq pcomplete-window-restore-timer nil))
+ (unless pcomplete-last-window-config
+ (setq pcomplete-last-window-config (current-window-configuration)))
+ (with-output-to-temp-buffer "*Completions*"
+ (display-completion-list completions))
+ (message "Hit space to flush")
+ (let (event)
+ (prog1
+ (catch 'done
+ (while (with-current-buffer (get-buffer "*Completions*")
+ (setq event (read-event)))
+ (cond
+ ((event-matches-key-specifier-p event ? )
+ (set-window-configuration pcomplete-last-window-config)
+ (setq pcomplete-last-window-config nil)
+ (throw 'done nil))
+ ((event-matches-key-specifier-p event 'tab)
+ (save-selected-window
+ (select-window (get-buffer-window "*Completions*"))
+ (if (pos-visible-in-window-p (point-max))
+ (goto-char (point-min))
+ (scroll-up)))
+ (message ""))
+ (t
+ (setq unread-command-events (list event))
+ (throw 'done nil)))))
+ (if (and pcomplete-last-window-config
+ pcomplete-restore-window-delay)
+ (setq pcomplete-window-restore-timer
+ (run-with-timer pcomplete-restore-window-delay nil
+ 'pcomplete-restore-windows)))))))
+
+;; insert completion at point
+
+(defun pcomplete-insert-entry (stub entry &optional addsuffix raw-p)
+ "Insert a completion entry at point.
+Returns non-nil if a space was appended at the end."
+ (let ((here (point)))
+ (if (not pcomplete-ignore-case)
+ (insert-and-inherit (if raw-p
+ (substring entry (length stub))
+ (pcomplete-quote-argument
+ (substring entry (length stub)))))
+ ;; the stub is not quoted at this time, so to determine the
+ ;; length of what should be in the buffer, we must quote it
+ (delete-backward-char (length (pcomplete-quote-argument stub)))
+ ;; if there is already a backslash present to handle the first
+ ;; character, don't bother quoting it
+ (when (eq (char-before) ?\\)
+ (insert-and-inherit (substring entry 0 1))
+ (setq entry (substring entry 1)))
+ (insert-and-inherit (if raw-p
+ entry
+ (pcomplete-quote-argument entry))))
+ (let (space-added)
+ (when (and (not (memq (char-before) pcomplete-suffix-list))
+ addsuffix)
+ (insert-and-inherit " ")
+ (setq space-added t))
+ (setq pcomplete-last-completion-length (- (point) here)
+ pcomplete-last-completion-stub stub)
+ space-added)))
+
+;; selection of completions
+
+(defun pcomplete-do-complete (stub completions)
+ "Dynamically complete at point using STUB and COMPLETIONS.
+This is basically just a wrapper for `pcomplete-stub' which does some
+extra checking, and munging of the COMPLETIONS list."
+ (unless (stringp stub)
+ (message "Cannot complete argument")
+ (throw 'pcompleted nil))
+ (if (null completions)
+ (ignore
+ (if (and stub (> (length stub) 0))
+ (message "No completions of %s" stub)
+ (message "No completions")))
+ ;; pare it down, if applicable
+ (if pcomplete-seen
+ (let* ((arg (pcomplete-arg))
+ (prefix
+ (file-name-as-directory
+ (funcall pcomplete-norm-func
+ (substring arg 0 (- (length arg)
+ (length pcomplete-stub)))))))
+ (setq pcomplete-seen
+ (mapcar 'directory-file-name pcomplete-seen))
+ (let ((p pcomplete-seen))
+ (while p
+ (add-to-list 'pcomplete-seen
+ (funcall pcomplete-norm-func (car p)))
+ (setq p (cdr p))))
+ (setq completions
+ (mapcar
+ (function
+ (lambda (elem)
+ (file-relative-name elem prefix)))
+ (pcomplete-pare-list
+ (mapcar
+ (function
+ (lambda (elem)
+ (expand-file-name elem prefix)))
+ completions)
+ pcomplete-seen
+ (function
+ (lambda (elem)
+ (member (directory-file-name
+ (funcall pcomplete-norm-func elem))
+ pcomplete-seen))))))))
+ ;; OK, we've got a list of completions.
+ (if pcomplete-show-list
+ (pcomplete-show-completions completions)
+ (pcomplete-stub stub completions))))
+
+(defun pcomplete-stub (stub candidates &optional cycle-p)
+ "Dynamically complete STUB from CANDIDATES list.
+This function inserts completion characters at point by completing
+STUB from the strings in CANDIDATES. A completions listing may be
+shown in a help buffer if completion is ambiguous.
+
+Returns nil if no completion was inserted.
+Returns `sole' if completed with the only completion match.
+Returns `shortest' if completed with the shortest of the matches.
+Returns `partial' if completed as far as possible with the matches.
+Returns `listed' if a completion listing was shown.
+
+See also `pcomplete-filename'."
+ (let* ((completion-ignore-case pcomplete-ignore-case)
+ (candidates (mapcar 'list candidates))
+ (completions (all-completions stub candidates)))
+ (let (result entry)
+ (cond
+ ((null completions)
+ (if (and stub (> (length stub) 0))
+ (message "No completions of %s" stub)
+ (message "No completions")))
+ ((= 1 (length completions))
+ (setq entry (car completions))
+ (if (string-equal entry stub)
+ (message "Sole completion"))
+ (setq result 'sole))
+ ((and pcomplete-cycle-completions
+ (or cycle-p
+ (not pcomplete-cycle-cutoff-length)
+ (<= (length completions)
+ pcomplete-cycle-cutoff-length)))
+ (setq entry (car completions)
+ pcomplete-current-completions completions))
+ (t ; There's no unique completion; use longest substring
+ (setq entry (try-completion stub candidates))
+ (cond ((and pcomplete-recexact
+ (string-equal stub entry)
+ (member entry completions))
+ ;; It's not unique, but user wants shortest match.
+ (message "Completed shortest")
+ (setq result 'shortest))
+ ((or pcomplete-autolist
+ (string-equal stub entry))
+ ;; It's not unique, list possible completions.
+ (pcomplete-show-completions completions)
+ (setq result 'listed))
+ (t
+ (message "Partially completed")
+ (setq result 'partial)))))
+ (cons result entry))))
+
+;; context sensitive help
+
+(defun pcomplete--help ()
+ "Produce context-sensitive help for the current argument.
+If specific documentation can't be given, be generic.
+INFODOC specifies the Info node to goto. DOCUMENTATION is a sexp
+which will produce documentation for the argument (it is responsible
+for displaying in its own buffer)."
+ (if (and pcomplete-help
+ (or (and (stringp pcomplete-help)
+ (fboundp 'Info-goto-node))
+ (listp pcomplete-help)))
+ (if (listp pcomplete-help)
+ (message (eval pcomplete-help))
+ (save-window-excursion (info))
+ (switch-to-buffer-other-window "*info*")
+ (funcall (symbol-function 'Info-goto-node) pcomplete-help))
+ (if pcomplete-man-function
+ (let ((cmd (funcall pcomplete-command-name-function)))
+ (if (and cmd (> (length cmd) 0))
+ (funcall pcomplete-man-function cmd)))
+ (message "No context-sensitive help available"))))
+
+;; general utilities
+
+(defsubst pcomplete-time-less-p (t1 t2)
+ "Say whether time T1 is less than time T2."
+ (or (< (car t1) (car t2))
+ (and (= (car t1) (car t2))
+ (< (nth 1 t1) (nth 1 t2)))))
+
+(defun pcomplete-pare-list (l r &optional pred)
+ "Destructively remove from list L all elements matching any in list R.
+Test is done using `equal'.
+If PRED is non-nil, it is a function used for further removal.
+Returns the resultant list."
+ (while (and l (or (and r (member (car l) r))
+ (and pred
+ (funcall pred (car l)))))
+ (setq l (cdr l)))
+ (let ((m l))
+ (while m
+ (while (and (cdr m)
+ (or (and r (member (cadr m) r))
+ (and pred
+ (funcall pred (cadr m)))))
+ (setcdr m (cddr m)))
+ (setq m (cdr m))))
+ l)
+
+(defun pcomplete-uniqify-list (l)
+ "Sort and remove multiples in L."
+ (setq l (sort l 'string-lessp))
+ (let ((m l))
+ (while m
+ (while (and (cdr m)
+ (string= (car m)
+ (cadr m)))
+ (setcdr m (cddr m)))
+ (setq m (cdr m))))
+ l)
+
+(defun pcomplete-process-result (cmd &rest args)
+ "Call CMD using `call-process' and return the simplest result."
+ (with-temp-buffer
+ (apply 'call-process cmd nil t nil args)
+ (skip-chars-backward "\n")
+ (buffer-substring (point-min) (point))))
+
+;; create a set of aliases which allow completion functions to be not
+;; quite so verbose
+
+;; jww (1999-10-20): are these a good idea?
+; (defalias 'pc-here 'pcomplete-here)
+; (defalias 'pc-test 'pcomplete-test)
+; (defalias 'pc-opt 'pcomplete-opt)
+; (defalias 'pc-match 'pcomplete-match)
+; (defalias 'pc-match-string 'pcomplete-match-string)
+; (defalias 'pc-match-beginning 'pcomplete-match-beginning)
+; (defalias 'pc-match-end 'pcomplete-match-end)
+
+;;; pcomplete.el ends here