-;;; shell.el --- general command interpreter in a window stuff
-
-;; Author: Olin Shivers <shivers@cs.cmu.edu>
-;; Last-Modified: 16 Mar 1992
-;; Keywords: processes
-
-;;; Copyright Olin Shivers (1988).
-
-;;; 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, 675 Mass Ave, Cambridge, MA 02139, USA.
-
-;;; Commentary:
-
-;;; The changelog is at the end of file.
-
-;;; Please send me bug reports, bug fixes, and extensions, so that I can
-;;; merge them into the master source.
-;;; - Olin Shivers (shivers@cs.cmu.edu)
-
-;;; This file defines a a shell-in-a-buffer package (shell mode) built
-;;; on top of comint mode. This is actually cmushell with things
-;;; renamed to replace its counterpart in Emacs 18. cmushell is more
-;;; featureful, robust, and uniform than the Emacs 18 version.
-
-;;; Since this mode is built on top of the general command-interpreter-in-
-;;; a-buffer mode (comint mode), it shares a common base functionality,
-;;; and a common set of bindings, with all modes derived from comint mode.
-;;; This makes these modes easier to use.
-
-;;; For documentation on the functionality provided by comint mode, and
-;;; the hooks available for customising it, see the file comint.el.
-;;; For further information on shell mode, see the comments below.
-
-;;; Needs fixin:
-;;; When sending text from a source file to a subprocess, the process-mark can
-;;; move off the window, so you can lose sight of the process interactions.
-;;; Maybe I should ensure the process mark is in the window when I send
-;;; text to the process? Switch selectable?
-
-;; YOUR .EMACS FILE
-;;=============================================================================
-;; Some suggestions for your .emacs file.
-;;
-;; ; If cmushell lives in some non-standard directory, you must tell emacs
-;; ; where to get it. This may or may not be necessary.
-;; (setq load-path (cons (expand-file-name "~jones/lib/emacs") load-path))
-;;
-;; ; Autoload cmushell from file cmushell.el
-;; (autoload 'cmushell "cmushell"
-;; "Run an inferior shell process."
-;; t)
-;;
-;; ; Define C-c t to run my favorite command in cmushell mode:
-;; (setq cmushell-load-hook
-;; '((lambda ()
-;; (define-key cmushell-mode-map "\C-ct" 'favorite-cmd))))
-
-\f
-;;; Brief Command Documentation:
-;;;============================================================================
-;;; Comint Mode Commands: (common to shell and all comint-derived modes)
-;;;
-;;; m-p comint-previous-input Cycle backwards in input history
-;;; m-n comint-next-input Cycle forwards
-;;; m-c-r comint-previous-input-matching Search backwards in input history
-;;; return comint-send-input
-;;; c-a comint-bol Beginning of line; skip prompt.
-;;; c-d comint-delchar-or-maybe-eof Delete char unless at end of buff.
-;;; c-c c-u comint-kill-input ^u
-;;; c-c c-w backward-kill-word ^w
-;;; c-c c-c comint-interrupt-subjob ^c
-;;; c-c c-z comint-stop-subjob ^z
-;;; c-c c-\ comint-quit-subjob ^\
-;;; c-c c-o comint-kill-output Delete last batch of process output
-;;; c-c c-r comint-show-output Show last batch of process output
-;;; send-invisible Read line w/o echo & send to proc
-;;; comint-continue-subjob Useful if you accidentally suspend
-;;; top-level job.
-;;; comint-mode-hook is the comint mode hook.
-
-;;; Shell Mode Commands:
-;;; shell Fires up the shell process.
-;;; tab comint-dynamic-complete Complete a partial file name
-;;; m-? comint-dynamic-list-completions List completions in help buffer
-;;; dirs Resync the buffer's dir stack.
-;;; dirtrack-toggle Turn dir tracking on/off.
-;;;
-;;; The shell mode hook is shell-mode-hook
-;;; The shell-load-hook is run after this file is loaded.
-;;; comint-prompt-regexp is initialised to shell-prompt-pattern, for backwards
-;;; compatibility.
-
-;;; Read the rest of this file for more information.
-\f
-;;; SHELL.EL COMPATIBILITY
-;;; Notes from when this was called cmushell, and was not the standard emacs
-;;; shell package.
-;;;============================================================================
-;;; In brief: this package should have no trouble coexisting with shell.el.
-;;;
-;;; Most customising variables -- e.g., explicit-shell-file-name -- are the
-;;; same, so the users shouldn't have much trouble. Hooks have different
-;;; names, however, so you can customise shell mode differently from cmushell
-;;; mode. You basically just have to remember to type M-x cmushell instead of
-;;; M-x shell.
-;;;
-;;; It would be nice if this file was completely plug-compatible with the old
-;;; shell package -- if you could just name this file shell.el, and have it
-;;; transparently replace the old one. But you can't. Several other packages
-;;; (tex-mode, background, dbx, gdb, kermit, monkey, prolog, telnet) are also
-;;; clients of shell mode. These packages assume detailed knowledge of shell
-;;; mode internals in ways that are incompatible with cmushell mode (mostly
-;;; because of cmushell mode's greater functionality). So, unless we are
-;;; willing to port all of these packages, we can't have this file be a
-;;; complete replacement for shell.el -- that is, we can't name this file
-;;; shell.el, and its main entry point (shell), because dbx.el will break
-;;; when it loads it in and tries to use it.
-;;;
-;;; There are two ways to fix this. One: rewrite these other modes to use the
-;;; new package. This is a win, but can't be assumed. The other, backwards
-;;; compatible route, is to make this package non-conflict with shell.el, so
-;;; both files can be loaded in at the same time. And *that* is why some
-;;; functions and variables have different names: (cmushell),
-;;; cmushell-mode-map, that sort of thing. All the names have been carefully
-;;; chosen so that shell.el and cmushell.el won't tromp on each other.
-\f
-;;; Customisation and Buffer Variables
-;;; ===========================================================================
-;;;
-
-;;; Code:
-
-(require 'comint)
-
-;;;###autoload
-(defconst shell-prompt-pattern "^[^#$%>]*[#$%>] *"
- "Regexp to match prompts in the inferior shell.
-Defaults to \"^[^#$%>]*[#$%>] *\", which works pretty well.
-This variable is used to initialise comint-prompt-regexp in the
-shell buffer.
-
-This is a fine thing to set in your .emacs file.")
-
-(defvar shell-popd-regexp "popd"
- "*Regexp to match subshell commands equivalent to popd.")
-
-(defvar shell-pushd-regexp "pushd"
- "*Regexp to match subshell commands equivalent to pushd.")
-
-(defvar shell-cd-regexp "cd"
- "*Regexp to match subshell commands equivalent to cd.")
-
-(defvar explicit-shell-file-name nil
- "*If non-nil, is file name to use for explicitly requested inferior shell.")
-
-(defvar explicit-csh-args
- (if (eq system-type 'hpux)
- ;; -T persuades HP's csh not to think it is smarter
- ;; than us about what terminal modes to use.
- '("-i" "-T")
- '("-i"))
- "*Args passed to inferior shell by M-x shell, if the shell is csh.
-Value is a list of strings, which may be nil.")
-
-;;; All the above vars aren't prefixed "cmushell-" to make them
-;;; backwards compatible w/shell.el and old .emacs files.
-
-(defvar shell-dirstack nil
- "List of directories saved by pushd in this buffer's shell.
-Thus, this does not include the shell's current directory.")
-
-(defvar shell-dirstack-query "dirs"
- "Command used by shell-resync-dirlist to query shell.")
-
-(defvar shell-mode-map '())
-(cond ((not shell-mode-map)
- (setq shell-mode-map (full-copy-sparse-keymap comint-mode-map))
- (define-key shell-mode-map "\t" 'comint-dynamic-complete)
- (define-key shell-mode-map "\M-?" 'comint-dynamic-list-completions)))
-
-(defvar shell-mode-hook '()
- "*Hook for customising shell mode")
-
-\f
-;;; Basic Procedures
-;;; ===========================================================================
-;;;
-
-(defun shell-mode ()
- "Major mode for interacting with an inferior shell.
-Return after the end of the process' output sends the text from the
- end of process to the end of the current line.
-Return before end of process output copies the current line (except
- for the prompt) to the end of the buffer and sends it.
-M-x send-invisible reads a line of text without echoing it, and sends it to
- the shell. This is useful for entering passwords.
-
-If you accidentally suspend your process, use \\[comint-continue-subjob]
-to continue it.
-
-cd, pushd and popd commands given to the shell are watched by Emacs to keep
-this buffer's default directory the same as the shell's working directory.
-M-x dirs queries the shell and resyncs Emacs' idea of what the current
- directory stack is.
-M-x dirtrack-toggle turns directory tracking on and off.
-
-\\{shell-mode-map}
-Customisation: Entry to this mode runs the hooks on comint-mode-hook and
-shell-mode-hook (in that order).
-
-Variables shell-cd-regexp, shell-pushd-regexp and shell-popd-regexp are used
-to match their respective commands."
- (interactive)
- (comint-mode)
- (setq comint-prompt-regexp shell-prompt-pattern)
- (setq major-mode 'shell-mode)
- (setq mode-name "shell")
- (use-local-map shell-mode-map)
- (make-local-variable 'shell-dirstack)
- (setq shell-dirstack nil)
- (make-local-variable 'shell-dirtrackp)
- (setq shell-dirtrackp t)
- (setq comint-input-sentinel 'shell-directory-tracker)
- (run-hooks 'shell-mode-hook))
-
-\f
-;;;###autoload
-(defun shell ()
- "Run an inferior shell, with I/O through buffer *shell*.
-If buffer exists but shell process is not running, make new shell.
-If buffer exists and shell process is running,
- just switch to buffer *shell*.
-Program used comes from variable explicit-shell-file-name,
- or (if that is nil) from the ESHELL environment variable,
- or else from SHELL if there is no ESHELL.
-If a file ~/.emacs_SHELLNAME exists, it is given as initial input
- (Note that this may lose due to a timing error if the shell
- discards input when it starts up.)
-The buffer is put in shell-mode, giving commands for sending input
-and controlling the subjobs of the shell. See shell-mode.
-See also variable shell-prompt-pattern.
-
-The shell file name (sans directories) is used to make a symbol name
-such as `explicit-csh-arguments'. If that symbol is a variable,
-its value is used as a list of arguments when invoking the shell.
-Otherwise, one argument `-i' is passed to the shell.
-
-\(Type \\[describe-mode] in the shell buffer for a list of commands.)"
- (interactive)
- (cond ((not (comint-check-proc "*shell*"))
- (let* ((prog (or explicit-shell-file-name
- (getenv "ESHELL")
- (getenv "SHELL")
- "/bin/sh"))
- (name (file-name-nondirectory prog))
- (startfile (concat "~/.emacs_" name))
- (xargs-name (intern-soft (concat "explicit-" name "-args"))))
- (set-buffer (apply 'make-comint "shell" prog
- (if (file-exists-p startfile) startfile)
- (if (and xargs-name (boundp xargs-name))
- (symbol-value xargs-name)
- '("-i"))))
- (shell-mode))))
- (switch-to-buffer "*shell*"))
-
-\f
-;;; Directory tracking
-;;; ===========================================================================
-;;; This code provides the shell mode input sentinel
-;;; SHELL-DIRECTORY-TRACKER
-;;; that tracks cd, pushd, and popd commands issued to the shell, and
-;;; changes the current directory of the shell buffer accordingly.
-;;;
-;;; This is basically a fragile hack, although it's more accurate than
-;;; the released version in shell.el. It has the following failings:
-;;; 1. It doesn't know about the cdpath shell variable.
-;;; 2. It only spots the first command in a command sequence. E.g., it will
-;;; miss the cd in "ls; cd foo"
-;;; 3. More generally, any complex command (like ";" sequencing) is going to
-;;; throw it. Otherwise, you'd have to build an entire shell interpreter in
-;;; emacs lisp. Failing that, there's no way to catch shell commands where
-;;; cd's are buried inside conditional expressions, aliases, and so forth.
-;;;
-;;; The whole approach is a crock. Shell aliases mess it up. File sourcing
-;;; messes it up. You run other processes under the shell; these each have
-;;; separate working directories, and some have commands for manipulating
-;;; their w.d.'s (e.g., the lcd command in ftp). Some of these programs have
-;;; commands that do *not* affect the current w.d. at all, but look like they
-;;; do (e.g., the cd command in ftp). In shells that allow you job
-;;; control, you can switch between jobs, all having different w.d.'s. So
-;;; simply saying %3 can shift your w.d..
-;;;
-;;; The solution is to relax, not stress out about it, and settle for
-;;; a hack that works pretty well in typical circumstances. Remember
-;;; that a half-assed solution is more in keeping with the spirit of Unix,
-;;; anyway. Blech.
-;;;
-;;; One good hack not implemented here for users of programmable shells
-;;; is to program up the shell w.d. manipulation commands to output
-;;; a coded command sequence to the tty. Something like
-;;; ESC | <cwd> |
-;;; where <cwd> is the new current working directory. Then trash the
-;;; directory tracking machinery currently used in this package, and
-;;; replace it with a process filter that watches for and strips out
-;;; these messages.
-
-;;; REGEXP is a regular expression. STR is a string. START is a fixnum.
-;;; Returns T if REGEXP matches STR where the match is anchored to start
-;;; at position START in STR. Sort of like LOOKING-AT for strings.
-(defun shell-front-match (regexp str start)
- (eq start (string-match regexp str start)))
-
-(defun shell-directory-tracker (str)
- "Tracks cd, pushd and popd commands issued to the shell.
-This function is called on each input passed to the shell.
-It watches for cd, pushd and popd commands and sets the buffer's
-default directory to track these commands.
-
-You may toggle this tracking on and off with M-x dirtrack-toggle.
-If emacs gets confused, you can resync with the shell with M-x dirs.
-
-See variables shell-cd-regexp, shell-pushd-regexp, and shell-popd-regexp.
-Environment variables are expanded, see function substitute-in-file-name."
- (condition-case err
- (cond (shell-dirtrackp
- (string-match "^\\s *" str) ; skip whitespace
- (let ((bos (match-end 0))
- (x nil))
- (cond ((setq x (shell-match-cmd-w/optional-arg shell-popd-regexp
- str bos))
- (shell-process-popd (substitute-in-file-name x)))
- ((setq x (shell-match-cmd-w/optional-arg shell-pushd-regexp
- str bos))
- (shell-process-pushd (substitute-in-file-name x)))
- ((setq x (shell-match-cmd-w/optional-arg shell-cd-regexp
- str bos))
- (shell-process-cd (substitute-in-file-name x)))))))
- (error (message (car (cdr err))))))
-
-
-;;; Try to match regexp CMD to string, anchored at position START.
-;;; CMD may be followed by a single argument. If a match, then return
-;;; the argument, if there is one, or the empty string if not. If
-;;; no match, return nil.
-
-(defun shell-match-cmd-w/optional-arg (cmd str start)
- (and (shell-front-match cmd str start)
- (let ((eoc (match-end 0))) ; end of command
- (cond ((shell-front-match "\\s *\\(\;\\|$\\)" str eoc)
- "") ; no arg
- ((shell-front-match "\\s +\\([^ \t\;]+\\)\\s *\\(\;\\|$\\)"
- str eoc)
- (substring str (match-beginning 1) (match-end 1))) ; arg
- (t nil))))) ; something else.
-;;; The first regexp is [optional whitespace, (";" or the end of string)].
-;;; The second regexp is [whitespace, (an arg), optional whitespace,
-;;; (";" or end of string)].
-
-
-;;; popd [+n]
-(defun shell-process-popd (arg)
- (let ((num (if (zerop (length arg)) 0 ; no arg means +0
- (shell-extract-num arg))))
- (if (and num (< num (length shell-dirstack)))
- (if (= num 0) ; condition-case because the CD could lose.
- (condition-case nil (progn (cd (car shell-dirstack))
- (setq shell-dirstack
- (cdr shell-dirstack))
- (shell-dirstack-message))
- (error (message "Couldn't cd.")))
- (let* ((ds (cons nil shell-dirstack))
- (cell (nthcdr (- num 1) ds)))
- (rplacd cell (cdr (cdr cell)))
- (setq shell-dirstack (cdr ds))
- (shell-dirstack-message)))
- (message "Bad popd."))))
-
-
-;;; cd [dir]
-(defun shell-process-cd (arg)
- (condition-case nil (progn (cd (if (zerop (length arg)) (getenv "HOME")
- arg))
- (shell-dirstack-message))
- (error (message "Couldn't cd."))))
-
-
-;;; pushd [+n | dir]
-(defun shell-process-pushd (arg)
- (if (zerop (length arg))
- ;; no arg -- swap pwd and car of shell stack
- (condition-case nil (if shell-dirstack
- (let ((old default-directory))
- (cd (car shell-dirstack))
- (setq shell-dirstack
- (cons old (cdr shell-dirstack)))
- (shell-dirstack-message))
- (message "Directory stack empty."))
- (message "Couldn't cd."))
-
- (let ((num (shell-extract-num arg)))
- (if num ; pushd +n
- (if (> num (length shell-dirstack))
- (message "Directory stack not that deep.")
- (let* ((ds (cons default-directory shell-dirstack))
- (dslen (length ds))
- (front (nthcdr num ds))
- (back (reverse (nthcdr (- dslen num) (reverse ds))))
- (new-ds (append front back)))
- (condition-case nil
- (progn (cd (car new-ds))
- (setq shell-dirstack (cdr new-ds))
- (shell-dirstack-message))
- (error (message "Couldn't cd.")))))
-
- ;; pushd <dir>
- (let ((old-wd default-directory))
- (condition-case nil
- (progn (cd arg)
- (setq shell-dirstack
- (cons old-wd shell-dirstack))
- (shell-dirstack-message))
- (error (message "Couldn't cd."))))))))
-
-;; If STR is of the form +n, for n>0, return n. Otherwise, nil.
-(defun shell-extract-num (str)
- (and (string-match "^\\+[1-9][0-9]*$" str)
- (string-to-int str)))
-
-
-(defun shell-dirtrack-toggle ()
- "Turn directory tracking on and off in a shell buffer."
- (interactive)
- (setq shell-dirtrackp (not shell-dirtrackp))
- (message "directory tracking %s."
- (if shell-dirtrackp "ON" "OFF")))
-
-;;; For your typing convenience:
-(fset 'dirtrack-toggle 'shell-dirtrack-toggle)
-
-
-(defun shell-resync-dirs ()
- "Resync the buffer's idea of the current directory stack.
-This command queries the shell with the command bound to
-shell-dirstack-query (default \"dirs\"), reads the next
-line output and parses it to form the new directory stack.
-DON'T issue this command unless the buffer is at a shell prompt.
-Also, note that if some other subprocess decides to do output
-immediately after the query, its output will be taken as the
-new directory stack -- you lose. If this happens, just do the
-command again."
- (interactive)
- (let* ((proc (get-buffer-process (current-buffer)))
- (pmark (process-mark proc)))
- (goto-char pmark)
- (insert shell-dirstack-query) (insert "\n")
- (sit-for 0) ; force redisplay
- (comint-send-string proc shell-dirstack-query)
- (comint-send-string proc "\n")
- (set-marker pmark (point))
- (let ((pt (point))) ; wait for 1 line
- ;; This extra newline prevents the user's pending input from spoofing us.
- (insert "\n") (backward-char 1)
- (while (not (looking-at ".+\n"))
- (accept-process-output proc)
- (goto-char pt)))
- (goto-char pmark) (delete-char 1) ; remove the extra newline
- ;; That's the dirlist. grab it & parse it.
- (let* ((dl (buffer-substring (match-beginning 0) (- (match-end 0) 1)))
- (dl-len (length dl))
- (ds '()) ; new dir stack
- (i 0))
- (while (< i dl-len)
- ;; regexp = optional whitespace, (non-whitespace), optional whitespace
- (string-match "\\s *\\(\\S +\\)\\s *" dl i) ; pick off next dir
- (setq ds (cons (substring dl (match-beginning 1) (match-end 1))
- ds))
- (setq i (match-end 0)))
- (let ((ds (reverse ds)))
- (condition-case nil
- (progn (cd (car ds))
- (setq shell-dirstack (cdr ds))
- (shell-dirstack-message))
- (error (message "Couldn't cd.")))))))
-
-;;; For your typing convenience:
-(fset 'dirs 'shell-resync-dirs)
-
-
-;;; Show the current dirstack on the message line.
-;;; Pretty up dirs a bit by changing "/usr/jqr/foo" to "~/foo".
-;;; (This isn't necessary if the dirlisting is generated with a simple "dirs".)
-;;; All the commands that mung the buffer's dirstack finish by calling
-;;; this guy.
-(defun shell-dirstack-message ()
- (let ((msg "")
- (ds (cons default-directory shell-dirstack)))
- (while ds
- (let ((dir (car ds)))
- (if (string-match (format "^%s\\(/\\|$\\)" (getenv "HOME")) dir)
- (setq dir (concat "~/" (substring dir (match-end 0)))))
- (if (string-equal dir "~/") (setq dir "~"))
- (setq msg (concat msg dir " "))
- (setq ds (cdr ds))))
- (message msg)))
-
-
-\f
-;;; Interfacing to client packages (and converting them)
-;;; Notes from when this was called cmushell, and was not the standard emacs
-;;; shell package. Many of the conversions discussed here have been done.
-;;;============================================================================
-;;; Several gnu packages (tex-mode, background, dbx, gdb, kermit, prolog,
-;;; telnet are some) use the shell package as clients. Most of them would
-;;; be better off using the comint package directly, but they predate it.
-;;; The catch is that most of these packages (dbx, gdb, prolog, telnet)
-;;; assume total knowledge of all the local variables that shell mode
-;;; functions depend on. So they (kill-all-local-variables), then create
-;;; the few local variables that shell.el functions depend on. Alas,
-;;; cmushell.el functions depend on a different set of vars (for example,
-;;; the input history ring is a local variable in cmushell.el's shell mode,
-;;; whereas there is no input history ring in shell.el's shell mode).
-;;; So we have a situation where the greater functionality of cmushell.el
-;;; is biting us -- you can't just replace shell will cmushell.
-;;;
-;;; Altering these packages to use comint mode directly should *greatly*
-;;; improve their functionality, and is actually pretty easy. It's
-;;; mostly a matter of renaming a few variable names. See comint.el for more.
-;;; -Olin
-
-
-
-;;; Do the user's customisation...
-;;;===============================
-(defvar shell-load-hook nil
- "This hook is run when shell is loaded in.
-This is a good place to put keybindings.")
-
-(run-hooks 'shell-load-hook)
-
-;;; Change Log
-;;; ===========================================================================
-;;; Olin 8/88
-;;; Created.
-;;;
-;;; Olin 5/26/90
-;;; - Split cmulisp and cmushell modes into separate files.
-;;; Not only is this a good idea, it's apparently the way it'll be rel 19.
-;;; - Souped up the directory tracking; it now can handle pushd, pushd +n,
-;;; and popd +n.
-;;; - Added cmushell-dirtrack-toggle command to toggle the directory
-;;; tracking that cmushell tries to do. This is useful, for example,
-;;; when you are running ftp -- it prevents the ftp "cd" command from
-;;; spoofing the tracking machinery. This command is also named
-;;; dirtrack-toggle, so you need only type M-x dirtrack to run it.
-;;; - Added cmushell-resync-dirs command. This queries the shell
-;;; for the current directory stack, and resets the buffer's stack
-;;; accordingly. This command is also named dirs, so you need only type
-;;; M-x dirs to run it.
-;;; - Bits of the new directory tracking code were adapted from source
-;;; contributed by Vince Broman, Jeff Peck, and Barry Warsaw.
-;;; - See also the improvements made to comint.el at the same time.
-;;; - Renamed several variables. Mostly this comprised changing "shell"
-;;; to "cmushell" in the names. The only variables that are not prefixed
-;;; with "cmushell-" are the ones that are common with shell.el:
-;;; explicit-shell-file-name shell-prompt-pattern explicit-csh-args
-;;; and shell-cd/popd/pushd-regexp
-;;; The variables and functions that were changed to have "cmushell-"
-;;; prefixes are:
-;;; shell-directory-stack (v), shell-directory-tracker (f)
-;;; This should not affect users, only Emacs Lisp hackers. Hopefully
-;;; one day shell.el will just go away, and we can drop all this
-;;; "cmushell" bullshit.
-;;; - Upgraded process sends to use comint-send-string instead of
-;;; process-send-string.
-;;;
-;;; Olin 6/14/90
-;;; - If your shell is named <shellname>, and a variable named
-;;; explicit-<shellname>-args exists, cmushell is supposed
-;;; to use its value as the arglist to the shell invocation.
-;;; E.g., if you define explicit-csh-args to be
-;;; ("-ifx"), then when cmushell cranks up a csh, it execs it
-;;; as "csh -ifx". This is what is documented. What has actually
-;;; been the case is that the variable checked is
-;;; explicit-<shellname>-arguments, not explicit-<shellname>-args.
-;;; The documentation has been changed to conform to the code (for
-;;; backwards compatibility with shell.el). This bug is inherited from
-;;; the same bug in shell.el.
-;;; This bug reported by Stephen Anderson.
-;;;
-;;; Olin 9/5/90
-;;; - Arguments to cd, popd, and pushd now have their env vars expanded
-;;; out by the tracking machinery. So if you say "cd $SRCDIR/funs", the
-;;; $SRCDIR var will be replaced by its value *in emacs' process
-;;; environment*. If this is different from the shell's binding of the
-;;; variable, you lose. Several users needed this feature, fragile
-;;; though it may be. The fix was contributed by sk@thp.Uni-Koeln.DE.
-;;;
-;;; Olin 3/12/91
-;;; - Moved comint-dynamic-complete (filename completion) from M-tab to tab.
-;;;
-;;; Jim Blandy 10/30/91
-;;; - Removed the "cmu" prefix from names, renamed file to shell.el,
-;;; to become the standard shell package.
-
-(provide 'shell)
-
-;;; shell.el ends here
+;;; shell.el --- specialized comint.el for running the shell.
+
+;; Copyright (C) 1988, 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
+
+;; Author: Olin Shivers <shivers@cs.cmu.edu>
+;; Maintainer: Simon Marshall <simon@gnu.ai.mit.edu>
+;; Keywords: processes
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 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:
+
+;; Please send me bug reports, bug fixes, and extensions, so that I can
+;; merge them into the master source.
+;; - Olin Shivers (shivers@cs.cmu.edu)
+;; - Simon Marshall (simon@gnu.ai.mit.edu)
+
+;; This file defines a a shell-in-a-buffer package (shell mode) built
+;; on top of comint mode. This is actually cmushell with things
+;; renamed to replace its counterpart in Emacs 18. cmushell is more
+;; featureful, robust, and uniform than the Emacs 18 version.
+
+;; Since this mode is built on top of the general command-interpreter-in-
+;; a-buffer mode (comint mode), it shares a common base functionality,
+;; and a common set of bindings, with all modes derived from comint mode.
+;; This makes these modes easier to use.
+
+;; For documentation on the functionality provided by comint mode, and
+;; the hooks available for customising it, see the file comint.el.
+;; For further information on shell mode, see the comments below.
+
+;; Needs fixin:
+;; When sending text from a source file to a subprocess, the process-mark can
+;; move off the window, so you can lose sight of the process interactions.
+;; Maybe I should ensure the process mark is in the window when I send
+;; text to the process? Switch selectable?
+
+;; YOUR .EMACS FILE
+;;=============================================================================
+;; Some suggestions for your .emacs file.
+;;
+;; ;; Define M-# to run some strange command:
+;; (eval-after-load "shell"
+;; '(define-key shell-mode-map "\M-#" 'shells-dynamic-spell))
+\f
+;; Brief Command Documentation:
+;;============================================================================
+;; Comint Mode Commands: (common to shell and all comint-derived modes)
+;;
+;; m-p comint-previous-input Cycle backwards in input history
+;; m-n comint-next-input Cycle forwards
+;; m-r comint-previous-matching-input Previous input matching a regexp
+;; m-s comint-next-matching-input Next input that matches
+;; m-c-l comint-show-output Show last batch of process output
+;; return comint-send-input
+;; c-d comint-delchar-or-maybe-eof Delete char unless at end of buff.
+;; c-c c-a comint-bol Beginning of line; skip prompt
+;; c-c c-u comint-kill-input ^u
+;; c-c c-w backward-kill-word ^w
+;; c-c c-c comint-interrupt-subjob ^c
+;; c-c c-z comint-stop-subjob ^z
+;; c-c c-\ comint-quit-subjob ^\
+;; c-c c-o comint-kill-output Delete last batch of process output
+;; c-c c-r comint-show-output Show last batch of process output
+;; c-c c-h comint-dynamic-list-input-ring List input history
+;; send-invisible Read line w/o echo & send to proc
+;; comint-continue-subjob Useful if you accidentally suspend
+;; top-level job
+;; comint-mode-hook is the comint mode hook.
+
+;; Shell Mode Commands:
+;; shell Fires up the shell process
+;; tab comint-dynamic-complete Complete filename/command/history
+;; m-? comint-dynamic-list-filename-completions
+;; List completions in help buffer
+;; m-c-f shell-forward-command Forward a shell command
+;; m-c-b shell-backward-command Backward a shell command
+;; dirs Resync the buffer's dir stack
+;; dirtrack-toggle Turn dir tracking on/off
+;; comint-strip-ctrl-m Remove trailing ^Ms from output
+;;
+;; The shell mode hook is shell-mode-hook
+;; comint-prompt-regexp is initialised to shell-prompt-pattern, for backwards
+;; compatibility.
+
+;; Read the rest of this file for more information.
+\f
+;;; Code:
+
+(require 'comint)
+
+;;; Customization and Buffer Variables
+
+;;;###autoload
+(defvar shell-prompt-pattern "^[^#$%>\n]*[#$%>] *"
+ "Regexp to match prompts in the inferior shell.
+Defaults to \"^[^#$%>\\n]*[#$%>] *\", which works pretty well.
+This variable is used to initialise `comint-prompt-regexp' in the
+shell buffer.
+
+The pattern should probably not match more than one line. If it does,
+Shell mode may become confused trying to distinguish prompt from input
+on lines which don't start with a prompt.
+
+This is a fine thing to set in your `.emacs' file.")
+
+(defvar shell-completion-fignore nil
+ "*List of suffixes to be disregarded during file/command completion.
+This variable is used to initialize `comint-completion-fignore' in the shell
+buffer. The default is nil, for compatibility with most shells.
+Some people like (\"~\" \"#\" \"%\").
+
+This is a fine thing to set in your `.emacs' file.")
+
+(defvar shell-delimiter-argument-list '(?\| ?& ?< ?> ?\( ?\) ?\;)
+ "List of characters to recognise as separate arguments.
+This variable is used to initialize `comint-delimiter-argument-list' in the
+shell buffer. The default is (?\\| ?& ?< ?> ?\\( ?\\) ?\\;).
+
+This is a fine thing to set in your `.emacs' file.")
+
+(defvar shell-file-name-quote-list
+ (append shell-delimiter-argument-list '(?\ ?\* ?\! ?\" ?\' ?\`))
+ "List of characters to quote when in a file name.
+This variable is used to initialize `comint-file-name-quote-list' in the
+shell buffer. The default is (?\ ?\* ?\! ?\" ?\' ?\`) plus characters
+in `shell-delimiter-argument-list'.
+
+This is a fine thing to set in your `.emacs' file.")
+
+(defvar shell-dynamic-complete-functions
+ '(comint-replace-by-expanded-history
+ shell-dynamic-complete-environment-variable
+ shell-dynamic-complete-command
+ shell-replace-by-expanded-directory
+ comint-dynamic-complete-filename)
+ "List of functions called to perform completion.
+This variable is used to initialise `comint-dynamic-complete-functions' in the
+shell buffer.
+
+This is a fine thing to set in your `.emacs' file.")
+
+(defvar shell-command-regexp "[^;&|\n]+"
+ "*Regexp to match a single command within a pipeline.
+This is used for directory tracking and does not do a perfect job.")
+
+(defvar shell-completion-execonly t
+ "*If non-nil, use executable files only for completion candidates.
+This mirrors the optional behavior of tcsh.
+
+Detecting executability of files may slow command completion considerably.")
+
+(defvar shell-popd-regexp "popd"
+ "*Regexp to match subshell commands equivalent to popd.")
+
+(defvar shell-pushd-regexp "pushd"
+ "*Regexp to match subshell commands equivalent to pushd.")
+
+(defvar shell-pushd-tohome nil
+ "*If non-nil, make pushd with no arg behave as \"pushd ~\" (like cd).
+This mirrors the optional behavior of tcsh.")
+
+(defvar shell-pushd-dextract nil
+ "*If non-nil, make \"pushd +n\" pop the nth dir to the stack top.
+This mirrors the optional behavior of tcsh.")
+
+(defvar shell-pushd-dunique nil
+ "*If non-nil, make pushd only add unique directories to the stack.
+This mirrors the optional behavior of tcsh.")
+
+(defvar shell-cd-regexp "cd"
+ "*Regexp to match subshell commands equivalent to cd.")
+
+(defvar explicit-shell-file-name nil
+ "*If non-nil, is file name to use for explicitly requested inferior shell.")
+
+(defvar explicit-csh-args
+ (if (eq system-type 'hpux)
+ ;; -T persuades HP's csh not to think it is smarter
+ ;; than us about what terminal modes to use.
+ '("-i" "-T")
+ '("-i"))
+ "*Args passed to inferior shell by M-x shell, if the shell is csh.
+Value is a list of strings, which may be nil.")
+
+(defvar shell-input-autoexpand 'history
+ "*If non-nil, expand input command history references on completion.
+This mirrors the optional behavior of tcsh (its autoexpand and histlit).
+
+If the value is `input', then the expansion is seen on input.
+If the value is `history', then the expansion is only when inserting
+into the buffer's input ring. See also `comint-magic-space' and
+`comint-dynamic-complete'.
+
+This variable supplies a default for `comint-input-autoexpand',
+for Shell mode only.")
+
+(defvar shell-dirstack nil
+ "List of directories saved by pushd in this buffer's shell.
+Thus, this does not include the shell's current directory.")
+
+(defvar shell-dirtrackp t
+ "Non-nil in a shell buffer means directory tracking is enabled.")
+
+(defvar shell-last-dir nil
+ "Keep track of last directory for ksh `cd -' command.")
+
+(defvar shell-dirstack-query nil
+ "Command used by `shell-resync-dir' to query the shell.")
+
+(defvar shell-mode-map nil)
+(cond ((not shell-mode-map)
+ (setq shell-mode-map (nconc (make-sparse-keymap) comint-mode-map))
+ (define-key shell-mode-map "\C-c\C-f" 'shell-forward-command)
+ (define-key shell-mode-map "\C-c\C-b" 'shell-backward-command)
+ (define-key shell-mode-map "\t" 'comint-dynamic-complete)
+ (define-key shell-mode-map "\M-?"
+ 'comint-dynamic-list-filename-completions)
+ (define-key shell-mode-map [menu-bar completion]
+ (copy-keymap (lookup-key comint-mode-map [menu-bar completion])))
+ (define-key-after (lookup-key shell-mode-map [menu-bar completion])
+ [complete-env-variable] '("Complete Env. Variable Name" .
+ shell-dynamic-complete-environment-variable)
+ 'complete-file)
+ (define-key-after (lookup-key shell-mode-map [menu-bar completion])
+ [expand-directory] '("Expand Directory Reference" .
+ shell-replace-by-expanded-directory)
+ 'complete-expand)))
+
+(defvar shell-mode-hook '()
+ "*Hook for customising Shell mode.")
+
+(defvar shell-font-lock-keywords
+ (list (cons shell-prompt-pattern 'font-lock-keyword-face)
+ '("[ \t]\\([+-][^ \t\n]+\\)" 1 font-lock-comment-face)
+ '("^[^ \t\n]+:.*" . font-lock-string-face)
+ '("^\\[[1-9][0-9]*\\]" . font-lock-string-face))
+ "Additional expressions to highlight in Shell mode.")
+\f
+;;; Basic Procedures
+
+(defun shell-mode ()
+ "Major mode for interacting with an inferior shell.
+\\[comint-send-input] after the end of the process' output sends the text from
+ the end of process to the end of the current line.
+\\[comint-send-input] before end of process output copies the current line minus the prompt to
+ the end of the buffer and sends it (\\[comint-copy-old-input] just copies the current line).
+\\[send-invisible] reads a line of text without echoing it, and sends it to
+ the shell. This is useful for entering passwords. Or, add the function
+ `comint-watch-for-password-prompt' to `comint-output-filter-functions'.
+
+If you want to make multiple shell buffers, rename the `*shell*' buffer
+using \\[rename-buffer] or \\[rename-uniquely] and start a new shell.
+
+If you want to make shell buffers limited in length, add the function
+`comint-truncate-buffer' to `comint-output-filter-functions'.
+
+If you accidentally suspend your process, use \\[comint-continue-subjob]
+to continue it.
+
+`cd', `pushd' and `popd' commands given to the shell are watched by Emacs to
+keep this buffer's default directory the same as the shell's working directory.
+While directory tracking is enabled, the shell's working directory is displayed
+by \\[list-buffers] or \\[mouse-buffer-menu] in the `File' field.
+\\[dirs] queries the shell and resyncs Emacs' idea of what the current
+ directory stack is.
+\\[dirtrack-toggle] turns directory tracking on and off.
+
+\\{shell-mode-map}
+Customization: Entry to this mode runs the hooks on `comint-mode-hook' and
+`shell-mode-hook' (in that order). Before each input, the hooks on
+`comint-input-filter-functions' are run. After each shell output, the hooks
+on `comint-output-filter-functions' are run.
+
+Variables `shell-cd-regexp', `shell-pushd-regexp' and `shell-popd-regexp'
+are used to match their respective commands, while `shell-pushd-tohome',
+`shell-pushd-dextract' and `shell-pushd-dunique' control the behavior of the
+relevant command.
+
+Variables `comint-completion-autolist', `comint-completion-addsuffix',
+`comint-completion-recexact' and `comint-completion-fignore' control the
+behavior of file name, command name and variable name completion. Variable
+`shell-completion-execonly' controls the behavior of command name completion.
+Variable `shell-completion-fignore' is used to initialise the value of
+`comint-completion-fignore'.
+
+Variables `comint-input-ring-file-name' and `comint-input-autoexpand' control
+the initialisation of the input ring history, and history expansion.
+
+Variables `comint-output-filter-functions', a hook, and
+`comint-scroll-to-bottom-on-input' and `comint-scroll-to-bottom-on-output'
+control whether input and output cause the window to scroll to the end of the
+buffer."
+ (interactive)
+ (comint-mode)
+ (setq major-mode 'shell-mode)
+ (setq mode-name "Shell")
+ (use-local-map shell-mode-map)
+ (setq comint-prompt-regexp shell-prompt-pattern)
+ (setq comint-completion-fignore shell-completion-fignore)
+ (setq comint-delimiter-argument-list shell-delimiter-argument-list)
+ (setq comint-file-name-quote-list shell-file-name-quote-list)
+ (setq comint-dynamic-complete-functions shell-dynamic-complete-functions)
+ (make-local-variable 'paragraph-start)
+ (setq paragraph-start comint-prompt-regexp)
+ (make-local-variable 'font-lock-defaults)
+ (setq font-lock-defaults '(shell-font-lock-keywords t))
+ (make-local-variable 'shell-dirstack)
+ (setq shell-dirstack nil)
+ (setq shell-last-dir nil)
+ (make-local-variable 'shell-dirtrackp)
+ (setq shell-dirtrackp t)
+ (add-hook 'comint-input-filter-functions 'shell-directory-tracker nil t)
+ (setq comint-input-autoexpand shell-input-autoexpand)
+ (make-local-variable 'list-buffers-directory)
+ (setq list-buffers-directory (expand-file-name default-directory))
+ ;; shell-dependent assignments.
+ (let ((shell (file-name-nondirectory (car
+ (process-command (get-buffer-process (current-buffer)))))))
+ (setq comint-input-ring-file-name
+ (or (getenv "HISTFILE")
+ (cond ((string-equal shell "bash") "~/.bash_history")
+ ((string-equal shell "ksh") "~/.sh_history")
+ (t "~/.history"))))
+ (if (or (equal comint-input-ring-file-name "")
+ (equal (file-truename comint-input-ring-file-name) "/dev/null"))
+ (setq comint-input-ring-file-name nil))
+ (setq shell-dirstack-query
+ (cond ((string-equal shell "sh") "pwd")
+ ((string-equal shell "ksh") "echo $PWD ~-")
+ (t "dirs"))))
+ (run-hooks 'shell-mode-hook)
+ (comint-read-input-ring t))
+\f
+;;;###autoload
+(defun shell ()
+ "Run an inferior shell, with I/O through buffer *shell*.
+If buffer exists but shell process is not running, make new shell.
+If buffer exists and shell process is running, just switch to buffer `*shell*'.
+Program used comes from variable `explicit-shell-file-name',
+ or (if that is nil) from the ESHELL environment variable,
+ or else from SHELL if there is no ESHELL.
+If a file `~/.emacs_SHELLNAME' exists, it is given as initial input
+ (Note that this may lose due to a timing error if the shell
+ discards input when it starts up.)
+The buffer is put in Shell mode, giving commands for sending input
+and controlling the subjobs of the shell. See `shell-mode'.
+See also the variable `shell-prompt-pattern'.
+
+The shell file name (sans directories) is used to make a symbol name
+such as `explicit-csh-args'. If that symbol is a variable,
+its value is used as a list of arguments when invoking the shell.
+Otherwise, one argument `-i' is passed to the shell.
+
+\(Type \\[describe-mode] in the shell buffer for a list of commands.)"
+ (interactive)
+ (if (not (comint-check-proc "*shell*"))
+ (let* ((prog (or explicit-shell-file-name
+ (getenv "ESHELL")
+ (getenv "SHELL")
+ "/bin/sh"))
+ (name (file-name-nondirectory prog))
+ (startfile (concat "~/.emacs_" name))
+ (xargs-name (intern-soft (concat "explicit-" name "-args")))
+ shell-buffer)
+ (save-excursion
+ (set-buffer (apply 'make-comint "shell" prog
+ (if (file-exists-p startfile) startfile)
+ (if (and xargs-name (boundp xargs-name))
+ (symbol-value xargs-name)
+ '("-i"))))
+ (setq shell-buffer (current-buffer))
+ (shell-mode))
+ (pop-to-buffer shell-buffer))
+ (pop-to-buffer "*shell*")))
+
+;;; Don't do this when shell.el is loaded, only while dumping.
+;;;###autoload (add-hook 'same-window-buffer-names "*shell*")
+\f
+;;; Directory tracking
+;;;
+;;; This code provides the shell mode input sentinel
+;;; SHELL-DIRECTORY-TRACKER
+;;; that tracks cd, pushd, and popd commands issued to the shell, and
+;;; changes the current directory of the shell buffer accordingly.
+;;;
+;;; This is basically a fragile hack, although it's more accurate than
+;;; the version in Emacs 18's shell.el. It has the following failings:
+;;; 1. It doesn't know about the cdpath shell variable.
+;;; 2. It cannot infallibly deal with command sequences, though it does well
+;;; with these and with ignoring commands forked in another shell with ()s.
+;;; 3. More generally, any complex command is going to throw it. Otherwise,
+;;; you'd have to build an entire shell interpreter in emacs lisp. Failing
+;;; that, there's no way to catch shell commands where cd's are buried
+;;; inside conditional expressions, aliases, and so forth.
+;;;
+;;; The whole approach is a crock. Shell aliases mess it up. File sourcing
+;;; messes it up. You run other processes under the shell; these each have
+;;; separate working directories, and some have commands for manipulating
+;;; their w.d.'s (e.g., the lcd command in ftp). Some of these programs have
+;;; commands that do *not* affect the current w.d. at all, but look like they
+;;; do (e.g., the cd command in ftp). In shells that allow you job
+;;; control, you can switch between jobs, all having different w.d.'s. So
+;;; simply saying %3 can shift your w.d..
+;;;
+;;; The solution is to relax, not stress out about it, and settle for
+;;; a hack that works pretty well in typical circumstances. Remember
+;;; that a half-assed solution is more in keeping with the spirit of Unix,
+;;; anyway. Blech.
+;;;
+;;; One good hack not implemented here for users of programmable shells
+;;; is to program up the shell w.d. manipulation commands to output
+;;; a coded command sequence to the tty. Something like
+;;; ESC | <cwd> |
+;;; where <cwd> is the new current working directory. Then trash the
+;;; directory tracking machinery currently used in this package, and
+;;; replace it with a process filter that watches for and strips out
+;;; these messages.
+
+(defun shell-directory-tracker (str)
+ "Tracks cd, pushd and popd commands issued to the shell.
+This function is called on each input passed to the shell.
+It watches for cd, pushd and popd commands and sets the buffer's
+default directory to track these commands.
+
+You may toggle this tracking on and off with M-x dirtrack-toggle.
+If emacs gets confused, you can resync with the shell with M-x dirs.
+
+See variables `shell-cd-regexp', `shell-pushd-regexp', and `shell-popd-regexp',
+while `shell-pushd-tohome', `shell-pushd-dextract' and `shell-pushd-dunique'
+control the behavior of the relevant command.
+
+Environment variables are expanded, see function `substitute-in-file-name'."
+ (if shell-dirtrackp
+ ;; We fail gracefully if we think the command will fail in the shell.
+ (condition-case chdir-failure
+ (let ((start (progn (string-match "^[; \t]*" str) ; skip whitespace
+ (match-end 0)))
+ end cmd arg1)
+ (while (string-match shell-command-regexp str start)
+ (setq end (match-end 0)
+ cmd (comint-arguments (substring str start end) 0 0)
+ arg1 (comint-arguments (substring str start end) 1 1))
+ (cond ((string-match (concat "\\`\\(" shell-popd-regexp
+ "\\)\\($\\|[ \t]\\)")
+ cmd)
+ (shell-process-popd (substitute-in-file-name arg1)))
+ ((string-match (concat "\\`\\(" shell-pushd-regexp
+ "\\)\\($\\|[ \t]\\)")
+ cmd)
+ (shell-process-pushd (substitute-in-file-name arg1)))
+ ((string-match (concat "\\`\\(" shell-cd-regexp
+ "\\)\\($\\|[ \t]\\)")
+ cmd)
+ (shell-process-cd (substitute-in-file-name arg1))))
+ (setq start (progn (string-match "[; \t]*" str end) ; skip again
+ (match-end 0)))))
+ (error "Couldn't cd"))))
+
+;;; popd [+n]
+(defun shell-process-popd (arg)
+ (let ((num (or (shell-extract-num arg) 0)))
+ (cond ((and num (= num 0) shell-dirstack)
+ (shell-cd (car shell-dirstack))
+ (setq shell-dirstack (cdr shell-dirstack))
+ (shell-dirstack-message))
+ ((and num (> num 0) (<= num (length shell-dirstack)))
+ (let* ((ds (cons nil shell-dirstack))
+ (cell (nthcdr (1- num) ds)))
+ (rplacd cell (cdr (cdr cell)))
+ (setq shell-dirstack (cdr ds))
+ (shell-dirstack-message)))
+ (t
+ (error "Couldn't popd")))))
+
+;; Return DIR prefixed with comint-file-name-prefix as appropriate.
+(defun shell-prefixed-directory-name (dir)
+ (if (= (length comint-file-name-prefix) 0)
+ dir
+ (if (file-name-absolute-p dir)
+ ;; The name is absolute, so prepend the prefix.
+ (concat comint-file-name-prefix dir)
+ ;; For relative name we assume default-directory already has the prefix.
+ (expand-file-name dir))))
+
+;;; cd [dir]
+(defun shell-process-cd (arg)
+ (let ((new-dir (cond ((zerop (length arg)) (concat comint-file-name-prefix
+ "~"))
+ ((string-equal "-" arg) shell-last-dir)
+ (t (shell-prefixed-directory-name arg)))))
+ (setq shell-last-dir default-directory)
+ (shell-cd new-dir)
+ (shell-dirstack-message)))
+
+;;; pushd [+n | dir]
+(defun shell-process-pushd (arg)
+ (let ((num (shell-extract-num arg)))
+ (cond ((zerop (length arg))
+ ;; no arg -- swap pwd and car of stack unless shell-pushd-tohome
+ (cond (shell-pushd-tohome
+ (shell-process-pushd (concat comint-file-name-prefix "~")))
+ (shell-dirstack
+ (let ((old default-directory))
+ (shell-cd (car shell-dirstack))
+ (setq shell-dirstack (cons old (cdr shell-dirstack)))
+ (shell-dirstack-message)))
+ (t
+ (message "Directory stack empty."))))
+ ((numberp num)
+ ;; pushd +n
+ (cond ((> num (length shell-dirstack))
+ (message "Directory stack not that deep."))
+ ((= num 0)
+ (error (message "Couldn't cd.")))
+ (shell-pushd-dextract
+ (let ((dir (nth (1- num) shell-dirstack)))
+ (shell-process-popd arg)
+ (shell-process-pushd default-directory)
+ (shell-cd dir)
+ (shell-dirstack-message)))
+ (t
+ (let* ((ds (cons default-directory shell-dirstack))
+ (dslen (length ds))
+ (front (nthcdr num ds))
+ (back (reverse (nthcdr (- dslen num) (reverse ds))))
+ (new-ds (append front back)))
+ (shell-cd (car new-ds))
+ (setq shell-dirstack (cdr new-ds))
+ (shell-dirstack-message)))))
+ (t
+ ;; pushd <dir>
+ (let ((old-wd default-directory))
+ (shell-cd (shell-prefixed-directory-name arg))
+ (if (or (null shell-pushd-dunique)
+ (not (member old-wd shell-dirstack)))
+ (setq shell-dirstack (cons old-wd shell-dirstack)))
+ (shell-dirstack-message))))))
+
+;; If STR is of the form +n, for n>0, return n. Otherwise, nil.
+(defun shell-extract-num (str)
+ (and (string-match "^\\+[1-9][0-9]*$" str)
+ (string-to-int str)))
+
+
+(defun shell-dirtrack-toggle ()
+ "Turn directory tracking on and off in a shell buffer."
+ (interactive)
+ (if (setq shell-dirtrackp (not shell-dirtrackp))
+ (setq list-buffers-directory default-directory)
+ (setq list-buffers-directory nil))
+ (message "Directory tracking %s" (if shell-dirtrackp "ON" "OFF")))
+
+;;; For your typing convenience:
+(defalias 'dirtrack-toggle 'shell-dirtrack-toggle)
+
+(defun shell-cd (dir)
+ "Do normal `cd' to DIR, and set `list-buffers-directory'."
+ (if shell-dirtrackp
+ (setq list-buffers-directory (file-name-as-directory
+ (expand-file-name dir))))
+ (cd dir))
+
+(defun shell-resync-dirs ()
+ "Resync the buffer's idea of the current directory stack.
+This command queries the shell with the command bound to
+`shell-dirstack-query' (default \"dirs\"), reads the next
+line output and parses it to form the new directory stack.
+DON'T issue this command unless the buffer is at a shell prompt.
+Also, note that if some other subprocess decides to do output
+immediately after the query, its output will be taken as the
+new directory stack -- you lose. If this happens, just do the
+command again."
+ (interactive)
+ (let* ((proc (get-buffer-process (current-buffer)))
+ (pmark (process-mark proc)))
+ (goto-char pmark)
+ (insert shell-dirstack-query) (insert "\n")
+ (sit-for 0) ; force redisplay
+ (comint-send-string proc shell-dirstack-query)
+ (comint-send-string proc "\n")
+ (set-marker pmark (point))
+ (let ((pt (point))) ; wait for 1 line
+ ;; This extra newline prevents the user's pending input from spoofing us.
+ (insert "\n") (backward-char 1)
+ (while (not (looking-at ".+\n"))
+ (accept-process-output proc)
+ (goto-char pt)))
+ (goto-char pmark) (delete-char 1) ; remove the extra newline
+ ;; That's the dirlist. grab it & parse it.
+ (let* ((dl (buffer-substring (match-beginning 0) (1- (match-end 0))))
+ (dl-len (length dl))
+ (ds '()) ; new dir stack
+ (i 0))
+ (while (< i dl-len)
+ ;; regexp = optional whitespace, (non-whitespace), optional whitespace
+ (string-match "\\s *\\(\\S +\\)\\s *" dl i) ; pick off next dir
+ (setq ds (cons (concat comint-file-name-prefix
+ (substring dl (match-beginning 1)
+ (match-end 1)))
+ ds))
+ (setq i (match-end 0)))
+ (let ((ds (nreverse ds)))
+ (condition-case nil
+ (progn (shell-cd (car ds))
+ (setq shell-dirstack (cdr ds)
+ shell-last-dir (car shell-dirstack))
+ (shell-dirstack-message))
+ (error (message "Couldn't cd.")))))))
+
+;;; For your typing convenience:
+(defalias 'dirs 'shell-resync-dirs)
+
+
+;;; Show the current dirstack on the message line.
+;;; Pretty up dirs a bit by changing "/usr/jqr/foo" to "~/foo".
+;;; (This isn't necessary if the dirlisting is generated with a simple "dirs".)
+;;; All the commands that mung the buffer's dirstack finish by calling
+;;; this guy.
+(defun shell-dirstack-message ()
+ (let* ((msg "")
+ (ds (cons default-directory shell-dirstack))
+ (home (expand-file-name (concat comint-file-name-prefix "~/")))
+ (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))))
+ ;; Strip off comint-file-name-prefix if present.
+ (and comint-file-name-prefix
+ (>= (length dir) (length comint-file-name-prefix))
+ (string= comint-file-name-prefix
+ (substring dir 0 (length comint-file-name-prefix)))
+ (setq dir (substring dir (length comint-file-name-prefix)))
+ (setcar ds dir))
+ (setq msg (concat msg (directory-file-name dir) " "))
+ (setq ds (cdr ds))))
+ (message "%s" msg)))
+\f
+(defun shell-forward-command (&optional arg)
+ "Move forward across ARG shell command(s). Does not cross lines.
+See `shell-command-regexp'."
+ (interactive "p")
+ (let ((limit (save-excursion (end-of-line nil) (point))))
+ (if (re-search-forward (concat shell-command-regexp "\\([;&|][\t ]*\\)+")
+ limit 'move arg)
+ (skip-syntax-backward " "))))
+
+
+(defun shell-backward-command (&optional arg)
+ "Move backward across ARG shell command(s). Does not cross lines.
+See `shell-command-regexp'."
+ (interactive "p")
+ (let ((limit (save-excursion (comint-bol nil) (point))))
+ (if (> limit (point))
+ (save-excursion (beginning-of-line) (setq limit (point))))
+ (skip-syntax-backward " " limit)
+ (if (re-search-backward
+ (format "[;&|]+[\t ]*\\(%s\\)" shell-command-regexp) limit 'move arg)
+ (progn (goto-char (match-beginning 1))
+ (skip-chars-forward ";&|")))))
+
+
+(defun shell-dynamic-complete-command ()
+ "Dynamically complete the command at point.
+This function is similar to `comint-dynamic-complete-filename', except that it
+searches `exec-path' (minus the trailing emacs library path) for completion
+candidates. Note that this may not be the same as the shell's idea of the
+path.
+
+Completion is dependent on the value of `shell-completion-execonly', plus
+those that effect file completion. See `shell-dynamic-complete-as-command'.
+
+Returns t if successful."
+ (interactive)
+ (let ((filename (comint-match-partial-filename)))
+ (if (and filename
+ (save-match-data (not (string-match "[~/]" filename)))
+ (eq (match-beginning 0)
+ (save-excursion (shell-backward-command 1) (point))))
+ (prog2 (message "Completing command name...")
+ (shell-dynamic-complete-as-command)))))
+
+
+(defun shell-dynamic-complete-as-command ()
+ "Dynamically complete at point as a command.
+See `shell-dynamic-complete-filename'. Returns t if successful."
+ (let* ((filename (or (comint-match-partial-filename) ""))
+ (pathnondir (file-name-nondirectory filename))
+ (paths (cdr (reverse exec-path)))
+ (cwd (file-name-as-directory (expand-file-name default-directory)))
+ (ignored-extensions
+ (and comint-completion-fignore
+ (mapconcat (function (lambda (x) (concat (regexp-quote x) "$")))
+ comint-completion-fignore "\\|")))
+ (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 (comint-directory (or (car paths) ".")))
+ comps-in-path (and (file-accessible-directory-p path)
+ (file-name-all-completions pathnondir 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))
+ (not (and ignored-extensions
+ (string-match ignored-extensions file)))
+ (or (string-equal path cwd)
+ (not (file-directory-p filepath)))
+ (or (null shell-completion-execonly)
+ (file-executable-p filepath)))
+ (setq completions (cons file completions)))
+ (setq comps-in-path (cdr comps-in-path)))
+ (setq paths (cdr paths)))
+ ;; OK, we've got a list of completions.
+ (let ((success (let ((comint-completion-addsuffix nil))
+ (comint-dynamic-simple-complete pathnondir completions))))
+ (if (and (memq success '(sole shortest)) comint-completion-addsuffix
+ (not (file-directory-p (comint-match-partial-filename))))
+ (insert " "))
+ success)))
+
+
+(defun shell-match-partial-variable ()
+ "Return the shell variable at point, or nil if none is found."
+ (save-excursion
+ (let ((limit (point)))
+ (if (re-search-backward "[^A-Za-z0-9_{}]" nil 'move)
+ (or (looking-at "\\$") (forward-char 1)))
+ ;; Anchor the search forwards.
+ (if (or (eolp) (looking-at "[^A-Za-z0-9_{}$]"))
+ nil
+ (re-search-forward "\\$?{?[A-Za-z0-9_]*}?" limit)
+ (buffer-substring (match-beginning 0) (match-end 0))))))
+
+
+(defun shell-dynamic-complete-environment-variable ()
+ "Dynamically complete the environment variable at point.
+Completes if after a variable, i.e., if it starts with a \"$\".
+See `shell-dynamic-complete-as-environment-variable'.
+
+This function is similar to `comint-dynamic-complete-filename', except that it
+searches `process-environment' for completion candidates. Note that this may
+not be the same as the interpreter's idea of variable names. The main problem
+with this type of completion is that `process-environment' is the environment
+which Emacs started with. Emacs does not track changes to the environment made
+by the interpreter. Perhaps it would be more accurate if this function was
+called `shell-dynamic-complete-process-environment-variable'.
+
+Returns non-nil if successful."
+ (interactive)
+ (let ((variable (shell-match-partial-variable)))
+ (if (and variable (string-match "^\\$" variable))
+ (prog2 (message "Completing variable name...")
+ (shell-dynamic-complete-as-environment-variable)))))
+
+
+(defun shell-dynamic-complete-as-environment-variable ()
+ "Dynamically complete at point as an environment variable.
+Used by `shell-dynamic-complete-environment-variable'.
+Uses `comint-dynamic-simple-complete'."
+ (let* ((var (or (shell-match-partial-variable) ""))
+ (variable (substring var (or (string-match "[^$({]\\|$" var) 0)))
+ (variables (mapcar (function (lambda (x)
+ (substring x 0 (string-match "=" x))))
+ process-environment))
+ (addsuffix comint-completion-addsuffix)
+ (comint-completion-addsuffix nil)
+ (success (comint-dynamic-simple-complete variable variables)))
+ (if (memq success '(sole shortest))
+ (let* ((var (shell-match-partial-variable))
+ (variable (substring var (string-match "[^$({]" var)))
+ (protection (cond ((string-match "{" var) "}")
+ ((string-match "(" var) ")")
+ (t "")))
+ (suffix (cond ((null addsuffix) "")
+ ((file-directory-p
+ (comint-directory (getenv variable))) "/")
+ (t " "))))
+ (insert protection suffix)))
+ success))
+
+
+(defun shell-replace-by-expanded-directory ()
+ "Expand directory stack reference before point.
+Directory stack references are of the form \"=digit\" or \"=-\".
+See `default-directory' and `shell-dirstack'.
+
+Returns t if successful."
+ (interactive)
+ (if (comint-match-partial-filename)
+ (save-excursion
+ (goto-char (match-beginning 0))
+ (let ((stack (cons default-directory shell-dirstack))
+ (index (cond ((looking-at "=-/?")
+ (length shell-dirstack))
+ ((looking-at "=\\([0-9]+\\)")
+ (string-to-number
+ (buffer-substring
+ (match-beginning 1) (match-end 1)))))))
+ (cond ((null index)
+ nil)
+ ((>= index (length stack))
+ (error "Directory stack not that deep."))
+ (t
+ (replace-match (file-name-as-directory (nth index stack)) t t)
+ (message "Directory item: %d" index)
+ t))))))
+\f
+(provide 'shell)
+
+;;; shell.el ends here
HCoop / bpt / emacs.git / blobdiff