-;;; shell.el --- specialized comint.el for running the shell.
+;;; shell.el --- specialized comint.el for running the shell
;; Copyright (C) 1988, 93, 94, 95, 96, 1997, 2000 Free Software Foundation, Inc.
-;; Author: Olin Shivers <shivers@cs.cmu.edu> then
+;; Author: Olin Shivers <shivers@cs.cmu.edu>
;; Simon Marshall <simon@gnu.org>
;; Maintainer: FSF
;; Keywords: processes
;; - 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-
-;; a-buffer mode (comint mode), it shares a common base functionality,
+;; 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 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
+;; 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?
;; ;; 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)
;; compatibility.
;; Read the rest of this file for more information.
-\f
+
;;; Code:
(require 'comint)
(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 initialise `comint-prompt-regexp' in the
shell buffer.
This variable is only used if the variable
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 '(?\ ?\* ?\! ?\" ?\' ?\` ?\# ?\\)))
"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.
: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.
:group 'shell-directories)
(defcustom shell-chdrive-regexp
- (if (memq system-type '(ms-dos windows-nt))
+ (if (memq system-type '(ms-dos windows-nt))
; NetWare allows the five chars between upper and lower alphabetics.
"[]a-zA-Z^_`\\[\\\\]:"
nil)
: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).
(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])))
+ (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" .
shell-dynamic-complete-environment-variable)
("^[^ \t\n]+:.*" . font-lock-string-face)
("^\\[[1-9][0-9]*\\]" . font-lock-string-face))
"Additional expressions to highlight in Shell mode.")
-\f
+
;;; Basic Procedures
(put 'shell-mode 'mode-class 'special)
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
+\\[dirs] queries the shell and resyncs Emacs' idea of what the current
directory stack is.
\\[dirtrack-mode] turns directory tracking on and off.
`comint-input-filter-functions' are run. After each shell output, the hooks
on `comint-output-filter-functions' are run.
-Variables `shell-cd-regexp', `shell-chdrive-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'
+Variables `shell-cd-regexp', `shell-chdrive-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',
(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.
Writes the input history to a history file
-`comint-comint-input-ring-file-name' using `comint-write-input-ring'
+`comint-input-ring-file-name' using `comint-write-input-ring'
and inserts a short message in the shell buffer.
This function is a sentinel watching the shell interpreter process.
Sentinels will always get the two parameters PROCESS and EVENT."
;; Write history.
(comint-write-input-ring)
- (if (buffer-live-p (process-buffer process))
- (insert (format "\nProcess %s %s\n" process event))))
-\f
+ (let ((buf (process-buffer process)))
+ (when (buffer-live-p buf)
+ (with-current-buffer buf
+ (insert (format "\nProcess %s %s\n" process event))))))
+
;;;###autoload
(defun shell (&optional buffer)
"Run an inferior shell, with I/O through BUFFER (which defaults to `*shell*').
(interactive
(list
(and current-prefix-arg
- (read-buffer "Shell buffer: " "*shell*"))))
- (when (null buffer)
- (setq buffer "*shell*"))
- (if (not (comint-check-proc buffer))
- (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-in-buffer "shell" buffer 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 buffer)))
+ (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).
+ (pop-to-buffer buffer)
+ (unless (comint-check-proc buffer)
+ (let* ((prog (or explicit-shell-file-name
+ (getenv "ESHELL") shell-file-name))
+ (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))
+ (symbol-value xargs-name)
+ '("-i")))
+ (shell-mode)))
+ buffer)
;;; 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
;;;
;;; 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,
+;;; 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
If emacs gets confused, you can resync with the shell with M-x dirs.
See variables `shell-cd-regexp', `shell-chdrive-regexp', `shell-pushd-regexp',
-and `shell-popd-regexp', while `shell-pushd-tohome', `shell-pushd-dextract',
+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
+ (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"))))
(cond ((> num (length shell-dirstack))
(message "Directory stack not that deep."))
((= num 0)
- (error (message "Couldn't cd.")))
+ (error (message "Couldn't cd")))
(shell-pushd-dextract
(let ((dir (nth (1- num) shell-dirstack)))
(shell-process-popd arg)
(defun shell-resync-dirs ()
"Resync the buffer's idea of the current directory stack.
-This command queries the shell with the command bound to
+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.
(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 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"))
+ (while (not (looking-at
+ (concat "\\(" ; skip literal echo in case of stty echo
+ (regexp-quote shell-dirstack-query)
+ "\n\\)?" ; skip if present
+ "\\(" ".+\n" "\\)")) ) ; what to actually look for
(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))
(setq shell-dirstack (cdr ds)
shell-last-dir (car shell-dirstack))
(shell-dirstack-message))
- (error (message "Couldn't cd.")))))))
+ (error (message "Couldn't cd")))))))
;;; For your typing convenience:
(defalias 'dirs 'shell-resync-dirs)
(setq msg (concat msg (directory-file-name dir) " "))
(setq ds (cdr ds))))
(message "%s" msg))))
-\f
+
;; This was mostly copied from shell-resync-dirs.
(defun shell-snarf-envar (var)
"Return as a string the shell's value of environment variable VAR."
(interactive (list (read-envvar-name "\
Copy Shell environment variable to Emacs: ")))
(setenv variable (shell-snarf-envar variable)))
-\f
+
(defun shell-forward-command (&optional arg)
"Move forward across ARG shell command(s). Does not cross lines.
See `shell-command-regexp'."
(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
"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)))))))
(cond ((null index)
nil)
((>= index (length stack))
- (error "Directory stack not that deep."))
+ (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)
+;;; arch-tag: bcb5f12a-c1f4-4aea-a809-2504bd5bd797
;;; shell.el ends here