2011-04-20 22:31:06 +00:00
|
|
|
;;; shell.el --- specialized comint.el for running the shell -*- lexical-binding: t -*-
|
1994-04-14 22:49:23 +00:00
|
|
|
|
2014-01-01 07:43:34 +00:00
|
|
|
;; Copyright (C) 1988, 1993-1997, 2000-2014 Free Software Foundation,
|
|
|
|
;; Inc.
|
1992-07-22 03:58:44 +00:00
|
|
|
|
2001-07-14 11:21:08 +00:00
|
|
|
;; Author: Olin Shivers <shivers@cs.cmu.edu>
|
1999-08-16 04:04:27 +00:00
|
|
|
;; Simon Marshall <simon@gnu.org>
|
2014-02-10 01:34:22 +00:00
|
|
|
;; Maintainer: emacs-devel@gnu.org
|
1992-07-17 20:24:00 +00:00
|
|
|
;; Keywords: processes
|
1992-07-15 21:31:44 +00:00
|
|
|
|
1994-04-14 22:49:23 +00:00
|
|
|
;; This file is part of GNU Emacs.
|
1992-05-30 21:11:25 +00:00
|
|
|
|
2008-05-06 08:06:51 +00:00
|
|
|
;; GNU Emacs is free software: you can redistribute it and/or modify
|
1994-04-14 22:49:23 +00:00
|
|
|
;; it under the terms of the GNU General Public License as published by
|
2008-05-06 08:06:51 +00:00
|
|
|
;; the Free Software Foundation, either version 3 of the License, or
|
|
|
|
;; (at your option) any later version.
|
1992-05-30 21:11:25 +00:00
|
|
|
|
1994-04-14 22:49:23 +00:00
|
|
|
;; 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.
|
1992-05-30 21:11:25 +00:00
|
|
|
|
1994-04-14 22:49:23 +00:00
|
|
|
;; You should have received a copy of the GNU General Public License
|
2008-05-06 08:06:51 +00:00
|
|
|
;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
|
1990-11-05 10:06:02 +00:00
|
|
|
|
1992-07-15 21:31:44 +00:00
|
|
|
;;; Commentary:
|
|
|
|
|
2002-07-03 12:01:24 +00:00
|
|
|
;; 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
|
1996-01-14 07:34:30 +00:00
|
|
|
;; featureful, robust, and uniform than the Emacs 18 version.
|
1990-11-05 10:06:02 +00:00
|
|
|
|
1996-01-14 07:34:30 +00:00
|
|
|
;; Since this mode is built on top of the general command-interpreter-in-
|
2001-01-28 03:43:35 +00:00
|
|
|
;; a-buffer mode (comint mode), it shares a common base functionality,
|
1996-01-14 07:34:30 +00:00
|
|
|
;; and a common set of bindings, with all modes derived from comint mode.
|
|
|
|
;; This makes these modes easier to use.
|
1990-11-05 10:06:02 +00:00
|
|
|
|
1996-01-14 07:34:30 +00:00
|
|
|
;; For documentation on the functionality provided by comint mode, and
|
2011-12-12 05:32:49 +00:00
|
|
|
;; the hooks available for customizing it, see the file comint.el.
|
1996-01-14 07:34:30 +00:00
|
|
|
;; For further information on shell mode, see the comments below.
|
1990-11-05 10:06:02 +00:00
|
|
|
|
1996-01-14 07:34:30 +00:00
|
|
|
;; Needs fixin:
|
2001-01-28 03:43:35 +00:00
|
|
|
;; When sending text from a source file to a subprocess, the process-mark can
|
1996-01-14 07:34:30 +00:00
|
|
|
;; 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?
|
1990-11-05 10:06:02 +00:00
|
|
|
|
1991-05-08 07:47:45 +00:00
|
|
|
;; YOUR .EMACS FILE
|
|
|
|
;;=============================================================================
|
2012-09-17 05:41:04 +00:00
|
|
|
;; Some suggestions for your init file.
|
1991-05-08 07:47:45 +00:00
|
|
|
;;
|
1995-02-21 13:07:23 +00:00
|
|
|
;; ;; Define M-# to run some strange command:
|
|
|
|
;; (eval-after-load "shell"
|
|
|
|
;; '(define-key shell-mode-map "\M-#" 'shells-dynamic-spell))
|
2001-01-28 03:43:35 +00:00
|
|
|
|
1996-01-14 07:34:30 +00:00
|
|
|
;; Brief Command Documentation:
|
|
|
|
;;============================================================================
|
|
|
|
;; Comint Mode Commands: (common to shell and all comint-derived modes)
|
|
|
|
;;
|
1998-06-28 22:43:25 +00:00
|
|
|
;; m-p comint-previous-input Cycle backwards in input history
|
|
|
|
;; m-n comint-next-input Cycle forwards
|
1996-01-14 07:34:30 +00:00
|
|
|
;; m-r comint-previous-matching-input Previous input matching a regexp
|
|
|
|
;; m-s comint-next-matching-input Next input that matches
|
1998-06-28 22:43:25 +00:00
|
|
|
;; m-c-l comint-show-output Show last batch of process output
|
1996-01-14 07:34:30 +00:00
|
|
|
;; return comint-send-input
|
1998-06-28 22:43:25 +00:00
|
|
|
;; c-d comint-delchar-or-maybe-eof Delete char unless at end of buff.
|
1996-01-14 07:34:30 +00:00
|
|
|
;; c-c c-a comint-bol Beginning of line; skip prompt
|
1998-06-28 22:43:25 +00:00
|
|
|
;; 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 ^\
|
Remove some functions, variables and aliases obsolete since at least 21.1.
* doc/misc/misc.texi (Shell Mode): Remove reference to old function name.
* src/character.c (Fchar_bytes): Remove obsolete function.
(syms_of_character): Remove Schar_bytes.
* lisp/subr.el (char-bytes): Remove obsolete function.
* lisp/emacs-lisp/checkdoc.el (checkdoc-minor-keymap): Remove obsolete alias.
* lisp/isearch.el (isearch-return-char): Remove obsolete function.
* lisp/mouse.el: No longer provide mldrag.
(mldrag-drag-mode-line, mldrag-drag-vertical-line):
Remove obsolete aliases.
* lisp/comint.el (comint-kill-output): Remove obsolete alias.
* lisp/shell.el: Comment fix.
* lisp/composite.el (decompose-composite-char): Remove obsolete function.
* lisp/ps-def.el (decompose-composite-char): Remove unused function.
* lisp/iswitchb.el (iswitchb-default-keybindings): Remove obsolete function.
* lisp/outline.el (outline-visible): Remove obsolete function.
* lisp/term/pc-win.el (x-frob-font-slant, x-frob-font-weight):
* lisp/faces.el (internal-find-face, internal-get-face)
(frame-update-faces, frame-update-face-colors)
(x-frob-font-weight, x-frob-font-slant)
(internal-frob-font-weight, internal-frob-font-slant)
(x-make-font-bold, x-make-font-demibold, x-make-font-unbold)
(x-make-font-italic, x-make-font-oblique, x-make-font-unitalic)
(x-make-font-bold-italic): Remove functions and aliases, obsolete
since Emacs 21.1.
* lisp/emulation/viper-util.el (viper-get-face):
* lisp/obsolete/lucid.el (find-face, get-face): Use facep.
* lisp/vc/ediff-init.el (ediff-valid-color-p, ediff-get-face):
Remove unused functions.
* lisp/vc/ediff-util.el (ediff-submit-report): Doc fix.
* etc/NEWS: Mention above changes.
2010-10-02 02:46:13 +00:00
|
|
|
;; c-c c-o comint-delete-output Delete last batch of process output
|
1998-06-28 22:43:25 +00:00
|
|
|
;; c-c c-r comint-show-output Show last batch of process output
|
1999-05-17 06:14:44 +00:00
|
|
|
;; c-c c-l comint-dynamic-list-input-ring List input history
|
1996-01-14 07:34:30 +00:00
|
|
|
;; send-invisible Read line w/o echo & send to proc
|
1998-06-28 22:43:25 +00:00
|
|
|
;; comint-continue-subjob Useful if you accidentally suspend
|
1996-01-14 07:34:30 +00:00
|
|
|
;; top-level job
|
|
|
|
;; comint-mode-hook is the comint mode hook.
|
|
|
|
|
|
|
|
;; Shell Mode Commands:
|
|
|
|
;; shell Fires up the shell process
|
2011-04-20 22:31:06 +00:00
|
|
|
;; tab completion-at-point Complete filename/command/history
|
1996-01-14 07:34:30 +00:00
|
|
|
;; 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
|
1998-06-28 22:43:25 +00:00
|
|
|
;; dirs Resync the buffer's dir stack
|
2007-10-27 22:15:27 +00:00
|
|
|
;; shell-dirtrack-mode Turn dir tracking on/off
|
1996-01-14 07:34:30 +00:00
|
|
|
;; comint-strip-ctrl-m Remove trailing ^Ms from output
|
|
|
|
;;
|
|
|
|
;; The shell mode hook is shell-mode-hook
|
2011-11-20 02:29:42 +00:00
|
|
|
;; comint-prompt-regexp is initialized to shell-prompt-pattern, for backwards
|
1996-01-14 07:34:30 +00:00
|
|
|
;; compatibility.
|
1991-05-08 07:47:45 +00:00
|
|
|
|
1996-01-14 07:34:30 +00:00
|
|
|
;; Read the rest of this file for more information.
|
2001-01-28 03:43:35 +00:00
|
|
|
|
1992-07-15 21:31:44 +00:00
|
|
|
;;; Code:
|
|
|
|
|
|
|
|
(require 'comint)
|
2011-06-04 12:31:34 +00:00
|
|
|
(require 'pcomplete)
|
1992-07-15 21:31:44 +00:00
|
|
|
|
1996-01-14 07:34:30 +00:00
|
|
|
;;; Customization and Buffer Variables
|
|
|
|
|
1997-04-13 02:39:56 +00:00
|
|
|
(defgroup shell nil
|
2005-07-04 02:28:54 +00:00
|
|
|
"Running shell from within Emacs buffers."
|
1997-04-13 02:39:56 +00:00
|
|
|
:group 'processes
|
|
|
|
:group 'unix)
|
|
|
|
|
|
|
|
(defgroup shell-directories nil
|
2005-07-04 02:28:54 +00:00
|
|
|
"Directory support in shell mode."
|
1997-04-13 02:39:56 +00:00
|
|
|
:group 'shell)
|
|
|
|
|
2013-05-15 23:55:41 +00:00
|
|
|
;; Unused.
|
|
|
|
;;; (defgroup shell-faces nil
|
|
|
|
;;; "Faces in shell buffers."
|
|
|
|
;;; :group 'shell)
|
1997-04-13 02:39:56 +00:00
|
|
|
|
1992-05-30 21:11:25 +00:00
|
|
|
;;;###autoload
|
* textmodes/tex-mode.el (tex-alt-dvi-print-command)
(tex-dvi-print-command, tex-bibtex-command, tex-start-commands)
(tex-start-options, slitex-run-command, latex-run-command)
(tex-run-command, tex-directory):
* textmodes/ispell.el (ispell-html-skip-alists)
(ispell-tex-skip-alists, ispell-tex-skip-alists):
* textmodes/fill.el (adaptive-fill-first-line-regexp):
(adaptive-fill-regexp):
* textmodes/dns-mode.el (auto-mode-alist):
* progmodes/python.el (interpreter-mode-alist):
* progmodes/etags.el (tags-compression-info-list):
* progmodes/etags.el (tags-file-name):
* net/browse-url.el (browse-url-galeon-program)
(browse-url-firefox-program):
* mail/sendmail.el (mail-signature-file)
(mail-citation-prefix-regexp):
* international/mule-conf.el (eight-bit):
* international/latexenc.el (latex-inputenc-coding-alist):
* international/fontset.el (x-pixel-size-width-font-regexp):
* emacs-lisp/warnings.el (warning-type-format):
* emacs-lisp/trace.el (trace-buffer):
* emacs-lisp/lisp-mode.el (lisp-interaction-mode-map)
(emacs-lisp-mode-map):
* calendar/holidays.el (holiday-solar-holidays)
(holiday-bahai-holidays, holiday-islamic-holidays)
(holiday-christian-holidays, holiday-hebrew-holidays)
(hebrew-holidays-4, hebrew-holidays-3, hebrew-holidays-2)
(hebrew-holidays-1, holiday-oriental-holidays)
(holiday-general-holidays):
* x-dnd.el (x-dnd-known-types):
* tool-bar.el (tool-bar):
* startup.el (site-run-file):
* shell.el (shell-dumb-shell-regexp):
* rfn-eshadow.el (file-name-shadow-tty-properties)
(file-name-shadow-properties):
* paths.el (remote-shell-program, news-directory):
* mouse.el ([C-down-mouse-3]):
* menu-bar.el (menu-bar-tools-menu):
* jka-cmpr-hook.el (jka-compr-load-suffixes)
(jka-compr-mode-alist-additions, jka-compr-compression-info-list)
(jka-compr-compression-info-list):
* isearch.el (search-whitespace-regexp):
* image-file.el (image-file-name-extensions):
* find-dired.el (find-ls-option):
* files.el (directory-listing-before-filename-regexp)
(directory-free-space-args, insert-directory-program)
(list-directory-brief-switches, magic-fallback-mode-alist)
(magic-fallback-mode-alist, auto-mode-interpreter-regexp)
(automount-dir-prefix):
* faces.el (face-x-resources, x-font-regexp, x-font-regexp-head)
(x-font-regexp-slant, x-font-regexp-weight, face-x-resources)
(face-font-registry-alternatives, face-font-registry-alternatives)
(face-font-family-alternatives):
* facemenu.el (facemenu-add-new-face, facemenu-background-menu)
(facemenu-foreground-menu, facemenu-face-menu):
* epa-hook.el (epa-file-name-regexp):
* dnd.el (dnd-protocol-alist):
* textmodes/rst.el (auto-mode-alist):
* button.el (default-button): Purecopy strings.
2009-11-06 05:16:23 +00:00
|
|
|
(defcustom shell-dumb-shell-regexp (purecopy "cmd\\(proxy\\)?\\.exe")
|
2001-01-27 12:43:56 +00:00
|
|
|
"Regexp to match shells that don't save their command history, and
|
|
|
|
don't handle the backslash as a quote character. For shells that
|
|
|
|
match this regexp, Emacs will write out the command history when the
|
|
|
|
shell finishes, and won't remove backslashes when it unquotes shell
|
|
|
|
arguments."
|
2000-09-14 21:15:44 +00:00
|
|
|
:type 'regexp
|
|
|
|
:group 'shell)
|
|
|
|
|
1998-11-22 15:33:21 +00:00
|
|
|
(defcustom shell-prompt-pattern "^[^#$%>\n]*[#$%>] *"
|
1991-05-08 07:47:45 +00:00
|
|
|
"Regexp to match prompts in the inferior shell.
|
1993-07-18 06:20:47 +00:00
|
|
|
Defaults to \"^[^#$%>\\n]*[#$%>] *\", which works pretty well.
|
2005-06-16 16:10:43 +00:00
|
|
|
This variable is used to initialize `comint-prompt-regexp' in the
|
1991-05-08 07:47:45 +00:00
|
|
|
shell buffer.
|
|
|
|
|
2005-04-26 23:16:20 +00:00
|
|
|
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.
|
2000-08-07 14:51:48 +00:00
|
|
|
|
1993-07-18 06:20:47 +00:00
|
|
|
The pattern should probably not match more than one line. If it does,
|
1996-02-03 13:38:32 +00:00
|
|
|
Shell mode may become confused trying to distinguish prompt from input
|
2012-09-17 05:01:10 +00:00
|
|
|
on lines which don't start with a prompt."
|
1998-11-22 15:33:21 +00:00
|
|
|
:type 'regexp
|
|
|
|
:group 'shell)
|
1991-05-08 07:47:45 +00:00
|
|
|
|
1997-04-13 02:39:56 +00:00
|
|
|
(defcustom shell-completion-fignore nil
|
2006-05-17 21:57:25 +00:00
|
|
|
"List of suffixes to be disregarded during file/command completion.
|
1994-03-08 17:43:07 +00:00
|
|
|
This variable is used to initialize `comint-completion-fignore' in the shell
|
|
|
|
buffer. The default is nil, for compatibility with most shells.
|
2012-09-17 05:01:10 +00:00
|
|
|
Some people like (\"~\" \"#\" \"%\")."
|
1997-04-13 02:39:56 +00:00
|
|
|
:type '(repeat (string :tag "Suffix"))
|
|
|
|
:group 'shell)
|
1994-03-08 17:43:07 +00:00
|
|
|
|
2012-02-15 08:00:23 +00:00
|
|
|
(defcustom shell-delimiter-argument-list '(?\| ?& ?< ?> ?\( ?\) ?\;)
|
2005-06-16 16:10:43 +00:00
|
|
|
"List of characters to recognize as separate arguments.
|
1994-03-02 22:02:56 +00:00
|
|
|
This variable is used to initialize `comint-delimiter-argument-list' in the
|
2011-02-17 05:02:02 +00:00
|
|
|
shell buffer. The value may depend on the operating system or shell."
|
|
|
|
:type '(choice (const nil)
|
|
|
|
(repeat :tag "List of characters" character))
|
|
|
|
:group 'shell)
|
1996-07-12 07:34:20 +00:00
|
|
|
|
2012-09-17 05:01:10 +00:00
|
|
|
(defcustom shell-file-name-chars
|
2003-01-31 15:24:20 +00:00
|
|
|
(if (memq system-type '(ms-dos windows-nt cygwin))
|
1998-04-17 05:25:04 +00:00
|
|
|
"~/A-Za-z0-9_^$!#%&{}@`'.,:()-"
|
2003-12-29 19:13:28 +00:00
|
|
|
"[]~/A-Za-z0-9+@:_.$#%,={}-")
|
1996-08-01 22:35:03 +00:00
|
|
|
"String of characters valid in a file name.
|
|
|
|
This variable is used to initialize `comint-file-name-chars' in the
|
2012-09-17 05:01:10 +00:00
|
|
|
shell buffer. The value may depend on the operating system or shell."
|
|
|
|
:type 'string
|
|
|
|
:group 'shell)
|
1993-10-22 02:53:24 +00:00
|
|
|
|
2012-09-17 05:01:10 +00:00
|
|
|
(defcustom shell-file-name-quote-list
|
1996-07-12 07:34:20 +00:00
|
|
|
(if (memq system-type '(ms-dos windows-nt))
|
|
|
|
nil
|
2008-08-27 17:04:23 +00:00
|
|
|
(append shell-delimiter-argument-list '(?\s ?$ ?\* ?\! ?\" ?\' ?\` ?\# ?\\)))
|
1995-04-03 13:01:15 +00:00
|
|
|
"List of characters to quote when in a file name.
|
|
|
|
This variable is used to initialize `comint-file-name-quote-list' in the
|
2012-09-17 05:01:10 +00:00
|
|
|
shell buffer. The value may depend on the operating system or shell."
|
|
|
|
:type '(repeat character)
|
|
|
|
:group 'shell)
|
1995-04-03 13:01:15 +00:00
|
|
|
|
2012-09-17 05:01:10 +00:00
|
|
|
(defcustom shell-dynamic-complete-functions
|
2011-04-20 22:31:06 +00:00
|
|
|
'(comint-c-a-p-replace-by-expanded-history
|
|
|
|
shell-environment-variable-completion
|
|
|
|
shell-command-completion
|
|
|
|
shell-c-a-p-replace-by-expanded-directory
|
2012-01-05 14:51:05 +00:00
|
|
|
pcomplete-completions-at-point
|
2011-04-20 22:31:06 +00:00
|
|
|
shell-filename-completion
|
2012-01-05 14:51:05 +00:00
|
|
|
comint-filename-completion)
|
1994-03-03 23:37:27 +00:00
|
|
|
"List of functions called to perform completion.
|
2005-06-16 16:10:43 +00:00
|
|
|
This variable is used to initialize `comint-dynamic-complete-functions' in the
|
2012-09-17 05:01:10 +00:00
|
|
|
shell buffer."
|
|
|
|
:type '(repeat function)
|
|
|
|
:group 'shell)
|
1994-03-03 23:37:27 +00:00
|
|
|
|
1997-04-13 02:39:56 +00:00
|
|
|
(defcustom shell-command-regexp "[^;&|\n]+"
|
2006-05-17 21:57:25 +00:00
|
|
|
"Regexp to match a single command within a pipeline.
|
1997-04-13 02:39:56 +00:00
|
|
|
This is used for directory tracking and does not do a perfect job."
|
|
|
|
:type 'regexp
|
|
|
|
:group 'shell)
|
1993-10-22 02:53:24 +00:00
|
|
|
|
2003-06-12 22:20:49 +00:00
|
|
|
(defcustom shell-command-separator-regexp "[;&|\n \t]*"
|
2006-05-17 21:57:25 +00:00
|
|
|
"Regexp to match a single command within a pipeline.
|
2003-06-12 22:20:49 +00:00
|
|
|
This is used for directory tracking and does not do a perfect job."
|
|
|
|
:type 'regexp
|
|
|
|
:group 'shell)
|
|
|
|
|
1997-04-13 02:39:56 +00:00
|
|
|
(defcustom shell-completion-execonly t
|
2006-05-17 21:57:25 +00:00
|
|
|
"If non-nil, use executable files only for completion candidates.
|
1993-11-08 23:40:37 +00:00
|
|
|
This mirrors the optional behavior of tcsh.
|
1993-10-22 02:53:24 +00:00
|
|
|
|
1997-04-13 02:39:56 +00:00
|
|
|
Detecting executability of files may slow command completion considerably."
|
|
|
|
:type 'boolean
|
|
|
|
:group 'shell)
|
1993-10-22 02:53:24 +00:00
|
|
|
|
1997-04-13 02:39:56 +00:00
|
|
|
(defcustom shell-popd-regexp "popd"
|
2006-05-17 21:57:25 +00:00
|
|
|
"Regexp to match subshell commands equivalent to popd."
|
1997-04-13 02:39:56 +00:00
|
|
|
:type 'regexp
|
|
|
|
:group 'shell-directories)
|
1990-11-05 10:06:02 +00:00
|
|
|
|
1997-04-13 02:39:56 +00:00
|
|
|
(defcustom shell-pushd-regexp "pushd"
|
2006-05-17 21:57:25 +00:00
|
|
|
"Regexp to match subshell commands equivalent to pushd."
|
1997-04-13 02:39:56 +00:00
|
|
|
:type 'regexp
|
|
|
|
:group 'shell-directories)
|
1990-11-05 10:06:02 +00:00
|
|
|
|
1997-04-13 02:39:56 +00:00
|
|
|
(defcustom shell-pushd-tohome nil
|
2006-05-17 21:57:25 +00:00
|
|
|
"If non-nil, make pushd with no arg behave as \"pushd ~\" (like cd).
|
1997-04-13 02:39:56 +00:00
|
|
|
This mirrors the optional behavior of tcsh."
|
|
|
|
:type 'boolean
|
|
|
|
:group 'shell-directories)
|
1993-10-22 02:53:24 +00:00
|
|
|
|
1997-04-13 02:39:56 +00:00
|
|
|
(defcustom shell-pushd-dextract nil
|
2006-05-17 21:57:25 +00:00
|
|
|
"If non-nil, make \"pushd +n\" pop the nth dir to the stack top.
|
1997-04-13 02:39:56 +00:00
|
|
|
This mirrors the optional behavior of tcsh."
|
|
|
|
:type 'boolean
|
|
|
|
:group 'shell-directories)
|
1993-10-22 02:53:24 +00:00
|
|
|
|
1997-04-13 02:39:56 +00:00
|
|
|
(defcustom shell-pushd-dunique nil
|
2006-05-17 21:57:25 +00:00
|
|
|
"If non-nil, make pushd only add unique directories to the stack.
|
1997-04-13 02:39:56 +00:00
|
|
|
This mirrors the optional behavior of tcsh."
|
|
|
|
:type 'boolean
|
|
|
|
:group 'shell-directories)
|
1993-10-22 02:53:24 +00:00
|
|
|
|
1997-04-13 02:39:56 +00:00
|
|
|
(defcustom shell-cd-regexp "cd"
|
2006-05-17 21:57:25 +00:00
|
|
|
"Regexp to match subshell commands equivalent to cd."
|
1997-04-13 02:39:56 +00:00
|
|
|
:type 'regexp
|
|
|
|
:group 'shell-directories)
|
1990-11-05 10:06:02 +00:00
|
|
|
|
1997-04-13 02:39:56 +00:00
|
|
|
(defcustom shell-chdrive-regexp
|
2001-01-28 03:43:35 +00:00
|
|
|
(if (memq system-type '(ms-dos windows-nt))
|
1996-06-09 20:31:51 +00:00
|
|
|
; NetWare allows the five chars between upper and lower alphabetics.
|
|
|
|
"[]a-zA-Z^_`\\[\\\\]:"
|
|
|
|
nil)
|
2006-05-17 21:57:25 +00:00
|
|
|
"If non-nil, is regexp used to track drive changes."
|
1997-09-09 02:56:56 +00:00
|
|
|
:type '(choice regexp
|
|
|
|
(const nil))
|
1997-04-13 02:39:56 +00:00
|
|
|
:group 'shell-directories)
|
1996-06-09 20:31:51 +00:00
|
|
|
|
1999-01-14 10:31:31 +00:00
|
|
|
(defcustom shell-dirtrack-verbose t
|
2006-05-17 21:57:25 +00:00
|
|
|
"If non-nil, show the directory stack following directory change.
|
2007-10-27 22:15:27 +00:00
|
|
|
This is effective only if directory tracking is enabled.
|
2007-10-30 06:39:00 +00:00
|
|
|
The `dirtrack' package provides an alternative implementation of this feature -
|
|
|
|
see the function `dirtrack-mode'."
|
1999-01-14 10:31:31 +00:00
|
|
|
:type 'boolean
|
|
|
|
:group 'shell-directories)
|
|
|
|
|
1997-04-13 02:39:56 +00:00
|
|
|
(defcustom explicit-shell-file-name nil
|
2006-05-17 21:57:25 +00:00
|
|
|
"If non-nil, is file name to use for explicitly requested inferior shell."
|
1997-04-13 02:39:56 +00:00
|
|
|
:type '(choice (const :tag "None" nil) file)
|
|
|
|
:group 'shell)
|
1990-11-05 10:06:02 +00:00
|
|
|
|
2006-10-09 09:04:23 +00:00
|
|
|
;; Note: There are no explicit references to the variable `explicit-csh-args'.
|
|
|
|
;; It is used implicitly by M-x shell when the shell is `csh'.
|
1997-04-13 02:39:56 +00:00
|
|
|
(defcustom explicit-csh-args
|
1990-11-05 10:06:02 +00:00
|
|
|
(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"))
|
2006-05-17 21:57:25 +00:00
|
|
|
"Args passed to inferior shell by \\[shell], if the shell is csh.
|
1997-04-13 02:39:56 +00:00
|
|
|
Value is a list of strings, which may be nil."
|
|
|
|
:type '(repeat (string :tag "Argument"))
|
|
|
|
:group 'shell)
|
1990-11-05 10:06:02 +00:00
|
|
|
|
2006-10-09 09:04:23 +00:00
|
|
|
;; Note: There are no explicit references to the variable `explicit-bash-args'.
|
|
|
|
;; It is used implicitly by M-x shell when the interactive shell is `bash'.
|
2002-06-28 18:50:36 +00:00
|
|
|
(defcustom explicit-bash-args
|
2013-07-15 02:33:54 +00:00
|
|
|
;; Tell bash not to use readline. It's safe to assume --noediting now,
|
|
|
|
;; as it was introduced in 1996 in Bash version 2.
|
|
|
|
'("--noediting" "-i")
|
2006-05-17 21:57:25 +00:00
|
|
|
"Args passed to inferior shell by \\[shell], if the shell is bash.
|
2002-06-28 18:50:36 +00:00
|
|
|
Value is a list of strings, which may be nil."
|
|
|
|
:type '(repeat (string :tag "Argument"))
|
|
|
|
:group 'shell)
|
|
|
|
|
1997-04-13 02:39:56 +00:00
|
|
|
(defcustom shell-input-autoexpand 'history
|
2006-05-17 21:57:25 +00:00
|
|
|
"If non-nil, expand input command history references on completion.
|
1994-01-09 17:11:57 +00:00
|
|
|
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
|
2011-04-20 22:31:06 +00:00
|
|
|
`comint-dynamic-complete-functions'.
|
1994-01-09 17:11:57 +00:00
|
|
|
|
|
|
|
This variable supplies a default for `comint-input-autoexpand',
|
1997-04-13 02:39:56 +00:00
|
|
|
for Shell mode only."
|
1998-09-18 09:20:28 +00:00
|
|
|
:type '(choice (const :tag "off" nil)
|
|
|
|
(const input)
|
|
|
|
(const history)
|
|
|
|
(const :tag "on" t))
|
1998-10-17 15:29:39 +00:00
|
|
|
:group 'shell)
|
1994-01-09 17:11:57 +00:00
|
|
|
|
1990-11-05 10:06:02 +00:00
|
|
|
(defvar shell-dirstack nil
|
1992-05-30 21:11:25 +00:00
|
|
|
"List of directories saved by pushd in this buffer's shell.
|
|
|
|
Thus, this does not include the shell's current directory.")
|
1990-11-05 10:06:02 +00:00
|
|
|
|
1994-03-02 16:55:16 +00:00
|
|
|
(defvar shell-dirtrackp t
|
|
|
|
"Non-nil in a shell buffer means directory tracking is enabled.")
|
|
|
|
|
1993-03-25 01:55:24 +00:00
|
|
|
(defvar shell-last-dir nil
|
|
|
|
"Keep track of last directory for ksh `cd -' command.")
|
|
|
|
|
1994-04-24 10:50:41 +00:00
|
|
|
(defvar shell-dirstack-query nil
|
2007-03-04 17:47:19 +00:00
|
|
|
"Command used by `shell-resync-dirs' to query the shell.")
|
1990-11-05 10:06:02 +00:00
|
|
|
|
2010-10-10 23:12:30 +00:00
|
|
|
(defvar shell-mode-map
|
|
|
|
(let ((map (nconc (make-sparse-keymap) comint-mode-map)))
|
|
|
|
(define-key map "\C-c\C-f" 'shell-forward-command)
|
|
|
|
(define-key map "\C-c\C-b" 'shell-backward-command)
|
2011-04-20 22:31:06 +00:00
|
|
|
(define-key map "\t" 'completion-at-point)
|
2010-10-10 23:12:30 +00:00
|
|
|
(define-key map (kbd "M-RET") 'shell-resync-dirs)
|
|
|
|
(define-key map "\M-?" 'comint-dynamic-list-filename-completions)
|
|
|
|
(define-key map [menu-bar completion]
|
|
|
|
(cons "Complete"
|
|
|
|
(copy-keymap (lookup-key comint-mode-map [menu-bar completion]))))
|
|
|
|
(define-key-after (lookup-key map [menu-bar completion])
|
|
|
|
[complete-env-variable] '("Complete Env. Variable Name" .
|
|
|
|
shell-dynamic-complete-environment-variable)
|
|
|
|
'complete-file)
|
|
|
|
(define-key-after (lookup-key map [menu-bar completion])
|
|
|
|
[expand-directory] '("Expand Directory Reference" .
|
|
|
|
shell-replace-by-expanded-directory)
|
|
|
|
'complete-expand)
|
|
|
|
map))
|
1990-11-05 10:06:02 +00:00
|
|
|
|
1997-04-13 02:39:56 +00:00
|
|
|
(defcustom shell-mode-hook '()
|
2009-09-24 01:37:14 +00:00
|
|
|
"Hook for customizing Shell mode."
|
1997-04-13 02:39:56 +00:00
|
|
|
:type 'hook
|
|
|
|
:group 'shell)
|
1990-11-05 10:06:02 +00:00
|
|
|
|
1994-10-07 10:04:06 +00:00
|
|
|
(defvar shell-font-lock-keywords
|
2000-08-22 10:06:55 +00:00
|
|
|
'(("[ \t]\\([+-][^ \t\n]+\\)" 1 font-lock-comment-face)
|
1997-04-17 07:35:38 +00:00
|
|
|
("^[^ \t\n]+:.*" . font-lock-string-face)
|
|
|
|
("^\\[[1-9][0-9]*\\]" . font-lock-string-face))
|
1994-10-07 10:04:06 +00:00
|
|
|
"Additional expressions to highlight in Shell mode.")
|
2001-01-28 03:43:35 +00:00
|
|
|
|
1990-11-05 10:06:02 +00:00
|
|
|
;;; Basic Procedures
|
|
|
|
|
2012-05-15 16:58:35 +00:00
|
|
|
(defun shell--unquote&requote-argument (qstr &optional upos)
|
|
|
|
(unless upos (setq upos 0))
|
|
|
|
(let* ((qpos 0)
|
|
|
|
(dquotes nil)
|
|
|
|
(ustrs '())
|
|
|
|
(re (concat
|
|
|
|
"[\"']"
|
|
|
|
"\\|\\$\\(?:\\([[:alpha:]][[:alnum:]]*\\)"
|
|
|
|
"\\|{\\(?1:[^{}]+\\)}\\)"
|
|
|
|
(when (memq system-type '(ms-dos windows-nt))
|
|
|
|
"\\|%\\(?1:[^\\\\/]*\\)%")
|
|
|
|
(when comint-file-name-quote-list
|
|
|
|
"\\|\\\\\\(.\\)")))
|
|
|
|
(qupos nil)
|
|
|
|
(push (lambda (str end)
|
|
|
|
(push str ustrs)
|
|
|
|
(setq upos (- upos (length str)))
|
|
|
|
(unless (or qupos (> upos 0))
|
|
|
|
(setq qupos (if (< end 0) (- end) (+ upos end))))))
|
|
|
|
match)
|
|
|
|
(while (setq match (string-match re qstr qpos))
|
|
|
|
(funcall push (substring qstr qpos match) match)
|
|
|
|
(cond
|
|
|
|
((match-beginning 2) (funcall push (match-string 2 qstr) (match-end 0)))
|
|
|
|
((match-beginning 1) (funcall push (getenv (match-string 1 qstr))
|
|
|
|
(- (match-end 0))))
|
|
|
|
((eq (aref qstr match) ?\") (setq dquotes (not dquotes)))
|
|
|
|
((eq (aref qstr match) ?\')
|
|
|
|
(cond
|
|
|
|
(dquotes (funcall push "'" (match-end 0)))
|
|
|
|
((< match (1+ (length qstr)))
|
|
|
|
(let ((end (string-match "'" qstr (1+ match))))
|
|
|
|
(funcall push (substring qstr (1+ match) end)
|
|
|
|
(or end (length qstr)))))
|
|
|
|
(t nil)))
|
|
|
|
(t (error "Unexpected case in shell--unquote&requote-argument!")))
|
|
|
|
(setq qpos (match-end 0)))
|
|
|
|
(funcall push (substring qstr qpos) (length qstr))
|
|
|
|
(list (mapconcat #'identity (nreverse ustrs) "")
|
|
|
|
qupos #'comint-quote-filename)))
|
|
|
|
|
|
|
|
(defun shell--unquote-argument (str)
|
|
|
|
(car (shell--unquote&requote-argument str)))
|
|
|
|
(defun shell--requote-argument (upos qstr)
|
|
|
|
;; See `completion-table-with-quoting'.
|
|
|
|
(let ((res (shell--unquote&requote-argument qstr upos)))
|
|
|
|
(cons (nth 1 res) (nth 2 res))))
|
|
|
|
|
|
|
|
(defun shell--parse-pcomplete-arguments ()
|
2011-08-23 05:21:09 +00:00
|
|
|
"Parse whitespace separated arguments in the current region."
|
2012-05-15 16:58:35 +00:00
|
|
|
;; FIXME: share code with shell--unquote&requote-argument.
|
2011-08-23 05:21:09 +00:00
|
|
|
(let ((begin (save-excursion (shell-backward-command 1) (point)))
|
|
|
|
(end (point))
|
|
|
|
begins args)
|
|
|
|
(save-excursion
|
|
|
|
(goto-char begin)
|
|
|
|
(while (< (point) end)
|
|
|
|
(skip-chars-forward " \t\n")
|
|
|
|
(push (point) begins)
|
2011-08-28 05:15:17 +00:00
|
|
|
(let ((arg ()))
|
|
|
|
(while (looking-at
|
|
|
|
(eval-when-compile
|
|
|
|
(concat
|
|
|
|
"\\(?:[^\s\t\n\\\"']+"
|
|
|
|
"\\|'\\([^']*\\)'?"
|
|
|
|
"\\|\"\\(\\(?:[^\"\\]\\|\\\\.\\)*\\)\"?"
|
|
|
|
"\\|\\\\\\(\\(?:.\\|\n\\)?\\)\\)")))
|
|
|
|
(goto-char (match-end 0))
|
|
|
|
(cond
|
|
|
|
((match-beginning 3) ;Backslash escape.
|
2012-05-05 04:18:49 +00:00
|
|
|
(push (cond
|
2012-05-15 16:58:35 +00:00
|
|
|
((null comint-file-name-quote-list)
|
2012-05-05 04:18:49 +00:00
|
|
|
(goto-char (match-beginning 3)) "\\")
|
|
|
|
((= (match-beginning 3) (match-end 3)) "\\")
|
|
|
|
(t (match-string 3)))
|
2011-08-28 05:15:17 +00:00
|
|
|
arg))
|
|
|
|
((match-beginning 2) ;Double quote.
|
2012-05-15 16:58:35 +00:00
|
|
|
(push (if (null comint-file-name-quote-list) (match-string 2)
|
2012-05-09 17:20:24 +00:00
|
|
|
(replace-regexp-in-string
|
|
|
|
"\\\\\\(.\\)" "\\1" (match-string 2)))
|
2011-08-28 05:15:17 +00:00
|
|
|
arg))
|
|
|
|
((match-beginning 1) ;Single quote.
|
|
|
|
(push (match-string 1) arg))
|
|
|
|
(t (push (match-string 0) arg))))
|
|
|
|
(push (mapconcat #'identity (nreverse arg) "") args)))
|
2011-08-23 05:21:09 +00:00
|
|
|
(cons (nreverse args) (nreverse begins)))))
|
2011-05-17 02:38:04 +00:00
|
|
|
|
2012-01-05 14:51:05 +00:00
|
|
|
(defun shell-command-completion-function ()
|
|
|
|
"Completion function for shell command names.
|
|
|
|
This is the value of `pcomplete-command-completion-function' for
|
|
|
|
Shell buffers. It implements `shell-completion-execonly' for
|
|
|
|
`pcomplete' completion."
|
|
|
|
(pcomplete-here (pcomplete-entries nil
|
|
|
|
(if shell-completion-execonly
|
|
|
|
'file-executable-p))))
|
|
|
|
|
2011-05-12 12:55:10 +00:00
|
|
|
(defun shell-completion-vars ()
|
|
|
|
"Setup completion vars for `shell-mode' and `read-shell-command'."
|
|
|
|
(set (make-local-variable 'comint-completion-fignore)
|
|
|
|
shell-completion-fignore)
|
|
|
|
(set (make-local-variable 'comint-delimiter-argument-list)
|
|
|
|
shell-delimiter-argument-list)
|
|
|
|
(set (make-local-variable 'comint-file-name-chars) shell-file-name-chars)
|
|
|
|
(set (make-local-variable 'comint-file-name-quote-list)
|
|
|
|
shell-file-name-quote-list)
|
|
|
|
(set (make-local-variable 'comint-dynamic-complete-functions)
|
|
|
|
shell-dynamic-complete-functions)
|
2012-05-15 16:58:35 +00:00
|
|
|
(setq-local comint-unquote-function #'shell--unquote-argument)
|
|
|
|
(setq-local comint-requote-function #'shell--requote-argument)
|
2011-05-12 12:55:10 +00:00
|
|
|
(set (make-local-variable 'pcomplete-parse-arguments-function)
|
2012-05-15 16:58:35 +00:00
|
|
|
#'shell--parse-pcomplete-arguments)
|
2011-06-17 18:52:46 +00:00
|
|
|
(set (make-local-variable 'pcomplete-termination-string)
|
|
|
|
(cond ((not comint-completion-addsuffix) "")
|
|
|
|
((stringp comint-completion-addsuffix)
|
|
|
|
comint-completion-addsuffix)
|
|
|
|
((not (consp comint-completion-addsuffix)) " ")
|
|
|
|
(t (cdr comint-completion-addsuffix))))
|
2012-01-05 14:51:05 +00:00
|
|
|
(set (make-local-variable 'pcomplete-command-completion-function)
|
|
|
|
#'shell-command-completion-function)
|
2011-06-04 12:31:34 +00:00
|
|
|
;; Don't use pcomplete's defaulting mechanism, rely on
|
|
|
|
;; shell-dynamic-complete-functions instead.
|
|
|
|
(set (make-local-variable 'pcomplete-default-completion-function) #'ignore)
|
2011-05-12 12:55:10 +00:00
|
|
|
(setq comint-input-autoexpand shell-input-autoexpand)
|
|
|
|
;; Not needed in shell-mode because it's inherited from comint-mode, but
|
|
|
|
;; placed here for read-shell-command.
|
|
|
|
(add-hook 'completion-at-point-functions 'comint-completion-at-point nil t))
|
|
|
|
|
1997-05-05 00:59:28 +00:00
|
|
|
(put 'shell-mode 'mode-class 'special)
|
|
|
|
|
2000-11-21 21:33:45 +00:00
|
|
|
(define-derived-mode shell-mode comint-mode "Shell"
|
2006-06-02 02:09:19 +00:00
|
|
|
"Major mode for interacting with an inferior shell.\\<shell-mode-map>
|
1995-02-25 16:10:01 +00:00
|
|
|
\\[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).
|
1995-01-10 12:08:21 +00:00
|
|
|
\\[send-invisible] reads a line of text without echoing it, and sends it to
|
1994-03-24 07:51:27 +00:00
|
|
|
the shell. This is useful for entering passwords. Or, add the function
|
|
|
|
`comint-watch-for-password-prompt' to `comint-output-filter-functions'.
|
1990-11-05 10:06:02 +00:00
|
|
|
|
1995-01-10 12:08:21 +00:00
|
|
|
If you want to make multiple shell buffers, rename the `*shell*' buffer
|
|
|
|
using \\[rename-buffer] or \\[rename-uniquely] and start a new shell.
|
|
|
|
|
1995-02-25 16:10:01 +00:00
|
|
|
If you want to make shell buffers limited in length, add the function
|
1995-02-25 16:16:57 +00:00
|
|
|
`comint-truncate-buffer' to `comint-output-filter-functions'.
|
1995-02-25 16:10:01 +00:00
|
|
|
|
1990-11-05 10:06:02 +00:00
|
|
|
If you accidentally suspend your process, use \\[comint-continue-subjob]
|
|
|
|
to continue it.
|
|
|
|
|
1995-01-10 12:08:21 +00:00
|
|
|
`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.
|
1995-02-21 13:07:23 +00:00
|
|
|
While directory tracking is enabled, the shell's working directory is displayed
|
|
|
|
by \\[list-buffers] or \\[mouse-buffer-menu] in the `File' field.
|
2012-02-28 08:17:21 +00:00
|
|
|
\\[dirs] queries the shell and resyncs Emacs's idea of what the current
|
1990-11-05 10:06:02 +00:00
|
|
|
directory stack is.
|
2007-10-27 22:15:27 +00:00
|
|
|
\\[shell-dirtrack-mode] turns directory tracking on and off.
|
|
|
|
\(The `dirtrack' package provides an alternative implementation of this
|
2007-10-30 06:39:00 +00:00
|
|
|
feature - see the function `dirtrack-mode'.)
|
1990-11-05 10:06:02 +00:00
|
|
|
|
|
|
|
\\{shell-mode-map}
|
1993-04-29 14:23:22 +00:00
|
|
|
Customization: Entry to this mode runs the hooks on `comint-mode-hook' and
|
1994-03-03 23:37:27 +00:00
|
|
|
`shell-mode-hook' (in that order). Before each input, the hooks on
|
1994-03-03 23:57:27 +00:00
|
|
|
`comint-input-filter-functions' are run. After each shell output, the hooks
|
|
|
|
on `comint-output-filter-functions' are run.
|
1990-11-05 10:06:02 +00:00
|
|
|
|
2001-01-28 03:43:35 +00:00
|
|
|
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'
|
1996-06-09 20:31:51 +00:00
|
|
|
control the behavior of the relevant command.
|
1993-10-22 02:53:24 +00:00
|
|
|
|
1994-03-08 17:43:07 +00:00
|
|
|
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.
|
2005-06-16 16:10:43 +00:00
|
|
|
Variable `shell-completion-fignore' is used to initialize the value of
|
1994-03-08 17:43:07 +00:00
|
|
|
`comint-completion-fignore'.
|
1993-10-22 02:53:24 +00:00
|
|
|
|
|
|
|
Variables `comint-input-ring-file-name' and `comint-input-autoexpand' control
|
2005-08-29 11:08:04 +00:00
|
|
|
the initialization of the input ring history, and history expansion.
|
1993-10-22 02:53:24 +00:00
|
|
|
|
1994-03-03 23:57:27 +00:00
|
|
|
Variables `comint-output-filter-functions', a hook, and
|
1994-03-08 17:43:07 +00:00
|
|
|
`comint-scroll-to-bottom-on-input' and `comint-scroll-to-bottom-on-output'
|
1994-03-03 23:37:27 +00:00
|
|
|
control whether input and output cause the window to scroll to the end of the
|
|
|
|
buffer."
|
1993-10-22 02:53:24 +00:00
|
|
|
(setq comint-prompt-regexp shell-prompt-pattern)
|
2011-05-12 12:55:10 +00:00
|
|
|
(shell-completion-vars)
|
2005-04-26 23:16:20 +00:00
|
|
|
(set (make-local-variable 'paragraph-separate) "\\'")
|
2011-05-12 12:55:10 +00:00
|
|
|
(set (make-local-variable 'paragraph-start) comint-prompt-regexp)
|
|
|
|
(set (make-local-variable 'font-lock-defaults) '(shell-font-lock-keywords t))
|
|
|
|
(set (make-local-variable 'shell-dirstack) nil)
|
|
|
|
(set (make-local-variable 'shell-last-dir) nil)
|
2009-09-25 04:35:14 +00:00
|
|
|
(shell-dirtrack-mode 1)
|
2012-02-19 13:59:42 +00:00
|
|
|
|
|
|
|
;; By default, ansi-color applies faces using overlays. This is
|
|
|
|
;; very inefficient in Shell buffers (e.g. Bug#10835). We use a
|
|
|
|
;; custom `ansi-color-apply-face-function' to convert color escape
|
|
|
|
;; sequences into `font-lock-face' properties.
|
2012-11-30 08:24:53 +00:00
|
|
|
(setq-local ansi-color-apply-face-function #'shell-apply-ansi-color)
|
|
|
|
(shell-reapply-ansi-color)
|
2012-02-19 13:59:42 +00:00
|
|
|
|
1997-07-20 04:13:45 +00:00
|
|
|
;; This is not really correct, since the shell buffer does not really
|
|
|
|
;; edit this directory. But it is useful in the buffer list and menus.
|
|
|
|
(setq list-buffers-directory (expand-file-name default-directory))
|
1993-10-22 02:53:24 +00:00
|
|
|
;; shell-dependent assignments.
|
2002-05-14 08:46:00 +00:00
|
|
|
(when (ring-empty-p comint-input-ring)
|
2002-04-03 15:23:59 +00:00
|
|
|
(let ((shell (file-name-nondirectory (car
|
2011-03-09 09:01:14 +00:00
|
|
|
(process-command (get-buffer-process (current-buffer))))))
|
|
|
|
(hsize (getenv "HISTSIZE")))
|
|
|
|
(and (stringp hsize)
|
|
|
|
(integerp (setq hsize (string-to-number hsize)))
|
|
|
|
(> hsize 0)
|
|
|
|
(set (make-local-variable 'comint-input-ring-size) hsize))
|
2002-04-03 15:23:59 +00:00
|
|
|
(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 ~-")
|
2003-06-05 12:02:09 +00:00
|
|
|
(t "dirs")))
|
|
|
|
;; Bypass a bug in certain versions of bash.
|
|
|
|
(when (string-equal shell "bash")
|
2011-04-20 22:31:06 +00:00
|
|
|
(add-hook 'comint-preoutput-filter-functions
|
2003-06-05 12:02:09 +00:00
|
|
|
'shell-filter-ctrl-a-ctrl-b nil t)))
|
2002-04-03 15:23:59 +00:00
|
|
|
(comint-read-input-ring t)))
|
2000-09-14 21:15:44 +00:00
|
|
|
|
2012-11-30 08:24:53 +00:00
|
|
|
(defun shell-apply-ansi-color (beg end face)
|
|
|
|
"Apply FACE as the ansi-color face for the text between BEG and END."
|
|
|
|
(when face
|
|
|
|
(put-text-property beg end 'ansi-color-face face)
|
|
|
|
(put-text-property beg end 'font-lock-face face)))
|
|
|
|
|
|
|
|
(defun shell-reapply-ansi-color ()
|
|
|
|
"Reapply ansi-color faces to the existing contents of the buffer."
|
|
|
|
(save-restriction
|
|
|
|
(widen)
|
|
|
|
(let* ((pos (point-min))
|
|
|
|
(end (or (next-single-property-change pos 'ansi-color-face)
|
|
|
|
(point-max)))
|
|
|
|
face)
|
|
|
|
(while end
|
|
|
|
(if (setq face (get-text-property pos 'ansi-color-face))
|
|
|
|
(put-text-property pos (or end (point-max))
|
|
|
|
'font-lock-face face))
|
|
|
|
(setq pos end
|
|
|
|
end (next-single-property-change pos 'ansi-color-face))))))
|
|
|
|
|
2011-04-20 22:31:06 +00:00
|
|
|
(defun shell-filter-ctrl-a-ctrl-b (string)
|
2003-06-05 12:02:09 +00:00
|
|
|
"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.
|
|
|
|
|
2011-04-20 22:31:06 +00:00
|
|
|
This function can be put on `comint-preoutput-filter-functions'."
|
|
|
|
(if (string-match "[\C-a\C-b]" string)
|
|
|
|
(replace-regexp-in-string "[\C-a\C-b]" "" string t t)
|
|
|
|
string))
|
2003-06-05 12:02:09 +00:00
|
|
|
|
2000-09-14 21:15:44 +00:00
|
|
|
(defun shell-write-history-on-exit (process event)
|
|
|
|
"Called when the shell process is stopped.
|
|
|
|
|
|
|
|
Writes the input history to a history file
|
2001-01-28 03:43:35 +00:00
|
|
|
`comint-input-ring-file-name' using `comint-write-input-ring'
|
2000-09-14 21:15:44 +00:00
|
|
|
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)
|
2001-01-28 03:43:35 +00:00
|
|
|
(let ((buf (process-buffer process)))
|
|
|
|
(when (buffer-live-p buf)
|
|
|
|
(with-current-buffer buf
|
|
|
|
(insert (format "\nProcess %s %s\n" process event))))))
|
|
|
|
|
1992-05-30 21:11:25 +00:00
|
|
|
;;;###autoload
|
2000-10-27 08:01:52 +00:00
|
|
|
(defun shell (&optional buffer)
|
|
|
|
"Run an inferior shell, with I/O through BUFFER (which defaults to `*shell*').
|
|
|
|
Interactively, a prefix arg means to prompt for BUFFER.
|
2007-08-22 19:47:57 +00:00
|
|
|
If `default-directory' is a remote file name, it is also prompted
|
|
|
|
to change if called with a prefix arg.
|
|
|
|
|
2000-10-27 08:01:52 +00:00
|
|
|
If BUFFER exists but shell process is not running, make new shell.
|
|
|
|
If BUFFER exists and shell process is running, just switch to BUFFER.
|
1993-04-29 14:23:22 +00:00
|
|
|
Program used comes from variable `explicit-shell-file-name',
|
1991-05-08 07:47:45 +00:00
|
|
|
or (if that is nil) from the ESHELL environment variable,
|
2006-12-15 21:21:43 +00:00
|
|
|
or (if that is nil) from `shell-file-name'.
|
2006-12-05 14:21:56 +00:00
|
|
|
If a file `~/.emacs_SHELLNAME' exists, or `~/.emacs.d/init_SHELLNAME.sh',
|
2006-12-15 21:17:01 +00:00
|
|
|
it is given as initial input (but this may be lost, due to a timing
|
|
|
|
error, if the shell discards input when it starts up).
|
1992-09-04 07:35:10 +00:00
|
|
|
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'.
|
1990-11-05 10:06:02 +00:00
|
|
|
|
1997-08-04 03:06:28 +00:00
|
|
|
To specify a coding system for converting non-ASCII characters
|
|
|
|
in the input and output to the shell, use \\[universal-coding-system-argument]
|
|
|
|
before \\[shell]. You can also specify this with \\[set-buffer-process-coding-system]
|
|
|
|
in the shell buffer, after you start the shell.
|
|
|
|
The default comes from `process-coding-system-alist' and
|
|
|
|
`default-process-coding-system'.
|
|
|
|
|
1991-05-08 07:47:45 +00:00
|
|
|
The shell file name (sans directories) is used to make a symbol name
|
1993-01-15 07:02:35 +00:00
|
|
|
such as `explicit-csh-args'. If that symbol is a variable,
|
1990-11-05 10:06:02 +00:00
|
|
|
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.)"
|
2000-10-27 08:01:52 +00:00
|
|
|
(interactive
|
|
|
|
(list
|
|
|
|
(and current-prefix-arg
|
2007-08-29 13:35:16 +00:00
|
|
|
(prog1
|
|
|
|
(read-buffer "Shell buffer: "
|
2012-11-30 08:06:04 +00:00
|
|
|
;; If the current buffer is an inactive
|
|
|
|
;; shell buffer, use it as the default.
|
|
|
|
(if (and (eq major-mode 'shell-mode)
|
|
|
|
(null (get-buffer-process (current-buffer))))
|
|
|
|
(buffer-name)
|
|
|
|
(generate-new-buffer-name "*shell*")))
|
2007-08-29 13:35:16 +00:00
|
|
|
(if (file-remote-p default-directory)
|
|
|
|
;; It must be possible to declare a local default-directory.
|
2010-11-23 14:19:54 +00:00
|
|
|
;; FIXME: This can't be right: it changes the default-directory
|
|
|
|
;; of the current-buffer rather than of the *shell* buffer.
|
2007-08-29 13:35:16 +00:00
|
|
|
(setq default-directory
|
|
|
|
(expand-file-name
|
2011-03-05 21:56:00 +00:00
|
|
|
(read-directory-name
|
2007-08-29 13:35:16 +00:00
|
|
|
"Default directory: " default-directory default-directory
|
2011-03-05 21:56:00 +00:00
|
|
|
t nil))))))))
|
2010-11-23 14:19:54 +00:00
|
|
|
(setq buffer (if (or buffer (not (derived-mode-p 'shell-mode))
|
|
|
|
(comint-check-proc (current-buffer)))
|
|
|
|
(get-buffer-create (or buffer "*shell*"))
|
|
|
|
;; If the current buffer is a dead shell buffer, use it.
|
|
|
|
(current-buffer)))
|
2011-03-14 09:53:13 +00:00
|
|
|
|
|
|
|
;; On remote hosts, the local `shell-file-name' might be useless.
|
2011-04-19 13:44:55 +00:00
|
|
|
(if (and (called-interactively-p 'any)
|
2011-03-14 09:53:13 +00:00
|
|
|
(file-remote-p default-directory)
|
|
|
|
(null explicit-shell-file-name)
|
|
|
|
(null (getenv "ESHELL")))
|
|
|
|
(with-current-buffer buffer
|
|
|
|
(set (make-local-variable 'explicit-shell-file-name)
|
|
|
|
(file-remote-p
|
|
|
|
(expand-file-name
|
|
|
|
(read-file-name
|
|
|
|
"Remote shell path: " default-directory shell-file-name
|
|
|
|
t shell-file-name))
|
|
|
|
'localname))))
|
|
|
|
|
Change modes that used same-window-* vars to use switch-to-buffer.
* cmuscheme.el (run-scheme, switch-to-scheme):
* ielm.el (ielm):
* shell.el (shell):
* net/rlogin.el (rlogin):
* net/telnet.el (telnet, rsh):
* progmodes/inf-lisp.el (inferior-lisp): Use switch-to-buffer.
* cus-edit.el (customize-group, custom-buffer-create)
(customize-browse, custom-buffer-create-other-window): Use
switch-to-buffer or switch-to-buffer-other-window.
* info.el (info, Info-find-node, Info-revert-find-node, Info-next)
(Info-prev, Info-up, Info-speedbar-goto-node)
(info-display-manual): Use switch-to-buffer.
(Info-speedbar-goto-node): Use switch-to-buffer-other-frame.
* lisp/gnus/message.el (message-pop-to-buffer): Default to switch-to-buffer.
(message-mail-other-window, message-mail-other-frame)
(message-news-other-window, message-news-other-frame): Use
switch-to-buffer-other-frame and switch-to-buffer-other-window instead
of setting buffer display varibles.
* mail/sendmail.el (mail): Use switch-to-buffer.
(mail-recover): Use switch-to-buffer-other-window.
* progmodes/gdb-mi.el (gdb-restore-windows, gdb-setup-windows):
Use switch-to-buffer.
2011-09-11 18:30:07 +00:00
|
|
|
;; The buffer's window must be correctly set when we call comint (so
|
|
|
|
;; that comint sets the COLUMNS env var properly).
|
2011-09-22 16:15:52 +00:00
|
|
|
(pop-to-buffer-same-window buffer)
|
2001-12-02 07:39:23 +00:00
|
|
|
(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"))))
|
2006-12-05 14:21:56 +00:00
|
|
|
(unless (file-exists-p startfile)
|
2007-06-13 00:03:49 +00:00
|
|
|
(setq startfile (concat user-emacs-directory "init_" name ".sh")))
|
2001-12-02 07:39:23 +00:00
|
|
|
(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)
|
1995-03-12 09:39:49 +00:00
|
|
|
|
1990-11-05 10:06:02 +00:00
|
|
|
;;; Directory tracking
|
2006-05-17 21:57:25 +00:00
|
|
|
;;
|
|
|
|
;; 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.
|
1990-11-05 10:06:02 +00:00
|
|
|
|
|
|
|
(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.
|
|
|
|
|
2007-10-27 22:15:27 +00:00
|
|
|
You may toggle this tracking on and off with \\[shell-dirtrack-mode].
|
2006-05-17 21:57:25 +00:00
|
|
|
If Emacs gets confused, you can resync with the shell with \\[dirs].
|
2007-10-30 06:39:00 +00:00
|
|
|
\(The `dirtrack' package provides an alternative implementation of this
|
|
|
|
feature - see the function `dirtrack-mode'.)
|
1990-11-05 10:06:02 +00:00
|
|
|
|
1996-06-09 20:31:51 +00:00
|
|
|
See variables `shell-cd-regexp', `shell-chdrive-regexp', `shell-pushd-regexp',
|
2001-01-28 03:43:35 +00:00
|
|
|
and `shell-popd-regexp', while `shell-pushd-tohome', `shell-pushd-dextract',
|
1996-06-09 20:31:51 +00:00
|
|
|
and `shell-pushd-dunique' control the behavior of the relevant command.
|
1993-10-22 02:53:24 +00:00
|
|
|
|
1993-04-29 14:23:22 +00:00
|
|
|
Environment variables are expanded, see function `substitute-in-file-name'."
|
1993-10-22 02:53:24 +00:00
|
|
|
(if shell-dirtrackp
|
|
|
|
;; We fail gracefully if we think the command will fail in the shell.
|
2014-04-07 01:27:32 +00:00
|
|
|
;;; (with-demoted-errors "Directory tracker failure: %s"
|
|
|
|
;; This fails so often that it seems better to just ignore errors (?).
|
|
|
|
;; Eg even: foo=/tmp; cd $foo is beyond us (bug#17159).
|
|
|
|
(ignore-errors
|
|
|
|
(let ((start (progn (string-match
|
2003-06-12 22:20:49 +00:00
|
|
|
(concat "^" shell-command-separator-regexp)
|
|
|
|
str) ; skip whitespace
|
1993-10-22 02:53:24 +00:00
|
|
|
(match-end 0)))
|
2011-05-27 01:54:56 +00:00
|
|
|
(case-fold-search)
|
1993-10-22 02:53:24 +00:00
|
|
|
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))
|
1999-07-20 04:16:51 +00:00
|
|
|
(if arg1
|
|
|
|
(setq arg1 (shell-unquote-argument arg1)))
|
1995-06-19 22:54:58 +00:00
|
|
|
(cond ((string-match (concat "\\`\\(" shell-popd-regexp
|
|
|
|
"\\)\\($\\|[ \t]\\)")
|
|
|
|
cmd)
|
1996-06-09 20:31:51 +00:00
|
|
|
(shell-process-popd (comint-substitute-in-file-name arg1)))
|
1995-06-19 22:54:58 +00:00
|
|
|
((string-match (concat "\\`\\(" shell-pushd-regexp
|
|
|
|
"\\)\\($\\|[ \t]\\)")
|
|
|
|
cmd)
|
1996-06-09 20:31:51 +00:00
|
|
|
(shell-process-pushd (comint-substitute-in-file-name arg1)))
|
1995-06-19 22:54:58 +00:00
|
|
|
((string-match (concat "\\`\\(" shell-cd-regexp
|
|
|
|
"\\)\\($\\|[ \t]\\)")
|
|
|
|
cmd)
|
1996-06-09 20:31:51 +00:00
|
|
|
(shell-process-cd (comint-substitute-in-file-name arg1)))
|
|
|
|
((and shell-chdrive-regexp
|
|
|
|
(string-match (concat "\\`\\(" shell-chdrive-regexp
|
|
|
|
"\\)\\($\\|[ \t]\\)")
|
|
|
|
cmd))
|
|
|
|
(shell-process-cd (comint-substitute-in-file-name cmd))))
|
2003-06-12 22:20:49 +00:00
|
|
|
(setq start (progn (string-match shell-command-separator-regexp
|
|
|
|
str end)
|
|
|
|
;; skip again
|
2013-09-12 05:40:50 +00:00
|
|
|
(match-end 0))))))))
|
1993-10-22 02:53:24 +00:00
|
|
|
|
1999-07-20 04:16:51 +00:00
|
|
|
(defun shell-unquote-argument (string)
|
|
|
|
"Remove all kinds of shell quoting from STRING."
|
|
|
|
(save-match-data
|
2001-01-27 12:43:56 +00:00
|
|
|
(let ((idx 0) next inside
|
|
|
|
(quote-chars
|
|
|
|
(if (string-match shell-dumb-shell-regexp
|
|
|
|
(file-name-nondirectory
|
|
|
|
(car (process-command (get-buffer-process (current-buffer))))))
|
|
|
|
"['`\"]"
|
|
|
|
"[\\'`\"]")))
|
1999-07-20 04:16:51 +00:00
|
|
|
(while (and (< idx (length string))
|
2001-01-27 12:43:56 +00:00
|
|
|
(setq next (string-match quote-chars string next)))
|
1999-07-20 04:16:51 +00:00
|
|
|
(cond ((= (aref string next) ?\\)
|
|
|
|
(setq string (replace-match "" nil nil string))
|
|
|
|
(setq next (1+ next)))
|
|
|
|
((and inside (= (aref string next) inside))
|
|
|
|
(setq string (replace-match "" nil nil string))
|
|
|
|
(setq inside nil))
|
|
|
|
(inside
|
|
|
|
(setq next (1+ next)))
|
|
|
|
(t
|
|
|
|
(setq inside (aref string next))
|
|
|
|
(setq string (replace-match "" nil nil string)))))
|
|
|
|
string)))
|
|
|
|
|
2006-05-17 21:57:25 +00:00
|
|
|
;; popd [+n]
|
1990-11-05 10:06:02 +00:00
|
|
|
(defun shell-process-popd (arg)
|
1993-10-22 02:53:24 +00:00
|
|
|
(let ((num (or (shell-extract-num arg) 0)))
|
|
|
|
(cond ((and num (= num 0) shell-dirstack)
|
2010-11-06 12:08:58 +00:00
|
|
|
(shell-cd (shell-prefixed-directory-name (car shell-dirstack)))
|
1993-10-22 02:53:24 +00:00
|
|
|
(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
|
1994-03-03 23:57:27 +00:00
|
|
|
(error "Couldn't popd")))))
|
1990-11-05 10:06:02 +00:00
|
|
|
|
1994-01-06 17:02:00 +00:00
|
|
|
;; Return DIR prefixed with comint-file-name-prefix as appropriate.
|
1994-06-23 23:12:13 +00:00
|
|
|
(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)
|
1995-02-21 13:07:23 +00:00
|
|
|
;; For relative name we assume default-directory already has the prefix.
|
1994-06-23 23:12:13 +00:00
|
|
|
(expand-file-name dir))))
|
1994-01-06 17:02:00 +00:00
|
|
|
|
2006-05-17 21:57:25 +00:00
|
|
|
;; cd [dir]
|
1990-11-05 10:06:02 +00:00
|
|
|
(defun shell-process-cd (arg)
|
1994-01-06 17:02:00 +00:00
|
|
|
(let ((new-dir (cond ((zerop (length arg)) (concat comint-file-name-prefix
|
|
|
|
"~"))
|
1993-10-22 02:53:24 +00:00
|
|
|
((string-equal "-" arg) shell-last-dir)
|
1994-01-06 17:02:00 +00:00
|
|
|
(t (shell-prefixed-directory-name arg)))))
|
1993-10-22 02:53:24 +00:00
|
|
|
(setq shell-last-dir default-directory)
|
1995-02-21 13:07:23 +00:00
|
|
|
(shell-cd new-dir)
|
1993-10-22 02:53:24 +00:00
|
|
|
(shell-dirstack-message)))
|
1990-11-05 10:06:02 +00:00
|
|
|
|
2006-05-17 21:57:25 +00:00
|
|
|
;; pushd [+n | dir]
|
1990-11-05 10:06:02 +00:00
|
|
|
(defun shell-process-pushd (arg)
|
1993-10-22 02:53:24 +00:00
|
|
|
(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
|
1994-01-06 17:02:00 +00:00
|
|
|
(shell-process-pushd (concat comint-file-name-prefix "~")))
|
1993-10-22 02:53:24 +00:00
|
|
|
(shell-dirstack
|
|
|
|
(let ((old default-directory))
|
1995-02-21 13:07:23 +00:00
|
|
|
(shell-cd (car shell-dirstack))
|
1996-02-03 13:38:32 +00:00
|
|
|
(setq shell-dirstack (cons old (cdr shell-dirstack)))
|
1993-10-22 02:53:24 +00:00
|
|
|
(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)
|
2013-09-12 05:40:50 +00:00
|
|
|
(error "Couldn't cd"))
|
1993-10-22 02:53:24 +00:00
|
|
|
(shell-pushd-dextract
|
|
|
|
(let ((dir (nth (1- num) shell-dirstack)))
|
|
|
|
(shell-process-popd arg)
|
|
|
|
(shell-process-pushd default-directory)
|
1995-02-21 13:07:23 +00:00
|
|
|
(shell-cd dir)
|
1993-10-22 02:53:24 +00:00
|
|
|
(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)))
|
1995-02-21 13:07:23 +00:00
|
|
|
(shell-cd (car new-ds))
|
1993-10-22 02:53:24 +00:00
|
|
|
(setq shell-dirstack (cdr new-ds))
|
|
|
|
(shell-dirstack-message)))))
|
|
|
|
(t
|
|
|
|
;; pushd <dir>
|
|
|
|
(let ((old-wd default-directory))
|
1995-02-21 13:07:23 +00:00
|
|
|
(shell-cd (shell-prefixed-directory-name arg))
|
1993-10-22 02:53:24 +00:00
|
|
|
(if (or (null shell-pushd-dunique)
|
|
|
|
(not (member old-wd shell-dirstack)))
|
|
|
|
(setq shell-dirstack (cons old-wd shell-dirstack)))
|
|
|
|
(shell-dirstack-message))))))
|
1990-11-05 10:06:02 +00:00
|
|
|
|
|
|
|
;; 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)
|
2005-05-16 11:34:49 +00:00
|
|
|
(string-to-number str)))
|
1990-11-05 10:06:02 +00:00
|
|
|
|
2006-05-17 21:57:25 +00:00
|
|
|
(defvaralias 'shell-dirtrack-mode 'shell-dirtrackp)
|
|
|
|
(define-minor-mode shell-dirtrack-mode
|
Fix minor mode docstrings for the new meaning of a nil ARG.
* abbrev.el (abbrev-mode):
* allout.el (allout-mode):
* autoinsert.el (auto-insert-mode):
* autoarg.el (autoarg-mode, autoarg-kp-mode):
* autorevert.el (auto-revert-mode, auto-revert-tail-mode)
(global-auto-revert-mode):
* battery.el (display-battery-mode):
* composite.el (global-auto-composition-mode)
(auto-composition-mode):
* delsel.el (delete-selection-mode):
* desktop.el (desktop-save-mode):
* dired-x.el (dired-omit-mode):
* dirtrack.el (dirtrack-mode):
* doc-view.el (doc-view-minor-mode):
* double.el (double-mode):
* electric.el (electric-indent-mode, electric-pair-mode):
* emacs-lock.el (emacs-lock-mode):
* epa-hook.el (auto-encryption-mode):
* follow.el (follow-mode):
* font-core.el (font-lock-mode):
* frame.el (auto-raise-mode, auto-lower-mode, blink-cursor-mode):
* help.el (temp-buffer-resize-mode):
* hilit-chg.el (highlight-changes-mode)
(highlight-changes-visible-mode):
* hi-lock.el (hi-lock-mode):
* hl-line.el (hl-line-mode, global-hl-line-mode):
* icomplete.el (icomplete-mode):
* ido.el (ido-everywhere):
* image-file.el (auto-image-file-mode):
* image-mode.el (image-minor-mode):
* iswitchb.el (iswitchb-mode):
* jka-cmpr-hook.el (auto-compression-mode):
* linum.el (linum-mode):
* longlines.el (longlines-mode):
* master.el (master-mode):
* mb-depth.el (minibuffer-depth-indicate-mode):
* menu-bar.el (menu-bar-mode):
* minibuf-eldef.el (minibuffer-electric-default-mode):
* mouse-sel.el (mouse-sel-mode):
* msb.el (msb-mode):
* mwheel.el (mouse-wheel-mode):
* outline.el (outline-minor-mode):
* paren.el (show-paren-mode):
* recentf.el (recentf-mode):
* reveal.el (reveal-mode, global-reveal-mode):
* rfn-eshadow.el (file-name-shadow-mode):
* ruler-mode.el (ruler-mode):
* savehist.el (savehist-mode):
* scroll-all.el (scroll-all-mode):
* scroll-bar.el (scroll-bar-mode):
* server.el (server-mode):
* shell.el (shell-dirtrack-mode):
* simple.el (auto-fill-mode, transient-mark-mode)
(visual-line-mode, overwrite-mode, binary-overwrite-mode)
(line-number-mode, column-number-mode, size-indication-mode)
(auto-save-mode, normal-erase-is-backspace-mode, visible-mode):
* strokes.el (strokes-mode):
* time.el (display-time-mode):
* t-mouse.el (gpm-mouse-mode):
* tool-bar.el (tool-bar-mode):
* tooltip.el (tooltip-mode):
* type-break.el (type-break-mode-line-message-mode)
(type-break-query-mode):
* view.el (view-mode):
* whitespace.el (whitespace-mode, whitespace-newline-mode)
(global-whitespace-mode, global-whitespace-newline-mode):
* xt-mouse.el (xterm-mouse-mode): Doc fix.
* emacs-lisp/easy-mmode.el (define-globalized-minor-mode): Fix
autogenerated docstring.
2011-10-19 12:54:24 +00:00
|
|
|
"Toggle directory tracking in this shell buffer (Shell Dirtrack mode).
|
|
|
|
With a prefix argument ARG, enable Shell Dirtrack mode if ARG is
|
|
|
|
positive, and disable it otherwise. If called from Lisp, enable
|
|
|
|
the mode if ARG is omitted or nil.
|
|
|
|
|
|
|
|
The `dirtrack' package provides an alternative implementation of
|
|
|
|
this feature; see the function `dirtrack-mode'."
|
2006-05-17 21:57:25 +00:00
|
|
|
nil nil nil
|
|
|
|
(setq list-buffers-directory (if shell-dirtrack-mode default-directory))
|
|
|
|
(if shell-dirtrack-mode
|
|
|
|
(add-hook 'comint-input-filter-functions 'shell-directory-tracker nil t)
|
|
|
|
(remove-hook 'comint-input-filter-functions 'shell-directory-tracker t)))
|
|
|
|
|
2007-10-27 22:15:27 +00:00
|
|
|
(define-obsolete-function-alias 'shell-dirtrack-toggle 'shell-dirtrack-mode
|
|
|
|
"23.1")
|
1990-11-05 10:06:02 +00:00
|
|
|
|
1995-02-21 13:07:23 +00:00
|
|
|
(defun shell-cd (dir)
|
|
|
|
"Do normal `cd' to DIR, and set `list-buffers-directory'."
|
2006-05-17 21:57:25 +00:00
|
|
|
(cd dir)
|
1995-03-02 08:59:07 +00:00
|
|
|
(if shell-dirtrackp
|
2006-05-17 21:57:25 +00:00
|
|
|
(setq list-buffers-directory default-directory)))
|
1990-11-05 10:06:02 +00:00
|
|
|
|
|
|
|
(defun shell-resync-dirs ()
|
|
|
|
"Resync the buffer's idea of the current directory stack.
|
2001-01-28 03:43:35 +00:00
|
|
|
This command queries the shell with the command bound to
|
1993-04-29 14:23:22 +00:00
|
|
|
`shell-dirstack-query' (default \"dirs\"), reads the next
|
1990-11-05 10:06:02 +00:00
|
|
|
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
|
2005-08-29 11:08:04 +00:00
|
|
|
new directory stack -- you lose. If this happens, just do the
|
1990-11-05 10:06:02 +00:00
|
|
|
command again."
|
|
|
|
(interactive)
|
|
|
|
(let* ((proc (get-buffer-process (current-buffer)))
|
2007-09-13 07:22:19 +00:00
|
|
|
(pmark (process-mark proc))
|
|
|
|
(started-at-pmark (= (point) (marker-position pmark))))
|
|
|
|
(save-excursion
|
|
|
|
(goto-char pmark)
|
|
|
|
;; 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))
|
|
|
|
(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)
|
|
|
|
;; 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 2) (1- (match-end 2))))
|
|
|
|
(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)))
|
2013-09-12 05:32:57 +00:00
|
|
|
(with-demoted-errors "Couldn't cd: %s"
|
|
|
|
(shell-cd (car ds))
|
|
|
|
(setq shell-dirstack (cdr ds)
|
|
|
|
shell-last-dir (car shell-dirstack))
|
|
|
|
(shell-dirstack-message)))))
|
2007-09-13 07:22:19 +00:00
|
|
|
(if started-at-pmark (goto-char (marker-position pmark)))))
|
1990-11-05 10:06:02 +00:00
|
|
|
|
2006-05-17 21:57:25 +00:00
|
|
|
;; For your typing convenience:
|
1993-04-23 06:51:44 +00:00
|
|
|
(defalias 'dirs 'shell-resync-dirs)
|
1990-11-05 10:06:02 +00:00
|
|
|
|
|
|
|
|
2006-05-17 21:57:25 +00:00
|
|
|
;; 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.
|
1990-11-05 10:06:02 +00:00
|
|
|
(defun shell-dirstack-message ()
|
1999-01-14 10:31:31 +00:00
|
|
|
(when shell-dirtrack-verbose
|
|
|
|
(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))))
|
2001-01-28 03:43:35 +00:00
|
|
|
|
1997-08-22 23:37:38 +00:00
|
|
|
;; 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."
|
|
|
|
(let* ((cmd (format "printenv '%s'\n" var))
|
|
|
|
(proc (get-buffer-process (current-buffer)))
|
|
|
|
(pmark (process-mark proc)))
|
|
|
|
(goto-char pmark)
|
|
|
|
(insert cmd)
|
|
|
|
(sit-for 0) ; force redisplay
|
|
|
|
(comint-send-string proc cmd)
|
|
|
|
(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
|
|
|
|
(buffer-substring (match-beginning 0) (1- (match-end 0)))))
|
|
|
|
|
|
|
|
(defun shell-copy-environment-variable (variable)
|
|
|
|
"Copy the environment variable VARIABLE from the subshell to Emacs.
|
|
|
|
This command reads the value of the specified environment variable
|
|
|
|
in the shell, and sets the same environment variable in Emacs
|
1998-06-28 22:43:25 +00:00
|
|
|
\(what `getenv' in Emacs would return) to that value.
|
1997-08-22 23:37:38 +00:00
|
|
|
That value will affect any new subprocesses that you subsequently start
|
|
|
|
from Emacs."
|
|
|
|
(interactive (list (read-envvar-name "\
|
|
|
|
Copy Shell environment variable to Emacs: ")))
|
|
|
|
(setenv variable (shell-snarf-envar variable)))
|
2001-01-28 03:43:35 +00:00
|
|
|
|
1993-10-22 02:53:24 +00:00
|
|
|
(defun shell-forward-command (&optional arg)
|
|
|
|
"Move forward across ARG shell command(s). Does not cross lines.
|
|
|
|
See `shell-command-regexp'."
|
|
|
|
(interactive "p")
|
Use line-end-position rather than end-of-line, etc.
* textmodes/texnfo-upd.el (texinfo-start-menu-description)
(texinfo-update-menu-region-beginning, texinfo-menu-first-node)
(texinfo-delete-existing-pointers, texinfo-find-pointer)
(texinfo-clean-up-node-line, texinfo-insert-node-lines)
(texinfo-multiple-files-update):
* textmodes/table.el (table--probe-cell-left-up)
(table--probe-cell-right-bottom):
* textmodes/picture.el (picture-tab-search):
* textmodes/page-ext.el (pages-copy-header-and-position)
(pages-directory-for-addresses):
* progmodes/vera-mode.el (vera-get-offset):
* progmodes/simula.el (simula-calculate-indent):
* progmodes/python.el (python-pdbtrack-overlay-arrow):
* progmodes/prolog.el (end-of-prolog-clause):
* progmodes/perl-mode.el (perl-calculate-indent, perl-indent-exp):
* progmodes/icon.el (indent-icon-exp):
* progmodes/etags.el (tag-re-match-p):
* progmodes/ebrowse.el (ebrowse-show-file-name-at-point):
* progmodes/ebnf2ps.el (ebnf-begin-file):
* progmodes/dcl-mode.el (dcl-back-to-indentation-1)
(dcl-save-local-variable):
* play/life.el (life-setup):
* play/gametree.el (gametree-looking-at-ply):
* nxml/nxml-maint.el (nxml-insert-target-repertoire-glyph-set):
* mail/sendmail.el (mail-mode-auto-fill):
* emacs-lisp/lisp-mode.el (calculate-lisp-indent):
* emacs-lisp/edebug.el (edebug-overlay-arrow):
* emacs-lisp/checkdoc.el (checkdoc-this-string-valid):
* woman.el (woman-parse-numeric-value, woman2-TH, woman2-SH)
(woman-tab-to-tab-stop, WoMan-warn-ignored):
* type-break.el (type-break-file-keystroke-count):
* term.el (term-replace-by-expanded-history-before-point)
(term-skip-prompt, term-extract-string):
* speedbar.el (speedbar-edit-line, speedbar-expand-line)
(speedbar-contract-line, speedbar-toggle-line-expansion)
(speedbar-parse-c-or-c++tag, speedbar-parse-tex-string)
(speedbar-buffer-revert-buffer, speedbar-highlight-one-tag-line):
* sort.el (sort-skip-fields):
* skeleton.el (skeleton-internal-list):
* simple.el (line-move-finish, line-move-to-column):
* shell.el (shell-forward-command):
* misc.el (copy-from-above-command):
* makesum.el (double-column):
* ebuff-menu.el (electric-buffer-update-highlight):
* dired.el (dired-move-to-end-of-filename):
* dframe.el (dframe-popup-kludge):
* bookmark.el (bookmark-kill-line, bookmark-bmenu-show-filenames):
* arc-mode.el (archive-get-lineno):
Use line-end-position and line-beginning-position.
* net/ange-ftp.el, progmodes/hideif.el, reposition.el:
Same, but only in comments.
2010-11-06 20:23:42 +00:00
|
|
|
(let ((limit (line-end-position)))
|
1994-05-07 01:22:50 +00:00
|
|
|
(if (re-search-forward (concat shell-command-regexp "\\([;&|][\t ]*\\)+")
|
1993-10-22 02:53:24 +00:00
|
|
|
limit 'move arg)
|
1993-12-24 05:42:58 +00:00
|
|
|
(skip-syntax-backward " "))))
|
1993-10-22 02:53:24 +00:00
|
|
|
|
|
|
|
|
|
|
|
(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))))
|
2000-08-07 14:51:48 +00:00
|
|
|
(when (> limit (point))
|
|
|
|
(setq limit (line-beginning-position)))
|
1993-12-24 05:42:58 +00:00
|
|
|
(skip-syntax-backward " " limit)
|
1993-10-22 02:53:24 +00:00
|
|
|
(if (re-search-backward
|
1994-05-07 01:22:50 +00:00
|
|
|
(format "[;&|]+[\t ]*\\(%s\\)" shell-command-regexp) limit 'move arg)
|
1993-10-22 02:53:24 +00:00
|
|
|
(progn (goto-char (match-beginning 1))
|
1993-12-24 05:42:58 +00:00
|
|
|
(skip-chars-forward ";&|")))))
|
1993-10-22 02:53:24 +00:00
|
|
|
|
|
|
|
(defun shell-dynamic-complete-command ()
|
|
|
|
"Dynamically complete the command at point.
|
|
|
|
This function is similar to `comint-dynamic-complete-filename', except that it
|
2013-12-27 20:58:21 +00:00
|
|
|
searches `exec-path' (minus trailing `exec-directory') for completion
|
1993-10-22 02:53:24 +00:00
|
|
|
candidates. Note that this may not be the same as the shell's idea of the
|
|
|
|
path.
|
|
|
|
|
2013-12-27 20:58:21 +00:00
|
|
|
Completion is dependent on the value of `shell-completion-execonly',
|
|
|
|
`shell-completion-fignore', plus those that affect file completion. See Info
|
|
|
|
node `Shell Options'.
|
1994-03-03 23:37:27 +00:00
|
|
|
|
|
|
|
Returns t if successful."
|
1993-10-22 02:53:24 +00:00
|
|
|
(interactive)
|
2011-04-20 22:31:06 +00:00
|
|
|
(let ((data (shell-command-completion)))
|
|
|
|
(if data
|
Do not call to `selected-window' where it is assumed by default.
Affected functions are `window-minibuffer-p', `window-dedicated-p',
`window-hscroll', `window-width', `window-height', `window-buffer',
`window-frame', `window-start', `window-point', `next-window'
and `window-display-table'.
* abbrev.el (abbrev--default-expand):
* bs.el (bs--show-with-configuration):
* buff-menu.el (Buffer-menu-mouse-select):
* calc/calc.el (calc):
* calendar/calendar.el (calendar-generate-window):
* calendar/diary-lib.el (diary-simple-display, diary-show-all-entries)
(diary-make-entry):
* comint.el (send-invisible, comint-dynamic-complete-filename)
(comint-dynamic-simple-complete, comint-dynamic-list-completions):
* completion.el (complete):
* dabbrev.el (dabbrev-expand, dabbrev--make-friend-buffer-list):
* disp-table.el (describe-current-display-table):
* doc-view.el (doc-view-insert-image):
* ebuff-menu.el (Electric-buffer-menu-mouse-select):
* ehelp.el (with-electric-help):
* emacs-lisp/easy-mmode.el (easy-mmode-define-navigation):
* emacs-lisp/edebug.el (edebug-two-window-p, edebug-pop-to-buffer):
* emacs-lisp/helper.el (Helper-help-scroller):
* emulation/cua-base.el (cua--post-command-handler-1):
* eshell/esh-mode.el (eshell-output-filter):
* ffap.el (ffap-gnus-wrapper):
* help-macro.el (make-help-screen):
* hilit-chg.el (highlight-compare-buffers):
* hippie-exp.el (hippie-expand, try-expand-dabbrev-visible):
* hl-line.el (global-hl-line-highlight):
* icomplete.el (icomplete-simple-completing-p):
* isearch.el (isearch-done):
* jit-lock.el (jit-lock-stealth-fontify):
* mail/rmailsum.el (rmail-summary-scroll-msg-up):
* lisp/mouse-drag.el (mouse-drag-should-do-col-scrolling):
* mpc.el (mpc-tagbrowser, mpc):
* net/rcirc.el (rcirc-any-buffer):
* play/gomoku.el (gomoku-max-width, gomoku-max-height):
* play/landmark.el (landmark-max-width, landmark-max-height):
* play/zone.el (zone):
* progmodes/compile.el (compilation-goto-locus):
* progmodes/ebrowse.el (ebrowse-view/find-file-and-search-pattern):
* progmodes/etags.el (find-tag-other-window):
* progmodes/fortran.el (fortran-column-ruler):
* progmodes/gdb-mi.el (gdb-mouse-toggle-breakpoint-fringe):
* progmodes/verilog-mode.el (verilog-point-text):
* reposition.el (reposition-window):
* rot13.el (toggle-rot13-mode):
* server.el (server-switch-buffer):
* shell.el (shell-dynamic-complete-command)
(shell-dynamic-complete-environment-variable):
* simple.el (insert-buffer, set-selective-display)
(delete-completion-window):
* speedbar.el (speedbar-timer-fn, speedbar-center-buffer-smartly)
(speedbar-recenter):
* startup.el (fancy-splash-head):
* textmodes/ispell.el (ispell-command-loop):
* textmodes/makeinfo.el (makeinfo-compilation-sentinel-region):
* tutorial.el (help-with-tutorial):
* vc/add-log.el (add-change-log-entry):
* vc/compare-w.el (compare-windows):
* vc/ediff-help.el (ediff-indent-help-message):
* vc/ediff-util.el (ediff-setup-control-buffer, ediff-position-region):
* vc/ediff-wind.el (ediff-skip-unsuitable-frames)
(ediff-setup-control-frame):
* vc/emerge.el (emerge-position-region):
* vc/pcvs-util.el (cvs-bury-buffer):
* window.el (walk-windows, mouse-autoselect-window-select):
* winner.el (winner-set-conf, winner-undo): Related users changed.
2013-08-05 14:26:57 +00:00
|
|
|
(prog2 (unless (window-minibuffer-p)
|
2011-04-20 22:31:06 +00:00
|
|
|
(message "Completing command name..."))
|
|
|
|
(apply #'completion-in-region data)))))
|
|
|
|
|
|
|
|
(defun shell-command-completion ()
|
|
|
|
"Return the completion data for the command at point, if any."
|
1994-03-03 23:37:27 +00:00
|
|
|
(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))))
|
2011-04-20 22:31:06 +00:00
|
|
|
(shell--command-completion-data))))
|
1994-03-03 23:37:27 +00:00
|
|
|
|
2011-04-20 22:31:06 +00:00
|
|
|
(defun shell--command-completion-data ()
|
|
|
|
"Return the completion data for the command at point."
|
1994-03-24 07:51:27 +00:00
|
|
|
(let* ((filename (or (comint-match-partial-filename) ""))
|
2011-04-20 22:31:06 +00:00
|
|
|
(start (if (zerop (length filename)) (point) (match-beginning 0)))
|
|
|
|
(end (if (zerop (length filename)) (point) (match-end 0)))
|
2003-12-29 19:13:28 +00:00
|
|
|
(filenondir (file-name-nondirectory filename))
|
2013-12-27 20:58:21 +00:00
|
|
|
; why cdr? see `shell-dynamic-complete-command'
|
|
|
|
(path-dirs (append (cdr (reverse exec-path))
|
|
|
|
(if (memq system-type '(windows-nt ms-dos)) '("."))))
|
1993-10-22 02:53:24 +00:00
|
|
|
(cwd (file-name-as-directory (expand-file-name default-directory)))
|
|
|
|
(ignored-extensions
|
1994-03-10 18:54:44 +00:00
|
|
|
(and comint-completion-fignore
|
2011-04-20 22:31:06 +00:00
|
|
|
(mapconcat (function (lambda (x) (concat (regexp-quote x) "\\'")))
|
1994-03-10 18:54:44 +00:00
|
|
|
comint-completion-fignore "\\|")))
|
2005-06-16 16:10:43 +00:00
|
|
|
(dir "") (comps-in-dir ())
|
2003-12-29 19:13:28 +00:00
|
|
|
(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)))
|
1993-10-22 02:53:24 +00:00
|
|
|
;; Go thru each completion found, to see whether it should be used.
|
2003-12-29 19:13:28 +00:00
|
|
|
(while comps-in-dir
|
|
|
|
(setq file (car comps-in-dir)
|
|
|
|
abs-file-name (concat dir file))
|
1993-10-22 02:53:24 +00:00
|
|
|
(if (and (not (member file completions))
|
1994-04-14 19:19:30 +00:00
|
|
|
(not (and ignored-extensions
|
|
|
|
(string-match ignored-extensions file)))
|
2003-12-29 19:13:28 +00:00
|
|
|
(or (string-equal dir cwd)
|
|
|
|
(not (file-directory-p abs-file-name)))
|
1993-10-22 02:53:24 +00:00
|
|
|
(or (null shell-completion-execonly)
|
2003-12-29 19:13:28 +00:00
|
|
|
(file-executable-p abs-file-name)))
|
1993-10-22 02:53:24 +00:00
|
|
|
(setq completions (cons file completions)))
|
2003-12-29 19:13:28 +00:00
|
|
|
(setq comps-in-dir (cdr comps-in-dir)))
|
|
|
|
(setq path-dirs (cdr path-dirs)))
|
1993-10-22 02:53:24 +00:00
|
|
|
;; OK, we've got a list of completions.
|
2011-04-20 22:31:06 +00:00
|
|
|
(list
|
|
|
|
start end
|
|
|
|
(lambda (string pred action)
|
2011-05-24 02:45:50 +00:00
|
|
|
(if (string-match "/" string)
|
|
|
|
(completion-file-name-table string pred action)
|
|
|
|
(complete-with-action action completions string pred)))
|
|
|
|
:exit-function
|
|
|
|
(lambda (_string finished)
|
|
|
|
(when (memq finished '(sole finished))
|
|
|
|
(if (looking-at " ")
|
|
|
|
(goto-char (match-end 0))
|
|
|
|
(insert " ")))))))
|
2011-04-20 22:31:06 +00:00
|
|
|
|
|
|
|
;; (defun shell-dynamic-complete-as-command ()
|
|
|
|
;; "Dynamically complete at point as a command.
|
|
|
|
;; See `shell-dynamic-complete-filename'. Returns t if successful."
|
|
|
|
;; (apply #'completion-in-region shell--command-completion-data))
|
1994-03-03 23:37:27 +00:00
|
|
|
|
2008-04-03 05:13:15 +00:00
|
|
|
(defun shell-dynamic-complete-filename ()
|
|
|
|
"Dynamically complete the filename at point.
|
|
|
|
This completes only if point is at a suitable position for a
|
|
|
|
filename argument."
|
|
|
|
(interactive)
|
2011-04-20 22:31:06 +00:00
|
|
|
(let ((data (shell-filename-completion)))
|
|
|
|
(if data (apply #'completion-in-region data))))
|
|
|
|
|
|
|
|
(defun shell-filename-completion ()
|
|
|
|
"Return the completion data for file name at point, if any."
|
2008-04-03 05:13:15 +00:00
|
|
|
(let ((opoint (point))
|
|
|
|
(beg (comint-line-beginning-position)))
|
|
|
|
(when (save-excursion
|
|
|
|
(goto-char (if (re-search-backward "[;|&]" beg t)
|
|
|
|
(match-end 0)
|
|
|
|
beg))
|
|
|
|
(re-search-forward "[^ \t][ \t]" opoint t))
|
2011-04-20 22:31:06 +00:00
|
|
|
(comint-filename-completion))))
|
1994-03-03 23:37:27 +00:00
|
|
|
|
|
|
|
(defun shell-match-partial-variable ()
|
1996-06-04 15:27:52 +00:00
|
|
|
"Return the shell variable at point, or nil if none is found."
|
1994-03-03 23:37:27 +00:00
|
|
|
(save-excursion
|
2011-04-20 22:31:06 +00:00
|
|
|
(if (re-search-backward "[^A-Za-z0-9_{(]" nil 'move)
|
|
|
|
(or (looking-at "\\$") (forward-char 1)))
|
|
|
|
(if (or (eolp) (looking-at "[^A-Za-z0-9_{($]"))
|
|
|
|
nil
|
|
|
|
(looking-at "\\$?[{(]?[A-Za-z0-9_]*[})]?")
|
|
|
|
(buffer-substring (match-beginning 0) (match-end 0)))))
|
1991-05-08 07:47:45 +00:00
|
|
|
|
1994-03-03 23:37:27 +00:00
|
|
|
(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 \"$\".
|
|
|
|
|
|
|
|
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)
|
2011-04-20 22:31:06 +00:00
|
|
|
(let ((data (shell-environment-variable-completion)))
|
|
|
|
(if data
|
Do not call to `selected-window' where it is assumed by default.
Affected functions are `window-minibuffer-p', `window-dedicated-p',
`window-hscroll', `window-width', `window-height', `window-buffer',
`window-frame', `window-start', `window-point', `next-window'
and `window-display-table'.
* abbrev.el (abbrev--default-expand):
* bs.el (bs--show-with-configuration):
* buff-menu.el (Buffer-menu-mouse-select):
* calc/calc.el (calc):
* calendar/calendar.el (calendar-generate-window):
* calendar/diary-lib.el (diary-simple-display, diary-show-all-entries)
(diary-make-entry):
* comint.el (send-invisible, comint-dynamic-complete-filename)
(comint-dynamic-simple-complete, comint-dynamic-list-completions):
* completion.el (complete):
* dabbrev.el (dabbrev-expand, dabbrev--make-friend-buffer-list):
* disp-table.el (describe-current-display-table):
* doc-view.el (doc-view-insert-image):
* ebuff-menu.el (Electric-buffer-menu-mouse-select):
* ehelp.el (with-electric-help):
* emacs-lisp/easy-mmode.el (easy-mmode-define-navigation):
* emacs-lisp/edebug.el (edebug-two-window-p, edebug-pop-to-buffer):
* emacs-lisp/helper.el (Helper-help-scroller):
* emulation/cua-base.el (cua--post-command-handler-1):
* eshell/esh-mode.el (eshell-output-filter):
* ffap.el (ffap-gnus-wrapper):
* help-macro.el (make-help-screen):
* hilit-chg.el (highlight-compare-buffers):
* hippie-exp.el (hippie-expand, try-expand-dabbrev-visible):
* hl-line.el (global-hl-line-highlight):
* icomplete.el (icomplete-simple-completing-p):
* isearch.el (isearch-done):
* jit-lock.el (jit-lock-stealth-fontify):
* mail/rmailsum.el (rmail-summary-scroll-msg-up):
* lisp/mouse-drag.el (mouse-drag-should-do-col-scrolling):
* mpc.el (mpc-tagbrowser, mpc):
* net/rcirc.el (rcirc-any-buffer):
* play/gomoku.el (gomoku-max-width, gomoku-max-height):
* play/landmark.el (landmark-max-width, landmark-max-height):
* play/zone.el (zone):
* progmodes/compile.el (compilation-goto-locus):
* progmodes/ebrowse.el (ebrowse-view/find-file-and-search-pattern):
* progmodes/etags.el (find-tag-other-window):
* progmodes/fortran.el (fortran-column-ruler):
* progmodes/gdb-mi.el (gdb-mouse-toggle-breakpoint-fringe):
* progmodes/verilog-mode.el (verilog-point-text):
* reposition.el (reposition-window):
* rot13.el (toggle-rot13-mode):
* server.el (server-switch-buffer):
* shell.el (shell-dynamic-complete-command)
(shell-dynamic-complete-environment-variable):
* simple.el (insert-buffer, set-selective-display)
(delete-completion-window):
* speedbar.el (speedbar-timer-fn, speedbar-center-buffer-smartly)
(speedbar-recenter):
* startup.el (fancy-splash-head):
* textmodes/ispell.el (ispell-command-loop):
* textmodes/makeinfo.el (makeinfo-compilation-sentinel-region):
* tutorial.el (help-with-tutorial):
* vc/add-log.el (add-change-log-entry):
* vc/compare-w.el (compare-windows):
* vc/ediff-help.el (ediff-indent-help-message):
* vc/ediff-util.el (ediff-setup-control-buffer, ediff-position-region):
* vc/ediff-wind.el (ediff-skip-unsuitable-frames)
(ediff-setup-control-frame):
* vc/emerge.el (emerge-position-region):
* vc/pcvs-util.el (cvs-bury-buffer):
* window.el (walk-windows, mouse-autoselect-window-select):
* winner.el (winner-set-conf, winner-undo): Related users changed.
2013-08-05 14:26:57 +00:00
|
|
|
(prog2 (unless (window-minibuffer-p)
|
2008-03-21 23:52:27 +00:00
|
|
|
(message "Completing variable name..."))
|
2011-04-20 22:31:06 +00:00
|
|
|
(apply #'completion-in-region data)))))
|
|
|
|
|
|
|
|
|
|
|
|
(defun shell-environment-variable-completion ()
|
|
|
|
"Completion data for an environment variable at point, if any."
|
|
|
|
(let* ((var (shell-match-partial-variable))
|
|
|
|
(end (match-end 0)))
|
|
|
|
(when (and (not (zerop (length var))) (eq (aref var 0) ?$))
|
|
|
|
(let* ((start
|
|
|
|
(save-excursion
|
|
|
|
(goto-char (match-beginning 0))
|
|
|
|
(looking-at "\\$?[({]*")
|
|
|
|
(match-end 0)))
|
|
|
|
(variables (mapcar (lambda (x)
|
|
|
|
(substring x 0 (string-match "=" x)))
|
|
|
|
process-environment))
|
More CL cleanups and reduction of use of cl.el.
* woman.el, winner.el, vc/vc-rcs.el, vc/vc-hooks.el, vc/vc-hg.el:
* vc/vc-git.el, vc/vc-dir.el, vc/vc-bzr.el, vc/vc-annotate.el:
* textmodes/tex-mode.el, textmodes/sgml-mode.el, tar-mode.el:
* strokes.el, ses.el, server.el, progmodes/js.el, progmodes/gdb-mi.el:
* progmodes/flymake.el, progmodes/ebrowse.el, progmodes/compile.el:
* play/tetris.el, play/snake.el, play/pong.el, play/landmark.el:
* play/hanoi.el, play/decipher.el, play/5x5.el, nxml/nxml-mode.el:
* net/secrets.el, net/quickurl.el, midnight.el, mail/footnote.el:
* image-dired.el, ibuffer.el, ibuf-macs.el, ibuf-ext.el, hexl.el:
* eshell/eshell.el, eshell/esh-io.el, eshell/esh-ext.el:
* eshell/esh-cmd.el, eshell/em-ls.el, eshell/em-hist.el:
* eshell/em-cmpl.el, eshell/em-banner.el:
* url/url.el, url/url-queue.el, url/url-parse.el, url/url-http.el:
* url/url-future.el, url/url-dav.el, url/url-cookie.el:
* calendar/parse-time.el, test/eshell.el: Use cl-lib.
* wid-browse.el, wdired.el, vc/vc.el, vc/vc-mtn.el, vc/vc-cvs.el:
* vc/vc-arch.el, tree-widget.el, textmodes/texinfo.el:
* textmodes/refill.el, textmodes/css-mode.el, term/tvi970.el:
* term/ns-win.el, term.el, shell.el, ps-samp.el:
* progmodes/perl-mode.el, progmodes/pascal.el, progmodes/gud.el:
* progmodes/glasses.el, progmodes/etags.el, progmodes/cwarn.el:
* play/gamegrid.el, play/bubbles.el, novice.el, notifications.el:
* net/zeroconf.el, net/xesam.el, net/snmp-mode.el, net/mairix.el:
* net/ldap.el, net/eudc.el, net/browse-url.el, man.el:
* mail/mailheader.el, mail/feedmail.el:
* url/url-util.el, url/url-privacy.el, url/url-nfs.el, url/url-misc.el:
* url/url-methods.el, url/url-gw.el, url/url-file.el, url/url-expand.el:
Dont use CL.
* ibuf-ext.el (ibuffer-mark-old-buffers): Use float-time.
* eshell/esh-opt.el (eshell-eval-using-options): Quote code with
`lambda' rather than with `quote'.
(eshell-do-opt): Adjust accordingly.
(eshell-process-option): Simplify.
* eshell/esh-var.el:
* eshell/em-script.el: Require `esh-opt' for eshell-eval-using-options.
* emacs-pcase.el (pcase--dontcare-upats, pcase--let*)
(pcase--expand, pcase--u1): Rename pcase's internal `dontcare' pattern
to `pcase--dontcare'.
* emacs-cl.el (labels): Mark obsolete.
(cl--letf, letf): Move to cl-lib.
(cl--letf*, letf*): Remove.
* emacs-cl-lib.el (cl-nth-value): Use defalias.
* emacs-cl-macs.el (cl-dolist, cl-dotimes): Add indent rule.
(cl-progv): Rewrite.
(cl--letf, cl-letf): Move from cl.el.
(cl-letf*): New macro.
* emacs-cl-extra.el (cl--progv-before, cl--progv-after): Remove.
2012-07-11 23:13:41 +00:00
|
|
|
(suffix (pcase (char-before start) (?\{ "}") (?\( ")") (_ ""))))
|
2011-05-24 02:45:50 +00:00
|
|
|
(list start end variables
|
|
|
|
:exit-function
|
|
|
|
(lambda (s finished)
|
|
|
|
(when (memq finished '(sole finished))
|
|
|
|
(let ((suf (concat suffix
|
|
|
|
(if (file-directory-p
|
|
|
|
(comint-directory (getenv s)))
|
|
|
|
"/"))))
|
|
|
|
(if (looking-at (regexp-quote suf))
|
|
|
|
(goto-char (match-end 0))
|
|
|
|
(insert suf))))))))))
|
2011-04-20 22:31:06 +00:00
|
|
|
|
|
|
|
|
|
|
|
(defun shell-c-a-p-replace-by-expanded-directory ()
|
|
|
|
"Expand directory stack reference before point.
|
|
|
|
For use on `completion-at-point-functions'."
|
|
|
|
(when (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)))))))
|
|
|
|
(when index
|
|
|
|
(let ((start (match-beginning 0))
|
|
|
|
(end (match-end 0))
|
|
|
|
(replacement (file-name-as-directory (nth index stack))))
|
|
|
|
(lambda ()
|
|
|
|
(cond
|
|
|
|
((>= index (length stack))
|
|
|
|
(error "Directory stack not that deep"))
|
|
|
|
(t
|
|
|
|
(save-excursion
|
|
|
|
(goto-char start)
|
|
|
|
(insert replacement)
|
|
|
|
(delete-char (- end start)))
|
|
|
|
(message "Directory item: %d" index)
|
|
|
|
t)))))))))
|
1994-03-03 23:37:27 +00:00
|
|
|
|
|
|
|
(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)
|
2011-04-20 22:31:06 +00:00
|
|
|
(let ((f (shell-c-a-p-replace-by-expanded-directory)))
|
|
|
|
(if f (funcall f))))
|
2001-01-28 03:43:35 +00:00
|
|
|
|
1992-05-30 21:11:25 +00:00
|
|
|
(provide 'shell)
|
|
|
|
|
|
|
|
;;; shell.el ends here
|