;;; shell.el --- specialized comint.el for running the shell
-;; Copyright (C) 1988, 93, 94, 95, 96, 1997, 2000 Free Software Foundation, Inc.
+;; Copyright (C) 1988, 1993, 1994, 1995, 1996, 1997, 2000,
+;; 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
;; Author: Olin Shivers <shivers@cs.cmu.edu>
;; Simon Marshall <simon@gnu.org>
;; 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.
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
;;; Commentary:
;; - Olin Shivers (shivers@cs.cmu.edu)
;; - Simon Marshall (simon@gnu.org)
-;; 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
+;; This file defines 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-
;;; Customization and Buffer Variables
(defgroup shell nil
- "Running shell from within Emacs buffers"
+ "Running shell from within Emacs buffers."
:group 'processes
:group 'unix)
(defgroup shell-directories nil
- "Directory support in shell mode"
+ "Directory support in shell mode."
:group 'shell)
(defgroup shell-faces nil
- "Faces in shell buffers"
+ "Faces in shell buffers."
:group 'shell)
;;;###autoload
(defcustom 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
+This variable is used to initialize `comint-prompt-regexp' in the
shell buffer.
-This variable is only used if the variable
-`comint-use-prompt-regexp-instead-of-fields' is non-nil.
+If `comint-use-prompt-regexp' is nil, then this variable is only used
+to determine paragraph boundaries. See Info node `Shell Prompts' for
+how Shell mode treats paragraphs.
The pattern should probably not match more than one line. If it does,
Shell mode may become confused trying to distinguish prompt from input
:group 'shell)
(defvar shell-delimiter-argument-list '(?\| ?& ?< ?> ?\( ?\) ?\;)
- "List of characters to recognise as separate arguments.
+ "List of characters to recognize as separate arguments.
This variable is used to initialize `comint-delimiter-argument-list' in the
shell buffer. The value may depend on the operating system or shell.
This is a fine thing to set in your `.emacs' file.")
(defvar shell-file-name-chars
- (if (memq system-type '(ms-dos windows-nt))
+ (if (memq system-type '(ms-dos windows-nt cygwin))
"~/A-Za-z0-9_^$!#%&{}@`'.,:()-"
- "~/A-Za-z0-9+@:_.$#%,={}-")
+ "[]~/A-Za-z0-9+@:_.$#%,={}-")
"String of characters valid in a file name.
This variable is used to initialize `comint-file-name-chars' in the
shell buffer. The value may depend on the operating system or shell.
(defvar shell-file-name-quote-list
(if (memq system-type '(ms-dos windows-nt))
nil
- (append shell-delimiter-argument-list '(?\ ?\* ?\! ?\" ?\' ?\` ?\#)))
+ (append shell-delimiter-argument-list '(?\s ?\* ?\! ?\" ?\' ?\` ?\# ?\\)))
"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 value may depend on the operating system or shell.
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
+This variable is used to initialize `comint-dynamic-complete-functions' in the
shell buffer.
This is a fine thing to set in your `.emacs' file.")
:type 'regexp
:group 'shell)
+(defcustom shell-command-separator-regexp "[;&|\n \t]*"
+ "*Regexp to match a single command within a pipeline.
+This is used for directory tracking and does not do a perfect job."
+ :type 'regexp
+ :group 'shell)
+
(defcustom shell-completion-execonly t
"*If non-nil, use executable files only for completion candidates.
This mirrors the optional behavior of tcsh.
:type '(repeat (string :tag "Argument"))
:group 'shell)
+(defcustom explicit-bash-args
+ ;; Tell bash not to use readline, except for bash 1.x which doesn't grook --noediting.
+ ;; Bash 1.x has -nolineediting, but process-send-eof cannot terminate bash if we use it.
+ (let* ((prog (or (and (boundp 'explicit-shell-file-name) explicit-shell-file-name)
+ (getenv "ESHELL") shell-file-name))
+ (name (file-name-nondirectory prog)))
+ (if (and (not purify-flag)
+ (equal name "bash")
+ (file-executable-p prog)
+ (string-match "bad option"
+ (shell-command-to-string (concat prog " --noediting"))))
+ '("-i")
+ '("--noediting" "-i")))
+ "*Args passed to inferior shell by M-x shell, if the shell is bash.
+Value is a list of strings, which may be nil."
+ :type '(repeat (string :tag "Argument"))
+ :group 'shell)
+
(defcustom 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).
(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" 'shell-pcomplete)
- (define-key shell-mode-map "\M-\t" 'shell-pcomplete-reverse)
+ (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]
- (cons "Complete"
+ (cons "Complete"
(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" .
`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
+Variable `shell-completion-fignore' is used to initialize 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.
+the initialization 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'
(setq comint-delimiter-argument-list shell-delimiter-argument-list)
(setq comint-file-name-chars shell-file-name-chars)
(setq comint-file-name-quote-list shell-file-name-quote-list)
+ (setq comint-dynamic-complete-functions shell-dynamic-complete-functions)
+ (set (make-local-variable 'paragraph-separate) "\\'")
(make-local-variable 'paragraph-start)
(setq paragraph-start comint-prompt-regexp)
(make-local-variable 'font-lock-defaults)
(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)
- (file-truename "/dev/null")))
- (setq comint-input-ring-file-name nil))
- ;; Arrange to write out the input ring on exit, if the shell doesn't
- ;; do this itself.
- (if (and comint-input-ring-file-name
- (string-match shell-dumb-shell-regexp shell))
- (set-process-sentinel (get-buffer-process (current-buffer))
- #'shell-write-history-on-exit))
- (setq shell-dirstack-query
- (cond ((string-equal shell "sh") "pwd")
- ((string-equal shell "ksh") "echo $PWD ~-")
- (t "dirs"))))
- (comint-read-input-ring t))
+ (when (ring-empty-p comint-input-ring)
+ (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)
+ (file-truename "/dev/null")))
+ (setq comint-input-ring-file-name nil))
+ ;; Arrange to write out the input ring on exit, if the shell doesn't
+ ;; do this itself.
+ (if (and comint-input-ring-file-name
+ (string-match shell-dumb-shell-regexp shell))
+ (set-process-sentinel (get-buffer-process (current-buffer))
+ #'shell-write-history-on-exit))
+ (setq shell-dirstack-query
+ (cond ((string-equal shell "sh") "pwd")
+ ((string-equal shell "ksh") "echo $PWD ~-")
+ (t "dirs")))
+ ;; Bypass a bug in certain versions of bash.
+ (when (string-equal shell "bash")
+ (add-hook 'comint-output-filter-functions
+ 'shell-filter-ctrl-a-ctrl-b nil t)))
+ (comint-read-input-ring t)))
+
+(defun shell-filter-ctrl-a-ctrl-b (string)
+ "Remove `^A' and `^B' characters from comint output.
+
+Bash uses these characters as internal quoting characters in its
+prompt. Due to a bug in some bash versions (including 2.03,
+2.04, and 2.05b), they may erroneously show up when bash is
+started with the `--noediting' option and Select Graphic
+Rendition (SGR) control sequences (formerly known as ANSI escape
+sequences) are used to color the prompt.
+
+This function can be put on `comint-output-filter-functions'.
+The argument STRING is ignored."
+ (let ((pmark (process-mark (get-buffer-process (current-buffer)))))
+ (save-excursion
+ (goto-char (or comint-last-output-start (point-min)))
+ (while (re-search-forward "[\C-a\C-b]" pmark t)
+ (replace-match "")))))
(defun shell-write-history-on-exit (process event)
"Called when the shell process is stopped.
(interactive
(list
(and current-prefix-arg
- (read-buffer "Shell buffer: " "*shell*"))))
+ (read-buffer "Shell buffer: "
+ (generate-new-buffer-name "*shell*")))))
(setq buffer (get-buffer-create (or buffer "*shell*")))
;; Pop to buffer, so that the buffer's window will be correctly set
;; when we call comint (so that comint sets the COLUMNS env var properly).
(name (file-name-nondirectory prog))
(startfile (concat "~/.emacs_" name))
(xargs-name (intern-soft (concat "explicit-" name "-args"))))
+ (if (not (file-exists-p startfile))
+ (setq startfile (concat "~/.emacs.d/.emacs_" name)))
(apply 'make-comint-in-buffer "shell" buffer prog
(if (file-exists-p startfile) startfile)
(if (and xargs-name (boundp xargs-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
+ (let ((start (progn (string-match
+ (concat "^" shell-command-separator-regexp)
+ str) ; skip whitespace
(match-end 0)))
end cmd arg1)
(while (string-match shell-command-regexp str start)
"\\)\\($\\|[ \t]\\)")
cmd))
(shell-process-cd (comint-substitute-in-file-name cmd))))
- (setq start (progn (string-match "[; \t]*" str end) ; skip again
+ (setq start (progn (string-match shell-command-separator-regexp
+ str end)
+ ;; skip again
(match-end 0)))))
(error "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)))
+ (string-to-number str)))
(defun shell-dirtrack-mode ()
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
+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")
+ ;; If the process echoes commands, don't insert a fake command in
+ ;; the buffer or it will appear twice.
+ (unless comint-process-echoes
+ (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
+ (let ((pt (point))
+ (regexp
+ (concat
+ (if comint-process-echoes
+ ;; Skip command echo if the process echoes
+ (concat "\\(" (regexp-quote shell-dirstack-query) "\n\\)")
+ "\\(\\)")
+ "\\(.+\n\\)")))
;; This extra newline prevents the user's pending input from spoofing us.
(insert "\n") (backward-char 1)
- (while (not (looking-at ".+\n"))
+ ;; Wait for one line.
+ (while (not (looking-at regexp))
(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))))
+ (let* ((dl (buffer-substring (match-beginning 2) (1- (match-end 2))))
(dl-len (length dl))
(ds '()) ; new dir stack
(i 0))
(progn (goto-char (match-beginning 1))
(skip-chars-forward ";&|")))))
-(defun shell-pcomplete ()
- "Cycle forwards through completions at point, using `pcomplete'.
-This function merely invokes `pcomplete', after ensuring this buffer
-is set up for it."
- (interactive)
- (unless (prog1 shell-pcomplete-setup-p
- (setq shell-pcomplete-setup-p t))
- (pcomplete-comint-setup 'shell-dynamic-complete-functions))
- ;; Convince pcomplete we are calling it directly
- (setq this-command 'pcomplete)
- (call-interactively #'pcomplete))
-
-(defun shell-pcomplete-reverse ()
- "Cycle backwards through completions at point, using `pcomplete'.
-This function merely invokes `pcomplete-reverse', after ensuring this
-buffer is set up for it."
- (interactive)
- (unless (prog1 shell-pcomplete-setup-p
- (setq shell-pcomplete-setup-p t))
- (pcomplete-comint-setup 'shell-dynamic-complete-functions))
- ;; Convince pcomplete we are calling it directly
- (setq this-command 'pcomplete-reverse)
- (call-interactively #'pcomplete-reverse))
-
(defun shell-dynamic-complete-command ()
"Dynamically complete the command at point.
This function is similar to `comint-dynamic-complete-filename', except that it
"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)))
+ (filenondir (file-name-nondirectory filename))
+ (path-dirs (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)))
+ (dir "") (comps-in-dir ())
+ (file "") (abs-file-name "") (completions ()))
+ ;; Go thru each dir in the search path, finding completions.
+ (while path-dirs
+ (setq dir (file-name-as-directory (comint-directory (or (car path-dirs) ".")))
+ comps-in-dir (and (file-accessible-directory-p dir)
+ (file-name-all-completions filenondir dir)))
;; 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))
+ (while comps-in-dir
+ (setq file (car comps-in-dir)
+ abs-file-name (concat dir 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 (string-equal dir cwd)
+ (not (file-directory-p abs-file-name)))
(or (null shell-completion-execonly)
- (file-executable-p filepath)))
+ (file-executable-p abs-file-name)))
(setq completions (cons file completions)))
- (setq comps-in-path (cdr comps-in-path)))
- (setq paths (cdr paths)))
+ (setq comps-in-dir (cdr comps-in-dir)))
+ (setq path-dirs (cdr path-dirs)))
;; OK, we've got a list of completions.
(let ((success (let ((comint-completion-addsuffix nil))
- (comint-dynamic-simple-complete pathnondir completions))))
+ (comint-dynamic-simple-complete filenondir completions))))
(if (and (memq success '(sole shortest)) comint-completion-addsuffix
(not (file-directory-p (comint-match-partial-filename))))
(insert " "))
(let ((stack (cons default-directory shell-dirstack))
(index (cond ((looking-at "=-/?")
(length shell-dirstack))
- ((looking-at "=\\([0-9]+\\)")
+ ((looking-at "=\\([0-9]+\\)/?")
(string-to-number
(buffer-substring
(match-beginning 1) (match-end 1)))))))
(provide 'shell)
+;;; arch-tag: bcb5f12a-c1f4-4aea-a809-2504bd5bd797
;;; shell.el ends here