;;; shell.el --- specialized comint.el for running the shell.
-;;; Copyright (C) 1988, 1993 Free Software Foundation, Inc.
+
+;; Copyright (C) 1988, 1993, 1994, 1995 Free Software Foundation, Inc.
;; Author: Olin Shivers <shivers@cs.cmu.edu>
-;; Adapted-by: Simon Marshall <s.marshall@dcs.hull.ac.uk>
+;; Maintainer: Simon Marshall <simon@gnu.ai.mit.edu>
;; Keywords: processes
-;;; This file is part of GNU Emacs.
+;; 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 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.
+;; 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.
+;; 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:
;;; 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 (s.marshall@dcs.hull.ac.uk)
+;;; - 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
;;=============================================================================
;; Some suggestions for your .emacs file.
;;
-;; ; If shell 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 shell from file shell.el
-;; (autoload 'shell "shell"
-;; "Run an inferior shell process."
-;; t)
-;;
-;; ; Define C-c t to run my favorite command in shell mode:
-;; (setq shell-mode-hook
-;; '((lambda ()
-;; (define-key shell-mode-map "\C-ct" 'favorite-cmd))))
-
+;; ;; Define M-# to run some strange command:
+;; (eval-after-load "shell"
+;; '(define-key shell-mode-map "\M-#" 'shells-dynamic-spell))
\f
;;; Brief Command Documentation:
;;;============================================================================
;;; 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-R comint-previous-matching-input-from-input -"- matching input
;;; m-s comint-next-matching-input Next input that matches
-;;; m-S comint-next-matching-input-from-input -"- matching input
-;;; m-c-r comint-previous-input-matching Search backwards in input history
+;;; m-c-l comint-show-output Show last batch of process output
;;; 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-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
;;; 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
+;;; 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
;;; 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
;;; Customization and Buffer Variables
;;; ===========================================================================
;;;
This is a fine thing to set in your `.emacs' file.")
-(defvar shell-delimiter-argument-list '("|" "&" "<" ">" "(" ")" ";")
+(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.
-Defaults to \(\"|\" \"&\" \"\(\" \")\" \";\"), which works pretty well.
-This variable is used to initialise `comint-delimiter-argument-list' in the
+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 "\\((.*)\\|[^;&|]\\)+"
- "*Regexp to match shell commands.
-Elements of pipes are considered as separate commands, forks and redirections
-as part of one command.")
+(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 behaviour of the tcsh.
+This mirrors the optional behavior of tcsh.
Detecting executability of files may slow command completion considerably.")
(defvar shell-pushd-tohome nil
"*If non-nil, make pushd with no arg behave as \"pushd ~\" (like cd).
-This mirrors the optional behaviour of the tcsh.")
+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 behaviour of the tcsh.")
+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 behaviour of the tcsh.")
+This mirrors the optional behavior of tcsh.")
(defvar shell-cd-regexp "cd"
"*Regexp to match subshell commands equivalent to cd.")
"*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-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 "dirs"
+(defvar shell-dirstack-query nil
"Command used by `shell-resync-dir' to query the shell.")
-(defvar shell-mode-map '())
+(defvar shell-mode-map nil)
(cond ((not shell-mode-map)
- (setq shell-mode-map (full-copy-sparse-keymap comint-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)))
+ '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.
-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.
+\\[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.
-M-x dirs queries the shell and resyncs Emacs' idea of what the current
+`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.
-M-x dirtrack-toggle turns directory tracking on and off.
+\\[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). After each shell output, the hooks on
-`comint-output-filter-hook' are run.
+`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 behaviour of the
+`shell-pushd-dextract' and `shell-pushd-dunique' control the behavior of the
relevant command.
-Variables `comint-completion-autolist', `comint-completion-addsuffix' and
-`comint-completion-recexact' control the behaviour of file name, command name
-and variable name completion. Variable `shell-completion-execonly' controls
-the behaviour of command name completion.
+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-hook', `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."
+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-after-partial-filename-command 'shell-after-partial-filename)
- (setq comint-get-current-command 'shell-get-current-command)
- (setq comint-dynamic-complete-command-command 'shell-dynamic-complete-command)
+ (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)
- (setq comint-input-sentinel 'shell-directory-tracker)
+ (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 (car (process-command (get-buffer-process (current-buffer))))))
+ (let ((shell (file-name-nondirectory (car
+ (process-command (get-buffer-process (current-buffer)))))))
(setq comint-input-ring-file-name
(or (getenv "HISTFILE")
- (cond ((string-match "csh$" shell) "~/.history")
- ((string-match "bash$" shell) "~/.bash_history")
- ((string-match "ksh$" shell) "~/.sh_history")
- (t "~/.history")))))
+ (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
+ (if (string-match "^k?sh$" shell) "pwd" "dirs")))
(run-hooks 'shell-mode-hook)
- (comint-read-input-ring)
- (shell-dirstack-message))
+ (comint-read-input-ring t))
\f
;;;###autoload
(defun 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*"))
+ (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
;;; ===========================================================================
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 behaviour of the relevant command.
+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 "^[;\\s ]*" str) ; skip whitespace
+ (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 ((eq (string-match shell-popd-regexp cmd) 0)
+ (cond ((string-match (concat "\\`\\(" shell-popd-regexp
+ "\\)\\($\\|[ \t]\\)")
+ cmd)
(shell-process-popd (substitute-in-file-name arg1)))
- ((eq (string-match shell-pushd-regexp cmd) 0)
+ ((string-match (concat "\\`\\(" shell-pushd-regexp
+ "\\)\\($\\|[ \t]\\)")
+ cmd)
(shell-process-pushd (substitute-in-file-name arg1)))
- ((eq (string-match shell-cd-regexp cmd) 0)
+ ((string-match (concat "\\`\\(" shell-cd-regexp
+ "\\)\\($\\|[ \t]\\)")
+ cmd)
(shell-process-cd (substitute-in-file-name arg1))))
- (setq start (progn (string-match "[;\\s ]*" str end) ; skip again
+ (setq start (progn (string-match "[; \t]*" str end) ; skip again
(match-end 0)))))
- (error (message "Couldn't cd")))))
-
-
-;; Like `cd', but prepends comint-file-name-prefix to absolute names.
-(defsubst shell-cd (directory)
- (if (file-name-absolute-p directory)
- (cd-absolute (concat comint-file-name-prefix directory))
- (cd directory)))
+ (error "Couldn't cd"))))
;;; popd [+n]
(defun shell-process-popd (arg)
(setq shell-dirstack (cdr ds))
(shell-dirstack-message)))
(t
- (error (message "Couldn't popd."))))))
+ (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)) (getenv "HOME"))
+ (let ((new-dir (cond ((zerop (length arg)) (concat comint-file-name-prefix
+ "~"))
((string-equal "-" arg) shell-last-dir)
- (t arg))))
+ (t (shell-prefixed-directory-name arg)))))
(setq shell-last-dir default-directory)
(shell-cd new-dir)
(shell-dirstack-message)))
(cond ((zerop (length arg))
;; no arg -- swap pwd and car of stack unless shell-pushd-tohome
(cond (shell-pushd-tohome
- (shell-process-pushd "~"))
+ (shell-process-pushd (concat comint-file-name-prefix "~")))
(shell-dirstack
(let ((old default-directory))
(shell-cd (car shell-dirstack))
(t
;; pushd <dir>
(let ((old-wd default-directory))
- (shell-cd arg)
+ (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)))
(defun shell-dirtrack-toggle ()
"Turn directory tracking on and off in a shell buffer."
(interactive)
- (setq shell-dirtrackp (not shell-dirtrackp))
+ (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.
(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))
+ (setq ds (cons (concat comint-file-name-prefix
+ (substring dl (match-beginning 1)
+ (match-end 1)))
ds))
(setq i (match-end 0)))
- (let ((ds (reverse ds)))
+ (let ((ds (nreverse ds)))
(condition-case nil
- (progn (cd (car ds))
+ (progn (shell-cd (car ds))
(setq shell-dirstack (cdr ds))
(shell-dirstack-message))
(error (message "Couldn't cd.")))))))
See `shell-command-regexp'."
(interactive "p")
(let ((limit (save-excursion (end-of-line nil) (point))))
- (if (re-search-forward (concat shell-command-regexp "\\([;&|][\\s ]*\\)+")
+ (if (re-search-forward (concat shell-command-regexp "\\([;&|][\t ]*\\)+")
limit 'move arg)
- (skip-syntax-backward "^\\s "))))
+ (skip-syntax-backward " "))))
(defun shell-backward-command (&optional arg)
See `shell-command-regexp'."
(interactive "p")
(let ((limit (save-excursion (comint-bol nil) (point))))
- (skip-syntax-backward "\\s " limit)
+ (if (> limit (point))
+ (save-excursion (beginning-of-line) (setq limit (point))))
+ (skip-syntax-backward " " limit)
(if (re-search-backward
- (format "[;&|]+[\\s ]*\\(%s\\)" shell-command-regexp) limit 'move arg)
+ (format "[;&|]+[\t ]*\\(%s\\)" shell-command-regexp) limit 'move arg)
(progn (goto-char (match-beginning 1))
- (skip-syntax-backward "^\\s ")))))
-
-
-(defun shell-get-current-command ()
- "Function that returns the current command including arguments."
- (save-excursion
- (if (looking-at "\\s *[^;&|]")
- (goto-char (match-end 0)))
- (buffer-substring
- (progn (shell-backward-command 1) (point))
- (progn (shell-forward-command 1) (if (eolp) (point) (match-end 1))))))
-
-
-(defun shell-after-partial-filename ()
- "Returns t if point is after a file name.
-File names are assumed to contain `/'s or not be the first item in the command.
-
-See also `shell-backward-command'."
- (let ((filename (comint-match-partial-filename)))
- (or (save-match-data (string-match "/" filename))
- (not (eq (match-beginning 0)
- (save-excursion (shell-backward-command 1) (point)))))))
+ (skip-chars-forward ";&|")))))
(defun shell-dynamic-complete-command ()
path.
Completion is dependent on the value of `shell-completion-execonly', plus
-those that effect file completion. See `comint-dynamic-complete-filename'."
+those that effect file completion. See `shell-dynamic-complete-as-command'.
+
+Returns t if successful."
(interactive)
- (let* ((completion-ignore-case nil)
- (filename (comint-match-partial-filename))
+ (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
- (mapconcat (function (lambda (x) (concat (regexp-quote x) "$")))
- completion-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 file (car comps-in-path)
filepath (concat path file))
(if (and (not (member file completions))
- (not (string-match ignored-extensions file))
+ (not (and ignored-extensions
+ (string-match ignored-extensions file)))
(or (string-equal path cwd)
(not (file-directory-p filepath)))
(or (null shell-completion-execonly)
(setq comps-in-path (cdr comps-in-path)))
(setq paths (cdr paths)))
;; OK, we've got a list of completions.
- (cond ((null completions)
- (message "No completions of %s" filename)
- (ding))
- ((= 1 (length completions)) ; Gotcha!
- (let ((completion (car completions)))
- (if (string-equal completion pathnondir)
- (message "Sole completion")
- (insert (substring (directory-file-name completion)
- (length pathnondir)))
- (message "Completed"))
- (if comint-completion-addsuffix
- (insert (if (file-directory-p completion) "/" " ")))))
- (t ; There's no unique completion.
- (let ((completion
- (try-completion pathnondir (mapcar (function (lambda (x)
- (list x)))
- completions))))
- ;; Insert the longest substring.
- (insert (substring (directory-file-name completion)
- (length pathnondir)))
- (cond ((and comint-completion-recexact comint-completion-addsuffix
- (string-equal pathnondir completion)
- (member completion completions))
- ;; It's not unique, but user wants shortest match.
- (insert (if (file-directory-p completion) "/" " "))
- (message "Completed shortest"))
- ((or comint-completion-autolist
- (string-equal pathnondir completion))
- ;; It's not unique, list possible completions.
- (comint-dynamic-list-completions completions))
- (t
- (message "Partially completed"))))))))
-\f
-;;; Do the user's customization...
-;;;
-;;; Isn't this what eval-after-load is for?
-;;;(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)
+ (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 variable at point, or nil if non 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