Revision: emacs@sv.gnu.org/emacs--unicode--0--patch-58

Merge from emacs--devo--0

Patches applied:

 * emacs--devo--0  (patch 239-258)

   - Update from CVS
   - (Ffield_beginning, find_field): Undo change of 2006-04-23.
   - Rcirc patch from Ryan Yeske
   - Merge from gnus--rel--5.10
   - Clean up lisp/gnus/ChangeLog a bit

 * gnus--rel--5.10  (patch 91-98)

   - Merge from emacs--devo--0
   - Update from CVS

6 files changed, 350 insertions, 244 deletions

diff --git a/lisp/progmodes/antlr-mode.el b/lisp/progmodes/antlr-mode.el
index 7ddd9212f6c..e31a94030c3 100644
--- a/lisp/progmodes/antlr-mode.el
+++ b/lisp/progmodes/antlr-mode.el
@@ -829,7 +829,7 @@ in the grammar's actions and semantic predicates, see
 `antlr-font-lock-maximum-decoration'.")
 
 (defvar antlr-default-face 'antlr-default)
-(defface antlr-default nil
+(defface antlr-default '((t nil))
   "Face to prevent strings from language dependent highlighting.
 Do not change."
   :group 'antlr)
diff --git a/lisp/progmodes/asm-mode.el b/lisp/progmodes/asm-mode.el
index b79237adba7..ebb532a3525 100644
--- a/lisp/progmodes/asm-mode.el
+++ b/lisp/progmodes/asm-mode.el
@@ -62,9 +62,9 @@
 
 (defvar asm-mode-syntax-table
   (let ((st (make-syntax-table)))
-    (modify-syntax-entry ?\n ">" st)
-    (modify-syntax-entry ?/  ". 14b" st)
-    (modify-syntax-entry ?*  ". 23b" st)
+    (modify-syntax-entry ?\n "> b" st)
+    (modify-syntax-entry ?/  ". 124b" st)
+    (modify-syntax-entry ?*  ". 23" st)
     st)
   "Syntax table used while in Asm mode.")
 
@@ -136,14 +136,14 @@ Special commands:
   (use-local-map (nconc (make-sparse-keymap) asm-mode-map))
   (local-set-key (vector asm-comment-char) 'asm-comment)
   (set-syntax-table (make-syntax-table asm-mode-syntax-table))
-  (modify-syntax-entry  asm-comment-char "<")
+  (modify-syntax-entry  asm-comment-char "< b")
 
   (make-local-variable 'comment-start)
   (setq comment-start (string asm-comment-char))
   (make-local-variable 'comment-add)
   (setq comment-add 1)
   (make-local-variable 'comment-start-skip)
-  (setq comment-start-skip "\\(?:\\s<+\\|/\\*+\\)[ \t]*")
+  (setq comment-start-skip "\\(?:\\s<+\\|/[/*]+\\)[ \t]*")
   (make-local-variable 'comment-end-skip)
   (setq comment-end-skip "[ \t]*\\(\\s>\\|\\*+/\\)")
   (make-local-variable 'comment-end)
diff --git a/lisp/progmodes/cc-subword.el b/lisp/progmodes/cc-subword.el
index 6ba76708ebf..72227e33290 100644
--- a/lisp/progmodes/cc-subword.el
+++ b/lisp/progmodes/cc-subword.el
@@ -91,8 +91,8 @@
 ;; Don't complain about the `define-minor-mode' form if it isn't defined.
 (cc-bytecomp-defvar c-subword-mode)
 
-;;; Autoload directives must be on the top level, so we construct an
-;;; autoload form instead.
+;; Autoload directives must be on the top level, so we construct an
+;; autoload form instead.
 ;;;###autoload (autoload 'c-subword-mode "cc-subword" "Mode enabling subword movement and editing keys." t)
 
 (if (not (fboundp 'define-minor-mode))
@@ -107,36 +107,19 @@ telling us which (X)Emacs version you're using."
 
   (defvar c-subword-mode-map
     (let ((map (make-sparse-keymap)))
-      (substitute-key-definition 'forward-word
-                                 'c-forward-subword
-                                 map global-map)
-      (substitute-key-definition 'backward-word
-                                 'c-backward-subword
-                                 map global-map)
-      (substitute-key-definition 'mark-word
-                                 'c-mark-subword
-                                 map global-map)
-    
-      (substitute-key-definition 'kill-word
-                                 'c-kill-subword
-                                 map global-map)
-      (substitute-key-definition 'backward-kill-word
-                                 'c-backward-kill-subword
-                                 map global-map)
-    
-      (substitute-key-definition 'transpose-words
-                                 'c-transpose-subwords
-                                 map global-map)
-    
-      (substitute-key-definition 'capitalize-word
-                                 'c-capitalize-subword
-                                 map global-map)
-      (substitute-key-definition 'upcase-word
-                                 'c-upcase-subword
-                                 map global-map)
-      (substitute-key-definition 'downcase-word
-                                 'c-downcase-subword
-                                 map global-map)
+      (dolist (cmd '(forward-word backward-word mark-word
+                     kill-word backward-kill-word
+                     transpose-words
+                     capitalize-word upcase-word downcase-word))
+        (let ((othercmd (let ((name (symbol-name cmd)))
+                          (string-match "\\(.*-\\)\\(word.*\\)" name)
+                          (intern (concat "c-"
+                                          (match-string 1 name)
+                                          "sub"
+                                          (match-string 2 name))))))
+          (if (fboundp 'command-remapping)
+              (define-key map (vector 'remap cmd) othercmd)
+            (substitute-key-definition cmd othercmd map global-map))))
       map)
     "Keymap used in command `c-subword-mode' minor mode.")
 
@@ -308,5 +291,5 @@ Optional argument ARG is the same as for `upcase-word'."
 
 (cc-provide 'cc-subword)
 
-;;; arch-tag: 2be9d294-7f30-4626-95e6-9964bb93c7a3
+;; arch-tag: 2be9d294-7f30-4626-95e6-9964bb93c7a3
 ;;; cc-subword.el ends here
diff --git a/lisp/progmodes/grep.el b/lisp/progmodes/grep.el
index 6afa3f29348..0aba9d42b84 100644
--- a/lisp/progmodes/grep.el
+++ b/lisp/progmodes/grep.el
@@ -35,7 +35,7 @@
 
 
 (defgroup grep nil
-  "Run compiler as inferior of Emacs, parse error messages."
+  "Run grep as inferior of Emacs, parse error messages."
   :group 'tools
   :group 'processes)
 
@@ -48,23 +48,6 @@
   :version "22.1"
   :group 'grep)
 
-(defcustom grep-auto-highlight t
-  "*Specify how many grep matches to highlight (and parse) initially.
-\(Highlighting applies to an grep match when the mouse is over it.)
-If this is a number N, all grep matches in the first N lines
-are highlighted and parsed as soon as they arrive in Emacs.
-If t, highlight and parse the whole grep output as soon as it arrives.
-If nil, don't highlight or parse any of the grep buffer until you try to
-move to the error messages.
-
-Those grep matches which are not parsed and highlighted initially
-will be parsed and highlighted as soon as you try to move to them."
-  :type '(choice (const :tag "All" t)
-                 (const :tag "None" nil)
-                 (integer :tag "First N lines"))
-  :version "22.1"
-  :group 'grep)
-
 (defcustom grep-highlight-matches 'auto-detect
   "If t, use special markers to highlight grep matches.
 
@@ -108,6 +91,20 @@ call that function before using this variable in your program."
                  (const :tag "Not Set" nil))
   :group 'grep)
 
+(defcustom grep-template nil
+  "The default command to run for \\[lgrep].
+The default value of this variable is set up by `grep-compute-defaults';
+call that function before using this variable in your program.
+The following place holders should be present in the string:
+ <C> - place to put -i if case insensitive grep.
+ <F> - file names and wildcards to search.
+ <R> - the regular expression searched for.
+ <N> - place to insert null-device."
+  :type '(choice string
+                 (const :tag "Not Set" nil))
+  :version "22.1"
+  :group 'grep)
+
 (defcustom grep-use-null-device 'auto-detect
   "If t, append the value of `null-device' to `grep' commands.
 This is done to ensure that the output of grep includes the filename of
@@ -130,8 +127,8 @@ call that function before using this variable in your program."
                  (const :tag "Not Set" nil))
   :group 'grep)
 
-(defcustom grep-tree-command nil
-  "The default find command for \\[grep-tree].
+(defcustom grep-find-template nil
+  "The default command to run for \\[rgrep].
 The default value of this variable is set up by `grep-compute-defaults';
 call that function before using this variable in your program.
 The following place holders should be present in the string:
@@ -145,27 +142,22 @@ The following place holders should be present in the string:
   :version "22.1"
   :group 'grep)
 
-(defcustom grep-tree-files-aliases '(
+(defcustom grep-files-aliases '(
+        ("el" . "*.el")
         ("ch" . "*.[ch]")
         ("c" .  "*.c")
         ("h" .  "*.h")
-        ("m" .  "[Mm]akefile*")
         ("asm" . "*.[sS]")
-        ("all" . "*")
-        ("el" . "*.el")
+        ("m" .  "[Mm]akefile*")
+        ("l" . "[Cc]hange[Ll]og*")
         )
-  "*Alist of aliases for the FILES argument to `grep-tree'."
+  "*Alist of aliases for the FILES argument to `lgrep' and `rgrep'."
   :type 'alist
   :group 'grep)
 
-(defcustom grep-tree-ignore-case t
-  "*If non-nil, `grep-tree' ignores case in matches."
-  :type 'boolean
-  :group 'grep)
-
-(defcustom grep-tree-ignore-CVS-directories t
-  "*If non-nil, `grep-tree' does no recurse into CVS directories."
-  :type 'boolean
+(defcustom grep-find-ignored-directories '("CVS" ".hg" "{arch}")
+  "*List of names of sub-directories which `rgrep' shall not recurse into."
+  :type '(repeat string)
   :group 'grep)
 
 (defcustom grep-error-screen-columns nil
@@ -208,6 +200,8 @@ See `compilation-error-screen-columns'"
       '("Compile..." . compile))
     (define-key map [menu-bar grep compilation-grep]
       '("Another grep..." . grep))
+    (define-key map [menu-bar grep compilation-grep-find]
+      '("Recursive grep..." . grep-find))
     (define-key map [menu-bar grep compilation-recompile]
       '("Repeat grep" . recompile))
     (define-key map [menu-bar grep compilation-separator2]
@@ -353,6 +347,11 @@ This variable's value takes effect when `grep-compute-defaults' is called.")
 ;;;###autoload
 (defvar grep-find-history nil)
 
+;; History of lgrep and rgrep regexp and files args.
+(defvar grep-regexp-history nil)
+(defvar grep-files-history '("ch" "el"))
+
+
 ;;;###autoload
 (defun grep-process-setup ()
   "Setup compilation variables and buffer for `grep'.
@@ -378,6 +377,12 @@ Set up `compilation-exit-message-function' and run `grep-setup-hook'."
            (cons msg code))))
   (run-hooks 'grep-setup-hook))
 
+(defun grep-probe (command args &optional func result)
+  (equal (condition-case nil
+             (apply (or func 'call-process) command args)
+           (error nil))
+         (or result 0)))
+
 ;;;###autoload
 (defun grep-compute-defaults ()
   (unless (or (not grep-use-null-device) (eq grep-use-null-device t))
@@ -385,73 +390,67 @@ Set up `compilation-exit-message-function' and run `grep-setup-hook'."
           (with-temp-buffer
             (let ((hello-file (expand-file-name "HELLO" data-directory)))
               (not
-               (and (equal (condition-case nil
-                               (if grep-command
-                                   ;; `grep-command' is already set, so
-                                   ;; use that for testing.
-                                   (call-process-shell-command
-                                    grep-command nil t nil
-                                    "^English" hello-file)
-                                 ;; otherwise use `grep-program'
-                                 (call-process grep-program nil t nil
-                                               "-nH" "^English" hello-file))
-                             (error nil))
-                           0)
+               (and (if grep-command
+                        ;; `grep-command' is already set, so
+                        ;; use that for testing.
+                        (grep-probe grep-command
+                                    `(nil t nil "^English" ,hello-file)
+                                    #'call-process-shell-command)
+                      ;; otherwise use `grep-program'
+                      (grep-probe grep-program
+                                  `(nil t nil "-nH" "^English" ,hello-file)))
                     (progn
                       (goto-char (point-min))
                       (looking-at
                        (concat (regexp-quote hello-file)
                                ":[0-9]+:English")))))))))
-  (unless grep-command
-    (setq grep-command
-          (let ((required-options (if grep-use-null-device "-n" "-nH")))
-            (if (equal (condition-case nil ; in case "grep" isn't in exec-path
-                           (call-process grep-program nil nil nil
-                                         "-e" "foo" null-device)
-                         (error nil))
-                       1)
-                (format "%s %s -e " grep-program required-options)
-              (format "%s %s " grep-program required-options)))))
-  (unless grep-find-use-xargs
-    (setq grep-find-use-xargs
-          (if (and
-               (equal (call-process "find" nil nil nil
-                                    null-device "-print0")
-                      0)
-               (equal (call-process "xargs" nil nil nil
-                                    "-0" "-e" "echo")
-                      0))
-              'gnu)))
-  (unless grep-find-command
-    (setq grep-find-command
-          (cond ((eq grep-find-use-xargs 'gnu)
-                 (format "%s . -type f -print0 | xargs -0 -e %s"
-                         find-program grep-command))
-                (grep-find-use-xargs
-                 (format "%s . -type f -print | xargs %s"
-                         find-program grep-command))
-                (t (cons (format "%s . -type f -exec %s {} %s \\;"
-                                 find-program grep-command null-device)
-                         (+ 22 (length grep-command)))))))
-  (unless grep-tree-command
-    (setq grep-tree-command
-          (let* ((glen (length grep-program))
-                 (gcmd (concat grep-program " <C>" (substring grep-command glen))))
-            (cond ((eq grep-find-use-xargs 'gnu)
-                   (format "%s <D> <X> -type f <F> -print0 | xargs -0 -e %s <R>"
-                           find-program gcmd))
-                  (grep-find-use-xargs
-                   (format "%s <D> <X> -type f <F> -print | xargs %s <R>"
-                           find-program gcmd))
-                  (t (format "%s <D> <X> -type f <F> -exec %s <R> {} %s \\;"
-                             find-program gcmd null-device))))))
+  (unless (and grep-command grep-find-command
+               grep-template grep-find-template)
+    (let ((grep-options
+           (concat (if grep-use-null-device "-n" "-nH")
+                   (if (grep-probe grep-program
+                                   `(nil nil nil "-e" "foo" ,null-device)
+                                   nil 1)
+                       " -e"))))
+      (unless grep-command
+        (setq grep-command
+              (format "%s %s " grep-program grep-options)))
+      (unless grep-template
+        (setq grep-template
+              (format "%s <C> %s <R> <F>" grep-program grep-options)))
+      (unless grep-find-use-xargs
+        (setq grep-find-use-xargs
+              (if (and
+                   (grep-probe find-program `(nil nil nil ,null-device "-print0"))
+                   (grep-probe "xargs" `(nil nil nil "-0" "-e" "echo")))
+                  'gnu)))
+      (unless grep-find-command
+        (setq grep-find-command
+              (cond ((eq grep-find-use-xargs 'gnu)
+                     (format "%s . -type f -print0 | xargs -0 -e %s"
+                             find-program grep-command))
+                    (grep-find-use-xargs
+                     (format "%s . -type f -print | xargs %s"
+                             find-program grep-command))
+                    (t (cons (format "%s . -type f -exec %s {} %s \\;"
+                                     find-program grep-command null-device)
+                             (+ 22 (length grep-command)))))))
+      (unless grep-find-template
+        (setq grep-find-template
+              (let ((gcmd (format "%s <C> %s <R>"
+                                  grep-program grep-options)))
+                (cond ((eq grep-find-use-xargs 'gnu)
+                       (format "%s . <X> -type f <F> -print0 | xargs -0 -e %s"
+                               find-program gcmd))
+                      (grep-find-use-xargs
+                       (format "%s . <X> -type f <F> -print | xargs %s"
+                               find-program gcmd))
+                      (t (format "%s . <X> -type f <F> -exec %s {} %s \\;"
+                                 find-program gcmd null-device))))))))
   (unless (or (not grep-highlight-matches) (eq grep-highlight-matches t))
     (setq grep-highlight-matches
           (with-temp-buffer
-            (and (equal (condition-case nil
-                            (call-process grep-program nil t nil "--help")
-                          (error nil))
-                        0)
+            (and (grep-probe grep-program '(nil t nil "--help"))
                  (progn
                    (goto-char (point-min))
                    (search-forward "--color" nil t))
@@ -487,8 +486,22 @@ Set up `compilation-exit-message-function' and run `grep-setup-hook'."
                                    (file-name-extension buffer-file-name))))
       (replace-match tag-default t t grep-default 1))))
 
+
 ;;;###autoload
-(defun grep (command-args &optional highlight-regexp)
+(define-compilation-mode grep-mode "Grep"
+  "Sets `grep-last-buffer' and `compilation-window-height'."
+  (setq grep-last-buffer (current-buffer))
+  (set (make-local-variable 'compilation-error-face)
+       grep-hit-face)
+  (set (make-local-variable 'compilation-error-regexp-alist)
+       grep-regexp-alist)
+  (set (make-local-variable 'compilation-process-setup-function)
+       'grep-process-setup)
+  (set (make-local-variable 'compilation-disable-input) t))
+
+
+;;;###autoload
+(defun grep (command-args)
   "Run grep, with user-specified args, and collect output in a buffer.
 While grep runs asynchronously, you can use \\[next-error] (M-x next-error),
 or \\<grep-mode-map>\\[compile-goto-error] in the grep \
@@ -501,15 +514,10 @@ easily repeat a grep command.
 A prefix argument says to default the argument based upon the current
 tag the cursor is over, substituting it into the last grep command
 in the grep command history (or into `grep-command'
-if that history list is empty).
-
-If specified, optional second arg HIGHLIGHT-REGEXP is the regexp to
-temporarily highlight in visited source lines."
+if that history list is empty)."
   (interactive
    (progn
-     (unless (and grep-command
-                  (or (not grep-use-null-device) (eq grep-use-null-device t)))
-       (grep-compute-defaults))
+     (grep-compute-defaults)
      (let ((default (grep-default-command)))
        (list (read-from-minibuffer "Run grep (like this): "
                                    (if current-prefix-arg
@@ -522,19 +530,8 @@ temporarily highlight in visited source lines."
   (compilation-start (if (and grep-use-null-device null-device)
                          (concat command-args " " null-device)
                        command-args)
-                     'grep-mode nil highlight-regexp))
+                     'grep-mode))
 
-;;;###autoload
-(define-compilation-mode grep-mode "Grep"
-  "Sets `grep-last-buffer' and `compilation-window-height'."
-  (setq grep-last-buffer (current-buffer))
-  (set (make-local-variable 'compilation-error-face)
-       grep-hit-face)
-  (set (make-local-variable 'compilation-error-regexp-alist)
-       grep-regexp-alist)
-  (set (make-local-variable 'compilation-process-setup-function)
-       'grep-process-setup)
-  (set (make-local-variable 'compilation-disable-input) t))
 
 ;;;###autoload
 (defun grep-find (command-args)
@@ -547,9 +544,7 @@ This command uses a special history list for its arguments, so you can
 easily repeat a find command."
   (interactive
    (progn
-     (unless (and grep-command
-                  (or (not grep-use-null-device) (eq grep-use-null-device t)))
-       (grep-compute-defaults))
+     (grep-compute-defaults)
      (if grep-find-command
          (list (read-from-minibuffer "Run find (like this): "
                                      grep-find-command nil nil
@@ -565,84 +560,190 @@ easily repeat a find command."
 ;;;###autoload
 (defalias 'find-grep 'grep-find)
 
-(defun grep-expand-command-macros (command &optional regexp files dir excl case-fold)
-  "Patch grep COMMAND replacing <D>, etc."
-  (setq command
-        (replace-regexp-in-string "<D>"
-                                  (or dir ".") command t t))
-  (setq command
-        (replace-regexp-in-string "<X>"
-                                  (or excl "") command t t))
-  (setq command
-        (replace-regexp-in-string "<F>"
-                                  (or files "") command t t))
-  (setq command
-        (replace-regexp-in-string "<C>"
-                                  (if case-fold "-i" "") command t t))
-  (setq command
-        (replace-regexp-in-string "<R>"
-                                  (or regexp "") command t t))
-  command)
-
-(defvar grep-tree-last-regexp "")
-(defvar grep-tree-last-files (car (car grep-tree-files-aliases)))
+
+;; User-friendly interactive API.
+
+(defconst grep-expand-keywords
+  '(("<C>" . (and cf (isearch-no-upper-case-p regexp t) "-i"))
+    ("<D>" . dir)
+    ("<F>" . files)
+    ("<N>" . null-device)
+    ("<X>" . excl)
+    ("<R>" . (shell-quote-argument (or regexp ""))))
+  "List of substitutions performed by `grep-expand-template'.
+If car of an element matches, the cdr is evalled in to get the
+substitution string.  Note dynamic scoping of variables.")
+
+(defun grep-expand-template (template &optional regexp files dir excl)
+  "Patch grep COMMAND string replacing <C>, <D>, <F>, <R>, and <X>."
+  (let ((command template)
+        (cf case-fold-search)
+        (case-fold-search nil))
+    (dolist (kw grep-expand-keywords command)
+      (if (string-match (car kw) command)
+          (setq command
+                (replace-match
+                 (or (if (symbolp (cdr kw))
+                         (eval (cdr kw))
+                       (save-match-data (eval (cdr kw))))
+                     "")
+                 t t command))))))
+
+(defun grep-read-regexp ()
+  "Read regexp arg for interactive grep."
+  (let ((default
+          (or (funcall (or find-tag-default-function
+                           (get major-mode 'find-tag-default-function)
+                           'find-tag-default))
+              "")))
+    (read-string
+     (concat "Search for"
+             (if (and default (> (length default) 0))
+                 (format " (default %s): " default) ": "))
+     nil 'grep-regexp-history default)))
+
+(defun grep-read-files (regexp)
+  "Read files arg for interactive grep."
+  (let* ((bn (or (buffer-file-name) (buffer-name)))
+         (fn (and bn
+                  (stringp bn)
+                  (file-name-nondirectory bn)))
+         (default
+           (or (and fn
+                    (let ((aliases grep-files-aliases)
+                          alias)
+                      (while aliases
+                        (setq alias (car aliases)
+                              aliases (cdr aliases))
+                        (if (string-match (wildcard-to-regexp (cdr alias)) fn)
+                            (setq aliases nil)
+                          (setq alias nil)))
+                      (cdr alias)))
+               (and fn
+                    (let ((ext (file-name-extension fn)))
+                      (and ext (concat "*." ext))))))
+         (files (read-string
+                 (concat "Search for \"" regexp
+                         "\" in files"
+                         (if default (concat " (default " default ")"))
+                         ": ")
+                 nil 'grep-files-history default)))
+    (and files
+         (or (cdr (assoc files grep-files-aliases))
+             files))))
 
 ;;;###autoload
-(defun grep-tree (regexp files dir &optional subdirs)
-  "Grep for REGEXP in FILES in directory tree rooted at DIR.
-Collect output in a buffer.
-Interactively, prompt separately for each search parameter.
-With prefix arg, reuse previous REGEXP.
+(defun lgrep (regexp &optional files)
+  "Run grep, searching for REGEXP in FILES in current directory.
 The search is limited to file names matching shell pattern FILES.
-FILES may use abbreviations defined in `grep-tree-files-aliases', e.g.
+FILES may use abbreviations defined in `grep-files-aliases', e.g.
 entering `ch' is equivalent to `*.[ch]'.
 
-While find runs asynchronously, you can use the \\[next-error] command
-to find the text that grep hits refer to.
+With \\[universal-argument] prefix, allow user to edit the constructed
+shell command line before it is executed.
+With two \\[universal-argument] prefixes, edit and run grep shell command.
 
-This command uses a special history list for its arguments, so you can
-easily repeat a find command.
+Collect output in a buffer.  While grep runs asynchronously, you
+can use \\[next-error] (M-x next-error), or \\<grep-mode-map>\\[compile-goto-error]
+in the grep output buffer, to go to the lines where grep found matches.
 
-When used non-interactively, optional arg SUBDIRS limits the search to
-those sub directories of DIR."
+This command shares argument histories with \\[rgrep] and \\[grep]."
   (interactive
-   (let* ((regexp
-           (if current-prefix-arg
-               grep-tree-last-regexp
-             (let* ((default (current-word))
-                    (spec (read-string
-                           (concat "Search for"
-                                   (if (and default (> (length default) 0))
-                                       (format " (default %s): " default) ": ")))))
-               (if (equal spec "") default spec))))
-          (files
-           (read-string (concat "Search for \"" regexp "\" in files (default "   grep-tree-last-files  "): ")))
-          (dir
-           (read-directory-name "Base directory: " nil default-directory t)))
-     (list regexp files dir)))
-  (unless grep-tree-command
-    (grep-compute-defaults))
-  (unless (and (stringp files) (> (length files) 0))
-    (setq files grep-tree-last-files))
-  (when files
-    (setq grep-tree-last-files files)
-    (let ((mf (assoc files grep-tree-files-aliases)))
-      (if mf
-          (setq files (cdr mf)))))
-  (let ((command-args (grep-expand-command-macros
-                       grep-tree-command
-                       (setq grep-tree-last-regexp regexp)
-                       (and files (concat "-name '" files "'"))
-                       (if subdirs
-                           (if (stringp subdirs)
-                               subdirs
-                             (mapconcat 'identity subdirs " "))
-                         nil)  ;; we change default-directory to dir
-                       (and grep-tree-ignore-CVS-directories "-path '*/CVS' -prune -o ")
-                       grep-tree-ignore-case))
-        (default-directory (file-name-as-directory (expand-file-name dir)))
-        (null-device nil))              ; see grep
-    (grep command-args regexp)))
+   (progn
+     (grep-compute-defaults)
+     (cond
+      ((and grep-command (equal current-prefix-arg '(16)))
+       (list (read-from-minibuffer "Run: " grep-command
+                                   nil nil 'grep-history)
+             nil))
+      ((not grep-template)
+       (list nil
+             (read-string "grep.el: No `grep-template' available. Press RET.")))
+      (t (let* ((regexp (grep-read-regexp))
+                (files (grep-read-files regexp)))
+           (list regexp files))))))
+  (when (and (stringp regexp) (> (length regexp) 0))
+    (let ((command regexp))
+      (if (null files)
+          (if (string= command grep-command)
+              (setq command nil))
+        (setq command (grep-expand-template
+                       grep-template
+                       regexp
+                       files))
+        (when command
+          (if (equal current-prefix-arg '(4))
+              (setq command
+                    (read-from-minibuffer "Confirm: "
+                                          command nil nil 'grep-history))
+            (push command grep-history))))
+      (when command
+        ;; Setting process-setup-function makes exit-message-function work
+        ;; even when async processes aren't supported.
+        (compilation-start (if (and grep-use-null-device null-device)
+                               (concat command " " null-device)
+                             command) 'grep-mode)))))
+
+
+;;;###autoload
+(defun rgrep (regexp &optional files dir)
+  "Recusively grep for REGEXP in FILES in directory tree rooted at DIR.
+The search is limited to file names matching shell pattern FILES.
+FILES may use abbreviations defined in `grep-files-aliases', e.g.
+entering `ch' is equivalent to `*.[ch]'.
+
+With \\[universal-argument] prefix, allow user to edit the constructed
+shell command line before it is executed.
+With two \\[universal-argument] prefixes, edit and run grep-find shell command.
+
+Collect output in a buffer.  While find runs asynchronously, you
+can use \\[next-error] (M-x next-error), or \\<grep-mode-map>\\[compile-goto-error]
+in the grep output buffer, to go to the lines where grep found matches.
+
+This command shares argument histories with \\[lgrep] and \\[grep-find]."
+  (interactive
+   (progn
+     (grep-compute-defaults)
+     (cond
+      ((and grep-find-command (equal current-prefix-arg '(16)))
+       (list (read-from-minibuffer "Run: " grep-find-command
+                                   nil nil 'grep-find-history)
+             nil))
+      ((not grep-find-template)
+       (list nil nil
+             (read-string "grep.el: No `grep-find-template' available. Press RET.")))
+      (t (let* ((regexp (grep-read-regexp))
+                (files (grep-read-files regexp))
+                (dir (read-directory-name "Base directory: "
+                                          nil default-directory t)))
+           (list regexp files dir))))))
+  (when (and (stringp regexp) (> (length regexp) 0))
+    (if (null files)
+        (if (not (string= regexp grep-find-command))
+            (compilation-start regexp 'grep-mode))
+      (let* ((default-directory (file-name-as-directory (expand-file-name dir)))
+             (command (grep-expand-template
+                       grep-find-template
+                       regexp
+                       (concat "\\( -name "
+                               (mapconcat #'shell-quote-argument
+                                          (split-string files)
+                                          " -o -name ")
+                               " \\)")
+                       default-directory
+                       (and grep-find-ignored-directories
+                            (concat "\\( -path '*/"
+                                    (mapconcat #'identity
+                                               grep-find-ignored-directories
+                                               "' -o -path '*/")
+                                    "' \\) -prune -o ")))))
+        (when command
+          (if current-prefix-arg
+              (setq command
+                    (read-from-minibuffer "Confirm: "
+                                          command nil nil 'grep-find-history))
+            (push command grep-find-history))
+          (compilation-start command 'grep-mode))))))
 
 
 (provide 'grep)
diff --git a/lisp/progmodes/gud.el b/lisp/progmodes/gud.el
index e1e2b9e28cd..11259aa3965 100644
--- a/lisp/progmodes/gud.el
+++ b/lisp/progmodes/gud.el
@@ -83,6 +83,8 @@ Supported debuggers include gdb, sdb, dbx, xdb, perldb, pdb (Python), jdb, and b
 (defvar gud-minor-mode nil)
 (put 'gud-minor-mode 'permanent-local t)
 
+(defvar gud-comint-buffer nil)
+
 (defvar gud-keep-buffer nil)
 
 (defun gud-symbol (sym &optional soft minor-mode)
@@ -301,13 +303,15 @@ Uses `gud-<MINOR-MODE>-directories' to find the source files."
 optional doc string DOC.  Certain %-escapes in the string arguments
 are interpreted specially if present.  These are:
 
-  %f    name (without directory) of current source file.
-  %F    name (without directory or extension) of current source file.
-  %d    directory of current source file.
-  %l    number of current source line
-  %e    text of the C lvalue or function-call expression surrounding point.
-  %a    text of the hexadecimal address surrounding point
-  %p    prefix argument to the command (if any) as a number
+  %f -- Name (without directory) of current source file.
+  %F -- Name (without directory or extension) of current source file.
+  %d -- Directory of current source file.
+  %l -- Number of current source line.
+  %e -- Text of the C lvalue or function-call expression surrounding point.
+  %a -- Text of the hexadecimal address surrounding point.
+  %p -- Prefix argument to the command (if any) as a number.
+  %c -- Fully qualified class name derived from the expression
+        surrounding point (jdb only).
 
   The `current' source file is the file of the current buffer (if
 we're in a C file) or the source file current at the last break or
@@ -444,8 +448,7 @@ required by the caller."
         (when (or gdb-force-update
                   (not (save-excursion
                          (goto-char (point-min))
-                         (let ((case-fold-search t))
-                           (looking-at "Watch Expressions:")))))
+                         (looking-at "Watch Expressions:"))))
           (erase-buffer)
           (insert "Watch Expressions:\n")
           (if gdb-speedbar-auto-raise
@@ -740,8 +743,6 @@ To run GDB in text command mode, set `gud-gdb-command-name' to
 ;; The completion list is constructed by the process filter.
 (defvar gud-gdb-fetched-lines)
 
-(defvar gud-comint-buffer nil)
-
 (defun gud-gdb-complete-command (&optional command a b)
   "Perform completion on the GDB command preceding point.
 This is implemented using the GDB `complete' command which isn't
@@ -2804,7 +2805,9 @@ Obeying it means displaying in another window the specified file and line."
   (let ((insource (not (eq (current-buffer) gud-comint-buffer)))
         (frame (or gud-last-frame gud-last-last-frame))
         result)
-    (while (and str (string-match "\\([^%]*\\)%\\([adeflpc]\\)" str))
+    (while (and str
+                (let ((case-fold-search nil))
+                  (string-match "\\([^%]*\\)%\\([adefFlpc]\\)" str)))
       (let ((key (string-to-char (match-string 2 str)))
             subst)
         (cond
@@ -2889,8 +2892,11 @@ Obeying it means displaying in another window the specified file and line."
       (set-buffer gud-comint-buffer)
       (save-restriction
         (widen)
-        (goto-char (process-mark proc))
-        (forward-line 0)
+        (if (marker-position gud-delete-prompt-marker)
+            ;; We get here when printing an expression.
+            (goto-char gud-delete-prompt-marker)
+          (goto-char (process-mark proc))
+          (forward-line 0))
         (if (looking-at comint-prompt-regexp)
             (set-marker gud-delete-prompt-marker (point)))
         (if (memq gud-minor-mode '(gdbmi gdba))
@@ -2911,7 +2917,21 @@ Obeying it means displaying in another window the specified file and line."
 (defvar gud-find-expr-function 'gud-find-c-expr)
 
 (defun gud-find-expr (&rest args)
-  (apply gud-find-expr-function args))
+  (let ((expr (if (and transient-mark-mode mark-active)
+                  (buffer-substring (region-beginning) (region-end))
+                (apply gud-find-expr-function args))))
+    (save-match-data
+      (if (string-match "\n" expr)
+          (error "Expression must not include a newline"))
+      (with-current-buffer gud-comint-buffer
+        (save-excursion
+          (goto-char (process-mark (get-buffer-process gud-comint-buffer)))
+          (forward-line 0)
+          (when (looking-at comint-prompt-regexp)
+            (set-marker gud-delete-prompt-marker (point))
+            (set-marker-insertion-type gud-delete-prompt-marker t))
+          (insert (concat  expr " = ")))))
+    expr))
 
 ;; The next eight functions are hacked from gdbsrc.el by
 ;; Debby Ayers <ayers@asc.slb.com>,
diff --git a/lisp/progmodes/python.el b/lisp/progmodes/python.el
index 5e645535a23..9636f7eaeae 100644
--- a/lisp/progmodes/python.el
+++ b/lisp/progmodes/python.el
@@ -292,9 +292,9 @@ The criteria are that the previous line ends in a backslash outside
 comments and strings, or that the bracket/paren nesting depth is nonzero."
   (or (and (eq ?\\ (char-before (line-end-position 0)))
            (not (syntax-ppss-context (syntax-ppss))))
-      (/= 0 (syntax-ppss-depth
-             (save-excursion      ; syntax-ppss with arg changes point
-               (syntax-ppss (line-beginning-position)))))))
+      (< 0 (syntax-ppss-depth
+            (save-excursion       ; syntax-ppss with arg changes point
+              (syntax-ppss (line-beginning-position)))))))
 
 (defun python-comment-line-p ()
   "Return non-nil iff current line has only a comment."
@@ -719,7 +719,10 @@ expressions."
         (python-beginning-of-string)
         ;; Skip forward out of nested brackets.
         (condition-case ()              ; beware invalid syntax
-            (progn (backward-up-list (syntax-ppss-depth (syntax-ppss))) t)
+            (let ((depth (syntax-ppss-depth (syntax-ppss))))
+              ;; Beware negative depths.
+              (if (> depth 0) (backward-up-list depth))
+              t)
           (error (throw 'foo nil))))))
   (back-to-indentation))
 
@@ -1755,7 +1758,6 @@ lines count as headers.
   (if (featurep 'hippie-exp)
       (set (make-local-variable 'hippie-expand-try-functions-list)
            (cons 'python-try-complete hippie-expand-try-functions-list)))
-  (unless font-lock-mode (font-lock-mode 1))
   (when python-guess-indent (python-guess-indent))
   (set (make-local-variable 'python-command) python-python-command)
   (unless (boundp 'python-mode-running) ; kill the recursion from jython-mode