Merge from emacs--devo--0

Patches applied:

 * emacs--devo--0  (patch 806-813)

   - Merge from emacs--rel--22
   - Update from CVS

 * emacs--rel--22  (patch 51-58)

   - Update from CVS
   - Merge from gnus--rel--5.10

 * gnus--rel--5.10  (patch 233-236)

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

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

5 files changed, 119 insertions, 77 deletions

diff --git a/lisp/progmodes/compile.el b/lisp/progmodes/compile.el
index a9f5f77c126..94def936fb9 100644
--- a/lisp/progmodes/compile.el
+++ b/lisp/progmodes/compile.el
@@ -87,13 +87,13 @@
 
 ;;;###autoload
 (defcustom compilation-mode-hook nil
-  "*List of hook functions run by `compilation-mode' (see `run-mode-hooks')."
+  "List of hook functions run by `compilation-mode' (see `run-mode-hooks')."
   :type 'hook
   :group 'compilation)
 
 ;;;###autoload
 (defcustom compilation-window-height nil
-  "*Number of lines in a compilation window.  If nil, use Emacs default."
+  "Number of lines in a compilation window.  If nil, use Emacs default."
   :type '(choice (const :tag "Default" nil)
                  integer)
   :group 'compilation)
@@ -442,7 +442,7 @@ Highlight entire line if t; don't highlight source lines if nil.")
   "Overlay used to temporarily highlight compilation matches.")
 
 (defcustom compilation-error-screen-columns t
-  "*If non-nil, column numbers in error messages are screen columns.
+  "If non-nil, column numbers in error messages are screen columns.
 Otherwise they are interpreted as character positions, with
 each character occupying one column.
 The default is to use screen columns, which requires that the compilation
@@ -453,21 +453,21 @@ especially the TAB character."
   :version "20.4")
 
 (defcustom compilation-read-command t
-  "*Non-nil means \\[compile] reads the compilation command to use.
+  "Non-nil means \\[compile] reads the compilation command to use.
 Otherwise, \\[compile] just uses the value of `compile-command'."
   :type 'boolean
   :group 'compilation)
 
 ;;;###autoload
 (defcustom compilation-ask-about-save t
-  "*Non-nil means \\[compile] asks which buffers to save before compiling.
+  "Non-nil means \\[compile] asks which buffers to save before compiling.
 Otherwise, it saves all modified buffers without asking."
   :type 'boolean
   :group 'compilation)
 
 ;;;###autoload
 (defcustom compilation-search-path '(nil)
-  "*List of directories to search for source files named in error messages.
+  "List of directories to search for source files named in error messages.
 Elements should be directory names, not file names of directories.
 The value nil as an element means to try the default directory."
   :type '(repeat (choice (const :tag "Default" nil)
@@ -476,7 +476,7 @@ The value nil as an element means to try the default directory."
 
 ;;;###autoload
 (defcustom compile-command "make -k "
-  "*Last shell command used to do a compilation; default for next compilation.
+  "Last shell command used to do a compilation; default for next compilation.
 
 Sometimes it is useful for files to supply local values for this variable.
 You might also use mode hooks to specify it in certain modes, like this:
@@ -494,7 +494,7 @@ You might also use mode hooks to specify it in certain modes, like this:
 
 ;;;###autoload
 (defcustom compilation-disable-input nil
-  "*If non-nil, send end-of-file as compilation process input.
+  "If non-nil, send end-of-file as compilation process input.
 This only affects platforms that support asynchronous processes (see
 `start-process'); synchronous compilation processes never accept input."
   :type 'boolean
@@ -605,6 +605,14 @@ Faces `compilation-error-face', `compilation-warning-face',
 (defvar compilation-error-list nil)
 (defvar compilation-old-error-list nil)
 
+(defcustom compilation-auto-jump-to-first-error nil
+  "If non-nil, automatically jump to the first error after `compile'."
+  :type 'boolean)
+
+(defvar compilation-auto-jump-to-next nil
+  "If non-nil, automatically jump to the next error encountered.")
+(make-variable-buffer-local 'compilation-auto-jump-to-next)
+
 (defun compilation-face (type)
   (or (and (car type) (match-end (car type)) compilation-warning-face)
       (and (cdr type) (match-end (cdr type)) compilation-info-face)
@@ -652,13 +660,18 @@ Faces `compilation-error-face', `compilation-warning-face',
               l2
             (setcdr l1 (cons (list ,key) l2)))))))
 
+(defun compilation-auto-jump (buffer pos)
+  (with-current-buffer buffer
+    (goto-char pos)
+    (compile-goto-error)))
 
 ;; This function is the central driver, called when font-locking to gather
 ;; all information needed to later jump to corresponding source code.
 ;; Return a property list with all meta information on this error location.
 
 (defun compilation-error-properties (file line end-line col end-col type fmt)
-  (unless (< (next-single-property-change (match-beginning 0) 'directory nil (point))
+  (unless (< (next-single-property-change (match-beginning 0)
+                                          'directory nil (point))
              (point))
     (if file
         (if (functionp file)
@@ -710,6 +723,13 @@ Faces `compilation-error-face', `compilation-warning-face',
         (setq type (or (and (car type) (match-end (car type)) 1)
                        (and (cdr type) (match-end (cdr type)) 0)
                        2)))
+
+    (when (and compilation-auto-jump-to-next
+               (>= type compilation-skip-threshold))
+      (kill-local-variable 'compilation-auto-jump-to-next)
+      (run-with-timer 0 nil 'compilation-auto-jump
+                      (current-buffer) (match-beginning 0)))
+
     (compilation-internal-error-properties file line end-line col end-col type fmt)))
 
 (defun compilation-move-to-column (col screen)
@@ -932,7 +952,7 @@ original use.  Otherwise, recompile using `compile-command'."
                                   `(,(eval compile-command))))))
 
 (defcustom compilation-scroll-output nil
-  "*Non-nil to scroll the *compilation* buffer window as output appears.
+  "Non-nil to scroll the *compilation* buffer window as output appears.
 
 Setting it causes the Compilation mode commands to put point at the
 end of their output window so that the end of the output is always
@@ -1026,8 +1046,9 @@ Returns the compilation buffer created."
       ;; Clear out the compilation buffer.
       (let ((inhibit-read-only t)
             (default-directory thisdir))
-        ;; Then evaluate a cd command if any, but don't perform it yet, else start-command
-        ;; would do it again through the shell: (cd "..") AND sh -c "cd ..; make"
+        ;; Then evaluate a cd command if any, but don't perform it yet, else
+        ;; start-command would do it again through the shell: (cd "..") AND
+        ;; sh -c "cd ..; make"
         (cd (if (string-match "^\\s *cd\\(?:\\s +\\(\\S +?\\)\\)?\\s *[;&\n]" command)
                 (if (match-end 1)
                     (substitute-env-vars (match-string 1 command))
@@ -1043,6 +1064,8 @@ Returns the compilation buffer created."
         (if highlight-regexp
             (set (make-local-variable 'compilation-highlight-regexp)
                  highlight-regexp))
+        (if compilation-auto-jump-to-first-error
+            (set (make-local-variable 'compilation-auto-jump-to-next) t))
         ;; Output a mode setter, for saving and later reloading this buffer.
         (insert "-*- mode: " name-of-mode
                 "; default-directory: " (prin1-to-string default-directory)
@@ -1075,7 +1098,8 @@ Returns the compilation buffer created."
               (unless (getenv "EMACS")
                 (list "EMACS=t"))
               (list "INSIDE_EMACS=t")
-              (copy-sequence process-environment))))
+              (copy-sequence process-environment)))
+            (start-process (symbol-function 'start-process)))
         (set (make-local-variable 'compilation-arguments)
              (list command mode name-function highlight-regexp))
         (set (make-local-variable 'revert-buffer-function)
@@ -1091,53 +1115,39 @@ Returns the compilation buffer created."
             (funcall compilation-process-setup-function))
         (compilation-set-window-height outwin)
         ;; Start the compilation.
-        (if (fboundp 'start-process)
-            (let ((proc (if (eq mode t)
-                            (get-buffer-process
-                             (with-no-warnings
-                              (comint-exec outbuf (downcase mode-name)
-                                           shell-file-name nil `("-c" ,command))))
-                          (start-process-shell-command (downcase mode-name)
-                                                       outbuf command))))
-              ;; Make the buffer's mode line show process state.
-              (setq mode-line-process '(":%s"))
-              (set-process-sentinel proc 'compilation-sentinel)
-              (set-process-filter proc 'compilation-filter)
-              (set-marker (process-mark proc) (point) outbuf)
-              (when compilation-disable-input
-                (condition-case nil
-                    (process-send-eof proc)
-                  ;; The process may have exited already.
-                  (error nil)))
-              (setq compilation-in-progress
-                    (cons proc compilation-in-progress)))
-          ;; No asynchronous processes available.
-          (message "Executing `%s'..." command)
-          ;; Fake modeline display as if `start-process' were run.
-          (setq mode-line-process ":run")
-          (force-mode-line-update)
-          (sit-for 0)                   ; Force redisplay
-          (let* ((buffer-read-only nil) ; call-process needs to modify outbuf
-                 (status (call-process shell-file-name nil outbuf nil "-c"
-                                       command)))
-            (cond ((numberp status)
-                   (compilation-handle-exit 'exit status
-                                            (if (zerop status)
-                                                "finished\n"
-                                              (format "\
-exited abnormally with code %d\n"
-                                                      status))))
-                  ((stringp status)
-                   (compilation-handle-exit 'signal status
-                                            (concat status "\n")))
-                  (t
-                   (compilation-handle-exit 'bizarre status status))))
-          ;; Without async subprocesses, the buffer is not yet
-          ;; fontified, so fontify it now.
-          (let ((font-lock-verbose nil)) ; shut up font-lock messages
-            (font-lock-fontify-buffer))
-          (set-buffer-modified-p nil)
-          (message "Executing `%s'...done" command)))
+        (let ((proc
+               (if (eq mode t)
+                   ;; comint uses `start-file-process'.
+                   (get-buffer-process
+                    (with-no-warnings
+                      (comint-exec outbuf (downcase mode-name)
+                                   shell-file-name nil `("-c" ,command))))
+                 ;; Redefine temporarily `start-process' in order to
+                 ;; handle remote compilation.
+                 (fset 'start-process
+                       (lambda (name buffer program &rest program-args)
+                         (apply
+                          (if (file-remote-p default-directory)
+                              'start-file-process
+                            start-process)
+                          name buffer program program-args)))
+                 (unwind-protect
+                     (start-process-shell-command (downcase mode-name)
+                                                  outbuf command)
+                   ;; Unwindform: Reset original definition of `start-process'.
+                   (fset 'start-process start-process)))))
+          ;; Make the buffer's mode line show process state.
+          (setq mode-line-process '(":%s"))
+          (set-process-sentinel proc 'compilation-sentinel)
+          (set-process-filter proc 'compilation-filter)
+          (set-marker (process-mark proc) (point) outbuf)
+          (when compilation-disable-input
+            (condition-case nil
+                (process-send-eof proc)
+              ;; The process may have exited already.
+              (error nil)))
+          (setq compilation-in-progress
+                (cons proc compilation-in-progress))))
       ;; Now finally cd to where the shell started make/grep/...
       (setq default-directory thisdir))
     (if (buffer-local-value 'compilation-scroll-output outbuf)
@@ -1258,7 +1268,7 @@ exited abnormally with code %d\n"
   "*If non-nil, skip multiple error messages for the same source location.")
 
 (defcustom compilation-skip-threshold 1
-  "*Compilation motion commands skip less important messages.
+  "Compilation motion commands skip less important messages.
 The value can be either 2 -- skip anything less than error, 1 --
 skip anything less than warning or 0 -- don't skip any messages.
 Note that all messages not positively identified as warning or
@@ -1270,7 +1280,7 @@ info, are considered errors."
   :version "22.1")
 
 (defcustom compilation-skip-visited nil
-  "*Compilation motion commands skip visited messages if this is t.
+  "Compilation motion commands skip visited messages if this is t.
 Visited messages are ones for which the file, line and column have been jumped
 to from the current content in the current compilation buffer, even if it was
 from a different message."
@@ -1371,6 +1381,8 @@ Optional argument MINOR indicates this is called from
   ;; with the next-error function in simple.el, and it's only
   ;; coincidentally named similarly to compilation-next-error.
   (setq next-error-function 'compilation-next-error-function)
+  (set (make-local-variable 'comint-file-name-prefix)
+       (or (file-remote-p default-directory) ""))
   (set (make-local-variable 'font-lock-extra-managed-props)
        '(directory message help-echo mouse-face debug))
   (set (make-local-variable 'compilation-locs)
diff --git a/lisp/progmodes/gdb-ui.el b/lisp/progmodes/gdb-ui.el
index 4dbc9893f61..7bc904f8319 100644
--- a/lisp/progmodes/gdb-ui.el
+++ b/lisp/progmodes/gdb-ui.el
@@ -1765,7 +1765,7 @@ static char *magick[] = {
 
 (defface breakpoint-enabled
   '((t
-     :foreground "red"
+     :foreground "red1"
      :weight bold))
   "Face for enabled breakpoint icon in fringe."
   :group 'gud)
diff --git a/lisp/progmodes/gud.el b/lisp/progmodes/gud.el
index aa382d4e185..97144fec83b 100644
--- a/lisp/progmodes/gud.el
+++ b/lisp/progmodes/gud.el
@@ -237,7 +237,7 @@ Used to grey out relevant toolbar icons.")
        ([menu-bar run] menu-item
         ,(propertize "run" 'face 'font-lock-doc-face) gud-run
         :visible (memq gud-minor-mode '(gdbmi gdb dbx jdb)))
-       ([menu-bar go] menu-item 
+       ([menu-bar go] menu-item
         ,(propertize " go " 'face 'font-lock-doc-face) gud-go
         :visible (and (not gud-running)
                       (eq gud-minor-mode 'gdba)))
@@ -292,6 +292,11 @@ Used to grey out relevant toolbar icons.")
 (defun gud-file-name (f)
   "Transform a relative file name to an absolute file name.
 Uses `gud-<MINOR-MODE>-directories' to find the source files."
+  ;; When `default-directory' is a remote file name, prepend its
+  ;; remote part to f, which is the local file name.  Fortunately,
+  ;; `file-remote-p' returns exactly this remote file name part (or
+  ;; nil otherwise).
+  (setq f (concat (or (file-remote-p default-directory) "") f))
   (if (file-exists-p f) (expand-file-name f)
     (let ((directories (gud-val 'directories))
           (result nil))
@@ -2510,7 +2515,10 @@ comint mode, which see."
       (while (and w (not (eq (car w) t)))
         (setq w (cdr w)))
       (if w
-          (setcar w file)))
+          (setcar w
+                  (if (file-remote-p default-directory)
+                      (setq file (file-name-nondirectory file))
+                    file))))
     (apply 'make-comint (concat "gud" filepart) program nil
            (if massage-args (funcall massage-args file args) args))
     ;; Since comint clobbered the mode, we don't set it until now.
@@ -3114,7 +3122,7 @@ class of the file (using s to separate nested class ids)."
                              'syntax-table (eval-when-compile
                                              (string-to-syntax "> b")))
           ;; Make sure that rehighlighting the previous line won't erase our
-          ;; syntax-table property.  
+          ;; syntax-table property.
           (put-text-property (1- (match-beginning 0)) (match-end 0)
                              'font-lock-multiline t)
           nil)))))
@@ -3193,8 +3201,12 @@ Treats actions as defuns."
     (goto-char (point-max)))
   t)
 
+;; Besides .gdbinit, gdb documents other names to be usable for init
+;; files, cross-debuggers can use something like
+;; .PROCESSORNAME-gdbinit so that the host and target gdbinit files
+;; don't interfere with each other.
 ;;;###autoload
-(add-to-list 'auto-mode-alist '("/\\.gdbinit" . gdb-script-mode))
+(add-to-list 'auto-mode-alist '("/\\.[a-z0-9-]*gdbinit" . gdb-script-mode))
 
 ;;;###autoload
 (define-derived-mode gdb-script-mode nil "GDB-Script"
diff --git a/lisp/progmodes/python.el b/lisp/progmodes/python.el
index 5c117dffd5d..26fc122631d 100644
--- a/lisp/progmodes/python.el
+++ b/lisp/progmodes/python.el
@@ -996,7 +996,16 @@ don't move and return nil.  Otherwise return t."
                           (throw 'done t)))))))
       (setq arg (1- arg)))
     (zerop arg)))
-
+
+(defvar python-which-func-length-limit 40
+  "Non-strict length limit for `python-which-func' output.")
+
+(defun python-which-func ()
+  (let ((function-name (python-current-defun python-which-func-length-limit)))
+    (set-text-properties 0 (length function-name) nil function-name)
+    function-name))
+
+ 
 ;;;; Imenu.
 
 (defvar python-recursing)
@@ -1814,22 +1823,30 @@ of current line."
   (1+ (/ (current-indentation) python-indent)))
 
 ;; Fixme: Consider top-level assignments, imports, &c.
-(defun python-current-defun ()
+(defun python-current-defun (&optional length-limit)
   "`add-log-current-defun-function' for Python."
   (save-excursion
     ;; Move up the tree of nested `class' and `def' blocks until we
     ;; get to zero indentation, accumulating the defined names.
     (let ((start t)
-          accum)
-      (while (or start (> (current-indentation) 0))
+          (accum)
+          (length -1))
+      (while (and (or start (> (current-indentation) 0))
+                  (or (null length-limit)
+                      (null (cdr accum))
+                      (< length length-limit)))
         (setq start nil)
         (python-beginning-of-block)
         (end-of-line)
         (beginning-of-defun)
-        (if (looking-at (rx (0+ space) (or "def" "class") (1+ space)
-                            (group (1+ (or word (syntax symbol))))))
-            (push (match-string 1) accum)))
-      (if accum (mapconcat 'identity accum ".")))))
+        (when (looking-at (rx (0+ space) (or "def" "class") (1+ space)
+                              (group (1+ (or word (syntax symbol))))))
+          (push (match-string 1) accum)
+          (setq length (+ length 1 (length (car accum))))))
+      (when accum
+        (when (and length-limit (> length length-limit))
+          (setcar accum ".."))
+        (mapconcat 'identity accum ".")))))
 
 (defun python-mark-block ()
   "Mark the block around point.
@@ -2248,6 +2265,7 @@ with skeleton expansions for compound statement templates.
   (set (make-local-variable 'beginning-of-defun-function)
        'python-beginning-of-defun)
   (set (make-local-variable 'end-of-defun-function) 'python-end-of-defun)
+  (add-hook 'which-func-functions 'python-which-func nil t)
   (setq imenu-create-index-function #'python-imenu-create-index)
   (set (make-local-variable 'eldoc-documentation-function)
        #'python-eldoc-function)
diff --git a/lisp/progmodes/which-func.el b/lisp/progmodes/which-func.el
index 43c70f67dfb..5b5c13342ad 100644
--- a/lisp/progmodes/which-func.el
+++ b/lisp/progmodes/which-func.el
@@ -76,8 +76,8 @@
   :version "20.3")
 
 (defcustom which-func-modes
-  '(emacs-lisp-mode c-mode c++-mode perl-mode cperl-mode makefile-mode
-                    sh-mode fortran-mode f90-mode ada-mode)
+  '(emacs-lisp-mode c-mode c++-mode perl-mode cperl-mode python-mode
+                    makefile-mode sh-mode fortran-mode f90-mode ada-mode)
   "List of major modes for which Which Function mode should be used.
 For other modes it is disabled.  If this is equal to t,
 then Which Function mode is enabled in any major mode that supports it."