Merge from mainline.

24 files changed, 1098 insertions, 482 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index a526ca900a7..62dd255cabe 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,8 +1,122 @@
-2011-04-07  Paul Eggert  <eggert@cs.ucla.edu>
+2011-04-09  Paul Eggert  <eggert@cs.ucla.edu>
 
         Remove the doprnt implementation, as Emacs now uses vsnprintf.
         * emacs-lisp/find-gc.el (find-gc-source-files): Remove doprnt.c.
 
+2011-04-08  Sho Nakatani <lay.sakura@gmail.com>
+
+        * doc-view.el (doc-view-fit-width-to-window)
+        (doc-view-fit-height-to-window, doc-view-fit-page-to-window): New
+        functions for fitting the shown image to the Emacs window size.
+        (doc-view-mode-map): Add bindings for the new functions.
+
+2011-03-24  Juanma Barranquero  <lekktu@gmail.com>
+
+        * vc-annotate.el (vc-annotate-show-log-revision-at-line):
+        Fix typo in docstring.
+
+2011-04-08  Eli Zaretskii  <eliz@gnu.org>
+
+        * files.el (file-size-human-readable): Produce one digit after
+        decimal, like "ls -lh" does.
+
+        * ls-lisp.el (ls-lisp-format-file-size): Allow for 7 characters in
+        the file size representation.
+
+        * simple.el (list-processes): If async subprocesses are not
+        available, error out with a clear error message.
+
+2011-04-08  Chong Yidong  <cyd@stupidchicken.com>
+
+        * help.el (help-form-show): New function, to be called from C.
+        Put help-form output in a buffer named differently than *Help*.
+
+2011-04-08  Eli Zaretskii  <eliz@gnu.org>
+
+        * files.el (file-size-human-readable): New function.
+
+        * ls-lisp.el (ls-lisp-format-file-size): Use it, instead of
+        computing the representation inline.  Don't require `cl'.
+
+2011-04-08  Glenn Morris  <rgm@gnu.org>
+
+        * man.el (Man-page-header-regexp): Solaris < 2.6 no longer supported.
+
+        * net/browse-url.el (browse-url-firefox):
+        Test system-type, not system-configuration.
+
+        * vc/log-edit.el (log-edit-empty-buffer-p): New function.
+        (log-edit-insert-cvs-template, log-edit-insert-cvs-rcstemplate):
+        Use log-edit-empty-buffer-p.  (Bug#7598)
+
+        * net/rlogin.el (rlogin-process-connection-type): Simplify.
+        (rlogin-mode-map): Initialize in the defvar.
+        (rlogin): Use ignore-errors.
+
+        * replace.el (occur-mode-map): Some fixes for menu items.
+
+2011-04-07  Aaron S. Hawley  <aaron.s.hawley@gmail.com>
+
+        * play/morse.el (denato-region): Handle varying case.  (Bug#8386)
+
+2011-04-06  Chong Yidong  <cyd@stupidchicken.com>
+
+        * emacs-lisp/cconv.el (cconv--analyse-use): Ignore "ignored" when
+        issuing unused warnings.
+
+        * emacs-lisp/tabulated-list.el (tabulated-list-print): Use lambda
+        macro directly.
+
+        * simple.el: Lisp reimplement of list-processes.  Based on an
+        earlier reimplementation by Leo Liu, but using tabulated-list.el.
+        (process-menu-mode): New major mode.
+        (list-processes--refresh, list-processes):
+        (process-menu-visit-buffer): New functions.
+
+        * files.el (save-buffers-kill-emacs): Don't assume any return
+        value of list-processes, which is undocumented anyway.
+
+2011-04-06  Chong Yidong  <cyd@stupidchicken.com>
+
+        * emacs-lisp/tabulated-list.el: New file.
+
+        * emacs-lisp/package.el: Use Tabulated List mode.
+        (package-menu-mode-map): Inherit from tabulated-list-mode-map.
+        (package-menu-mode): Derive from tabulated-list-mode.  Set up the
+        table format using Tabulated List mode variables.
+        (package--push): New macro, replacing package-list-maybe-add.
+        (package-menu--generate): Use package--push.  Renamed from
+        package--generate-package-list.
+        (package-menu-refresh, list-packages): Use it.
+        (package-menu--print-info): Renamed from package-print-package.
+        Return insertion data instead of inserting it directly.
+        (package-menu-describe-package, package-menu-execute): Use
+        tabulated-list-get-id.
+        (package-menu-mark-delete, package-menu-mark-install)
+        (package-menu-mark-unmark, package-menu-backup-unmark)
+        (package-menu-mark-obsolete-for-deletion): Use
+        tabulated-list-put-tag.
+        (package--list-packages, package-menu-revert)
+        (package-menu-get-package, package-menu-get-version)
+        (package-menu-sort-by-column): Functions deleted.
+        (package-menu-package-list, package-menu-sort-key): Vars deleted.
+        (package-menu--status-predicate, package-menu--version-predicate)
+        (package-menu--name-predicate)
+        (package-menu--description-predicate): Handle arguments in the
+        Tabulated List format.
+        (package-list-packages-no-fetch): Call list-packages.
+
+2011-04-06  Juanma Barranquero  <lekktu@gmail.com>
+
+        * files.el (after-find-file-from-revert-buffer): Remove variable.
+        (after-find-file): Dont' bind it.
+        (revert-buffer-in-progress-p): New variable.
+        (revert-buffer): Bind it.
+        Pass nil for `after-find-file-from-revert-buffer'.
+
+        * saveplace.el (save-place-find-file-hook): Use new variable
+        `rever-buffer-in-progress-p', not `after-find-file-from-revert-buffer'.
+
 2011-04-06  Glenn Morris  <rgm@gnu.org>
 
         * Makefile.in (AUTOGEN_VCS): New variable.
@@ -575,7 +689,7 @@
         (emerge-protect-metachars): Quote correctly for ms-dos and
         windows-nt systems.
 
-2011-03-19  Ralph Schleicher  <rs@ralph-schleicher.de>
+2011-03-19  Ralph Schleicher  <rs@ralph-schleicher.de>  (tiny change)
 
         * info.el (info-initialize): Replace all uses of `:' with
         path-separator for compatibility with non-Unix systems.
diff --git a/lisp/bs.el b/lisp/bs.el
index 72b3e4c6fef..6965af1368c 100644
--- a/lisp/bs.el
+++ b/lisp/bs.el
@@ -40,7 +40,7 @@
 ;; |  % vc-hooks.el     43605  Emacs-Lisp    /usr/share/emacs/19.34/lisp$|
 ;; -----------------------------------------------------------------------
 
-;;; Quick Installation und Customization:
+;;; Quick Installation and Customization:
 
 ;; To display the bs menu, do
 ;;   M-x bs-show
@@ -1083,7 +1083,7 @@ configuration."
                   bs-dont-show-regexp     (nth 3 list)
                   bs-dont-show-function   (nth 4 list)
                   bs-buffer-sort-function (nth 5 list))
-          ;; for backward compability
+          ;; for backward compatibility
           (funcall (cdr list)))
       ;; else
       (ding)
diff --git a/lisp/cus-face.el b/lisp/cus-face.el
index 0a48c0fbd68..f813b5b84d1 100644
--- a/lisp/cus-face.el
+++ b/lisp/cus-face.el
@@ -348,7 +348,7 @@ FACE's list property `theme-face' \(using `custom-push-theme')."
               (put face 'face-override-spec nil)
               (face-spec-set face spec t))))))))
 
-;; XEmacs compability function.  In XEmacs, when you reset a Custom
+;; XEmacs compatibility function.  In XEmacs, when you reset a Custom
 ;; Theme, you have to specify the theme to reset it to.  We just apply
 ;; the next theme.
 (defun custom-theme-reset-faces (theme &rest args)
diff --git a/lisp/doc-view.el b/lisp/doc-view.el
index 7bead624cc7..ab0d6bf837b 100644
--- a/lisp/doc-view.el
+++ b/lisp/doc-view.el
@@ -328,6 +328,10 @@ Can be `dvi', `pdf', or `ps'.")
     ;; Zoom in/out.
     (define-key map "+"               'doc-view-enlarge)
     (define-key map "-"               'doc-view-shrink)
+    ;; Fit the image to the window
+    (define-key map "W"               'doc-view-fit-width-to-window)
+    (define-key map "H"               'doc-view-fit-height-to-window)
+    (define-key map "P"               'doc-view-fit-page-to-window)
     ;; Killing the buffer (and the process)
     (define-key map (kbd "k")         'doc-view-kill-proc-and-buffer)
     (define-key map (kbd "K")         'doc-view-kill-proc)
@@ -664,6 +668,78 @@ OpenDocument format)."
   (interactive (list doc-view-shrink-factor))
   (doc-view-enlarge (/ 1.0 factor)))
 
+(defun doc-view-fit-width-to-window ()
+  "Fit the image width to the window width."
+  (interactive)
+  (let ((win-width (- (nth 2 (window-inside-pixel-edges))
+                      (nth 0 (window-inside-pixel-edges))))
+        (slice (doc-view-current-slice)))
+    (if (not slice)
+        (let ((img-width (car (image-display-size
+                               (image-get-display-property) t))))
+          (doc-view-enlarge (/ (float win-width) (float img-width))))
+
+      ;; If slice is set
+      (let* ((slice-width (nth 2 slice))
+             (scale-factor (/ (float win-width) (float slice-width)))
+             (new-slice (mapcar (lambda (x) (ceiling (* scale-factor x))) slice)))
+
+        (doc-view-enlarge scale-factor)
+        (setf (doc-view-current-slice) new-slice)
+        (doc-view-goto-page (doc-view-current-page))))))
+
+(defun doc-view-fit-height-to-window ()
+  "Fit the image height to the window height."
+  (interactive)
+  (let ((win-height (- (nth 3 (window-inside-pixel-edges))
+                       (nth 1 (window-inside-pixel-edges))))
+        (slice (doc-view-current-slice)))
+    (if (not slice)
+        (let ((img-height (cdr (image-display-size
+                                (image-get-display-property) t))))
+          ;; When users call 'doc-view-fit-height-to-window',
+          ;; they might want to go to next page by typing SPC
+          ;; ONLY once. So I used '(- win-height 1)' instead of
+          ;; 'win-height'
+          (doc-view-enlarge (/ (float (- win-height 1)) (float img-height))))
+
+      ;; If slice is set
+      (let* ((slice-height (nth 3 slice))
+             (scale-factor (/ (float (- win-height 1)) (float slice-height)))
+             (new-slice (mapcar (lambda (x) (ceiling (* scale-factor x))) slice)))
+
+        (doc-view-enlarge scale-factor)
+        (setf (doc-view-current-slice) new-slice)
+        (doc-view-goto-page (doc-view-current-page))))))
+
+(defun doc-view-fit-page-to-window ()
+  "Fit the image to the window.
+More specifically, this function enlarges image by:
+
+min {(window-width / image-width), (window-height / image-height)} times."
+  (interactive)
+  (let ((win-width (- (nth 2 (window-inside-pixel-edges))
+                      (nth 0 (window-inside-pixel-edges))))
+        (win-height (- (nth 3 (window-inside-pixel-edges))
+                       (nth 1 (window-inside-pixel-edges))))
+        (slice (doc-view-current-slice)))
+    (if (not slice)
+        (let ((img-width (car (image-display-size
+                               (image-get-display-property) t)))
+              (img-height (cdr (image-display-size
+                                (image-get-display-property) t))))
+          (doc-view-enlarge (min (/ (float win-width) (float img-width))
+                                 (/ (float (- win-height 1)) (float img-height)))))
+      ;; If slice is set
+      (let* ((slice-width (nth 2 slice))
+             (slice-height (nth 3 slice))
+             (scale-factor (min (/ (float win-width) (float slice-width))
+                                (/ (float (- win-height 1)) (float slice-height))))
+             (new-slice (mapcar (lambda (x) (ceiling (* scale-factor x))) slice)))
+        (doc-view-enlarge scale-factor)
+        (setf (doc-view-current-slice) new-slice)
+        (doc-view-goto-page (doc-view-current-page))))))
+
 (defun doc-view-reconvert-doc ()
   "Reconvert the current document.
 Should be invoked when the cached images aren't up-to-date."
diff --git a/lisp/emacs-lisp/cconv.el b/lisp/emacs-lisp/cconv.el
index 5cc9ecb4cf7..38584c437b8 100644
--- a/lisp/emacs-lisp/cconv.el
+++ b/lisp/emacs-lisp/cconv.el
@@ -536,7 +536,9 @@ FORM is the parent form that binds this var."
               ;; it is often non-trivial for the programmer to avoid such
               ;; unused vars.
               (not (intern-soft var))
-              (eq ?_ (aref (symbol-name var) 0)))
+              (eq ?_ (aref (symbol-name var) 0))
+              ;; As a special exception, ignore "ignore".
+              (eq var 'ignored))
        (byte-compile-log-warning (format "Unused lexical %s `%S'"
                                          varkind var))))
     ;; If it's unused, there's no point converting it into a cons-cell, even if
diff --git a/lisp/emacs-lisp/package.el b/lisp/emacs-lisp/package.el
index 6aecc3615f3..4ce71b29d70 100644
--- a/lisp/emacs-lisp/package.el
+++ b/lisp/emacs-lisp/package.el
@@ -173,6 +173,8 @@
 
 ;;; Code:
 
+(require 'tabulated-list)
+
 (defgroup package nil
   "Manager for Emacs Lisp packages."
   :group 'applications
@@ -1249,12 +1251,10 @@ If optional arg NO-ACTIVATE is non-nil, don't activate packages."
 ;;;; Package menu mode.
 
 (defvar package-menu-mode-map
-  (let ((map (copy-keymap special-mode-map))
+  (let ((map (make-sparse-keymap))
         (menu-map (make-sparse-keymap "Package")))
-    (set-keymap-parent map button-buffer-map)
+    (set-keymap-parent map tabulated-list-mode-map)
     (define-key map "\C-m" 'package-menu-describe-package)
-    (define-key map "n" 'next-line)
-    (define-key map "p" 'previous-line)
     (define-key map "u" 'package-menu-mark-unmark)
     (define-key map "\177" 'package-menu-backup-unmark)
     (define-key map "d" 'package-menu-mark-delete)
@@ -1264,8 +1264,6 @@ If optional arg NO-ACTIVATE is non-nil, don't activate packages."
     (define-key map "x" 'package-menu-execute)
     (define-key map "h" 'package-menu-quick-help)
     (define-key map "?" 'package-menu-describe-package)
-    (define-key map [follow-link] 'mouse-face)
-    (define-key map [mouse-2] 'mouse-select-window)
     (define-key map [menu-bar package-menu] (cons "Package" menu-map))
     (define-key menu-map [mq]
       '(menu-item "Quit" quit-window
@@ -1314,49 +1312,93 @@ If optional arg NO-ACTIVATE is non-nil, don't activate packages."
     map)
   "Local keymap for `package-menu-mode' buffers.")
 
-(defvar package-menu-sort-button-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map [header-line mouse-1] 'package-menu-sort-by-column)
-    (define-key map [header-line mouse-2] 'package-menu-sort-by-column)
-    (define-key map [follow-link] 'mouse-face)
-    map)
-  "Local keymap for package menu sort buttons.")
-
-(put 'package-menu-mode 'mode-class 'special)
-
-(define-derived-mode package-menu-mode special-mode "Package Menu"
+(define-derived-mode package-menu-mode tabulated-list-mode "Package Menu"
   "Major mode for browsing a list of packages.
 Letters do not insert themselves; instead, they are commands.
 \\<package-menu-mode-map>
 \\{package-menu-mode-map}"
-  (setq truncate-lines t)
-  (setq buffer-read-only t)
-  (set (make-local-variable 'revert-buffer-function) 'package-menu-revert)
-  (setq header-line-format
-        (mapconcat
-         (lambda (pair)
-           (let ((column (car pair))
-                 (name (cdr pair)))
-             (concat
-              ;; Insert a space that aligns the button properly.
-              (propertize " " 'display (list 'space :align-to column)
-                          'face 'fixed-pitch)
-              ;; Set up the column button.
-              (propertize name
-                          'column-name name
-                          'help-echo "mouse-1: sort by column"
-                          'mouse-face 'highlight
-                          'keymap package-menu-sort-button-map))))
-         ;; We take a trick from buff-menu and have a dummy leading
-         ;; space to align the header line with the beginning of the
-         ;; text.  This doesn't really work properly on Emacs 21, but
-         ;; it is close enough.
-         '((0 . "")
-           (2 . "Package")
-           (20 . "Version")
-           (32 . "Status")
-           (43 . "Description"))
-         "")))
+  (setq tabulated-list-format [("Package" 18 package-menu--name-predicate)
+                               ("Version" 12 nil)
+                               ("Status"  10 package-menu--status-predicate)
+                               ("Description" 0 nil)])
+  (setq tabulated-list-padding 2)
+  (setq tabulated-list-sort-key (cons "Status" nil))
+  (tabulated-list-init-header))
+
+(defmacro package--push (package desc status listname)
+  "Convenience macro for `package-menu--generate'.
+If the alist stored in the symbol LISTNAME lacks an entry for a
+package PACKAGE with descriptor DESC, add one.  The alist is
+keyed with cons cells (PACKAGE . VERSION), where PACKAGE is a
+symbol and VERSION is a version list."
+  `(let* ((version (package-desc-vers ,desc))
+          (key (cons ,package version)))
+     (unless (assoc key ,listname)
+       (push (list key ,status (package-desc-doc ,desc)) ,listname))))
+
+(defun package-menu--generate (&optional remember-pos)
+  "Populate the Package Menu.
+Optional argument REMEMBER-POS, if non-nil, means to move point
+to the entry as before."
+  ;; Construct list of ((PACKAGE . VERSION) STATUS DESCRIPTION).
+  (let (info-list name builtin)
+    ;; Installed packages:
+    (dolist (elt package-alist)
+      (setq name (car elt))
+      (package--push name (cdr elt)
+                     (if (stringp (cadr (assq name package-load-list)))
+                         "held" "installed")
+                     info-list))
+
+    ;; Built-in packages:
+    (dolist (elt package--builtins)
+      (setq name (car elt))
+      (unless (eq name 'emacs) ; Hide the `emacs' package.
+        (package--push name (cdr elt) "built-in" info-list)))
+
+    ;; Available and disabled packages:
+    (dolist (elt package-archive-contents)
+      (setq name (car elt))
+      (let ((hold (assq name package-load-list)))
+        (package--push name (cdr elt)
+                       (if (and hold (null (cadr hold))) "disabled" "available")
+                       info-list)))
+
+    ;; Obsolete packages:
+    (dolist (elt package-obsolete-alist)
+      (dolist (inner-elt (cdr elt))
+        (package--push (car elt) (cdr inner-elt) "obsolete" info-list)))
+
+    ;; Print the result.
+    (setq tabulated-list-entries (mapcar 'package-menu--print-info info-list))
+    (tabulated-list-print remember-pos)))
+
+(defun package-menu--print-info (pkg)
+  "Return a package entry suitable for `tabulated-list-entries'.
+PKG has the form ((PACKAGE . VERSION) STATUS DOC).
+Return (KEY [NAME VERSION STATUS DOC]), where KEY is the
+identifier (NAME . VERSION-LIST)."
+  (let* ((package (caar pkg))
+         (version (cdr (car pkg)))
+         (status  (nth 1 pkg))
+         (doc (or (nth 2 pkg) ""))
+         (face (cond
+                ((string= status "built-in")  'font-lock-builtin-face)
+                ((string= status "available") 'default)
+                ((string= status "held")      'font-lock-constant-face)
+                ((string= status "disabled")  'font-lock-warning-face)
+                ((string= status "installed") 'font-lock-comment-face)
+                (t 'font-lock-warning-face)))) ; obsolete.
+    (list (cons package version)
+          (vector (list (symbol-name package)
+                        'face 'link
+                        'follow-link t
+                        'package-symbol package
+                        'action 'package-menu-describe-package)
+                  (propertize (package-version-join version)
+                              'font-lock-face face)
+                  (propertize status 'font-lock-face face)
+                  (propertize doc 'font-lock-face face)))))
 
 (defun package-menu-refresh ()
   "Download the Emacs Lisp package archive.
@@ -1366,59 +1408,42 @@ This fetches the contents of each archive specified in
   (unless (eq major-mode 'package-menu-mode)
     (error "The current buffer is not a Package Menu"))
   (package-refresh-contents)
-  (package--generate-package-list))
+  (package-menu--generate t))
 
-(defun package-menu-revert (&optional arg noconfirm)
-  "Update the list of packages.
-This function is the `revert-buffer-function' for Package Menu
-buffers.  The arguments are ignored."
+(defun package-menu-describe-package (&optional button)
+  "Describe the current package.
+If optional arg BUTTON is non-nil, describe its associated package."
   (interactive)
-  (unless (eq major-mode 'package-menu-mode)
-    (error "The current buffer is not a Package Menu"))
-  (package--generate-package-list))
-
-(defun package-menu-describe-package ()
-  "Describe the package in the current line."
-  (interactive)
-  (let ((name (package-menu-get-package)))
-    (if name
-        (describe-package (intern name))
-      (message "No package on this line"))))
-
-(defun package-menu-mark-internal (what)
-  (unless (eobp)
-    (let ((buffer-read-only nil))
-      (beginning-of-line)
-      (delete-char 1)
-      (insert what)
-      (forward-line))))
+  (let ((package (if button (button-get button 'package-symbol)
+                   (car (tabulated-list-get-id)))))
+    (if package
+        (describe-package package))))
 
 ;; fixme numeric argument
 (defun package-menu-mark-delete (num)
   "Mark a package for deletion and move to the next line."
   (interactive "p")
   (if (string-equal (package-menu-get-status) "installed")
-      (package-menu-mark-internal "D")
+      (tabulated-list-put-tag "D" t)
     (forward-line)))
 
 (defun package-menu-mark-install (num)
   "Mark a package for installation and move to the next line."
   (interactive "p")
   (if (string-equal (package-menu-get-status) "available")
-      (package-menu-mark-internal "I")
+      (tabulated-list-put-tag "I" t)
     (forward-line)))
 
 (defun package-menu-mark-unmark (num)
   "Clear any marks on a package and move to the next line."
   (interactive "p")
-  (package-menu-mark-internal " "))
+  (tabulated-list-put-tag " " t))
 
 (defun package-menu-backup-unmark ()
   "Back up one line and clear any marks on that package."
   (interactive)
   (forward-line -1)
-  (package-menu-mark-internal " ")
-  (forward-line -1))
+  (tabulated-list-put-tag " "))
 
 (defun package-menu-mark-obsolete-for-deletion ()
   "Mark all obsolete packages for deletion."
@@ -1428,7 +1453,7 @@ buffers.  The arguments are ignored."
     (forward-line 2)
     (while (not (eobp))
       (if (looking-at ".*\\s obsolete\\s ")
-          (package-menu-mark-internal "D")
+          (tabulated-list-put-tag "D" t)
         (forward-line 1)))))
 
 (defun package-menu-quick-help ()
@@ -1439,20 +1464,6 @@ buffers.  The arguments are ignored."
 (define-obsolete-function-alias
   'package-menu-view-commentary 'package-menu-describe-package "24.1")
 
-;; Return the name of the package on the current line.
-(defun package-menu-get-package ()
-  (save-excursion
-    (beginning-of-line)
-    (if (looking-at ". \\([^ \t]*\\)")
-        (match-string-no-properties 1))))
-
-;; Return the version of the package on the current line.
-(defun package-menu-get-version ()
-  (save-excursion
-    (beginning-of-line)
-    (if (looking-at ". [^ \t]*[ \t]*\\([0-9.]*\\)")
-        (match-string 1))))
-
 (defun package-menu-get-status ()
   (save-excursion
     (if (looking-at ". [^ \t]*[ \t]*[^ \t]*[ \t]*\\([^ \t]*\\)")
@@ -1464,19 +1475,22 @@ buffers.  The arguments are ignored."
 Packages marked for installation are downloaded and installed;
 packages marked for deletion are removed."
   (interactive)
-  (let (install-list delete-list cmd)
+  (unless (eq major-mode 'package-menu-mode)
+    (error "The current buffer is not in Package Menu mode"))
+  (let (install-list delete-list cmd id)
     (save-excursion
       (goto-char (point-min))
       (while (not (eobp))
         (setq cmd (char-after))
-        (cond
-         ((eq cmd ?\s) t)
-         ((eq cmd ?D)
-          (push (cons (package-menu-get-package)
-                      (package-menu-get-version))
-                delete-list))
-         ((eq cmd ?I)
-          (push (package-menu-get-package) install-list)))
+        (unless (eq cmd ?\s)
+          ;; This is the key (PACKAGE . VERSION-LIST).
+          (setq id (tabulated-list-get-id))
+          (cond ((eq cmd ?D)
+                 (push (cons (symbol-name (car id))
+                             (package-version-join (cdr id)))
+                       delete-list))
+                ((eq cmd ?I)
+                 (push (car id) install-list))))
         (forward-line)))
     ;; Delete packages, prompting if necessary.
     (when delete-list
@@ -1502,217 +1516,71 @@ packages marked for deletion are removed."
                (format "Install package `%s'? " (car install-list))
              (format "Install these %d packages (%s)? "
                      (length install-list)
-                     (mapconcat 'identity install-list ", "))))
-          (dolist (elt install-list)
-            (package-install (intern elt)))))
+                     (mapconcat 'symbol-name install-list ", "))))
+          (mapc 'package-install install-list)))
     ;; If we deleted anything, regenerate `package-alist'.  This is done
     ;; automatically if we installed a package.
     (and delete-list (null install-list)
          (package-initialize))
     (if (or delete-list install-list)
-        (package-menu-revert)
+        (package-menu--generate t)
       (message "No operations specified."))))
 
-(defun package-print-package (package version key desc)
-  (let ((face
-         (cond ((string= key "built-in") 'font-lock-builtin-face)
-               ((string= key "available") 'default)
-               ((string= key "held") 'font-lock-constant-face)
-               ((string= key "disabled") 'font-lock-warning-face)
-               ((string= key "installed") 'font-lock-comment-face)
-               (t ; obsolete, but also the default.
-                'font-lock-warning-face))))
-    (insert (propertize "  " 'font-lock-face face))
-    (insert-text-button (symbol-name package)
-                        'face 'link
-                        'follow-link t
-                        'package-symbol package
-                        'action (lambda (button)
-                                  (describe-package
-                                   (button-get button 'package-symbol))))
-    (indent-to 20 1)
-    (insert (propertize (package-version-join version) 'font-lock-face face))
-    (indent-to 32 1)
-    (insert (propertize key 'font-lock-face face))
-    ;; FIXME: this 'when' is bogus...
-    (when desc
-      (indent-to 43 1)
-      (let ((opoint (point)))
-        (insert (propertize desc 'font-lock-face face))
-        (upcase-region opoint (min (point) (1+ opoint)))))
-    (insert "\n")))
-
-(defun package-list-maybe-add (package version status description result)
-  (unless (assoc (cons package version) result)
-    (push (list (cons package version) status description) result))
-  result)
-
-(defvar package-menu-package-list nil
-  "List of packages to display in the Package Menu buffer.
-A value of nil means to display all packages.")
-
-(defvar package-menu-sort-key nil
-  "Sort key for the current Package Menu buffer.")
-
-(defun package--generate-package-list ()
-  "Populate the current Package Menu buffer."
-  (let ((inhibit-read-only t)
-        info-list name desc hold builtin)
-    (erase-buffer)
-    ;; List installed packages
-    (dolist (elt package-alist)
-      (setq name (car elt))
-      (when (or (null package-menu-package-list)
-                (memq name package-menu-package-list))
-        (setq desc (cdr elt)
-              hold (cadr (assq name package-load-list)))
-        (setq info-list
-              (package-list-maybe-add
-               name (package-desc-vers desc)
-               ;; FIXME: it turns out to be tricky to see if this
-               ;; package is presently activated.
-               (if (stringp hold) "held" "installed")
-               (package-desc-doc desc)
-               info-list))))
-
-    ;; List built-in packages
-    (dolist (elt package--builtins)
-      (setq name (car elt))
-      (when (and (not (eq name 'emacs)) ; Hide the `emacs' package.
-                 (or (null package-menu-package-list)
-                     (memq name package-menu-package-list)))
-        (setq desc (cdr elt))
-        (setq info-list
-              (package-list-maybe-add
-               name (package-desc-vers desc)
-               "built-in"
-               (package-desc-doc desc)
-               info-list))))
-
-    ;; List available and disabled packages
-    (dolist (elt package-archive-contents)
-      (setq name (car elt)
-            desc (cdr elt)
-            hold (assq name package-load-list))
-      (when (or (null package-menu-package-list)
-                (memq name package-menu-package-list))
-        (setq info-list
-              (package-list-maybe-add name
-                                      (package-desc-vers desc)
-                                      (if (and hold (null (cadr hold)))
-                                          "disabled"
-                                        "available")
-                                      (package-desc-doc (cdr elt))
-                                      info-list))))
-    ;; List obsolete packages
-    (mapc (lambda (elt)
-            (mapc (lambda (inner-elt)
-                    (setq info-list
-                          (package-list-maybe-add (car elt)
-                                                  (package-desc-vers
-                                                   (cdr inner-elt))
-                                                  "obsolete"
-                                                  (package-desc-doc
-                                                   (cdr inner-elt))
-                                                  info-list)))
-                  (cdr elt)))
-          package-obsolete-alist)
-
-    (setq info-list
-          (sort info-list
-                (cond ((string= package-menu-sort-key "Package")
-                       'package-menu--name-predicate)
-                      ((string= package-menu-sort-key "Version")
-                       'package-menu--version-predicate)
-                      ((string= package-menu-sort-key "Description")
-                       'package-menu--description-predicate)
-                      (t ; By default, sort by package status
-                       'package-menu--status-predicate))))
-
-    (dolist (elt info-list)
-      (package-print-package (car (car elt))
-                             (cdr (car elt))
-                             (car (cdr elt))
-                             (car (cdr (cdr elt)))))
-    (goto-char (point-min))
-    (set-buffer-modified-p nil)
-    (current-buffer)))
-
-(defun package-menu--version-predicate (left right)
-  (let ((vleft  (or (cdr (car left))  '(0)))
-        (vright (or (cdr (car right)) '(0))))
-    (if (version-list-= vleft vright)
-        (package-menu--name-predicate left right)
-      (version-list-< vleft vright))))
-
-(defun package-menu--status-predicate (left right)
-  (let ((sleft  (cadr left))
-        (sright (cadr right)))
-    (cond ((string= sleft sright)
-           (package-menu--name-predicate left right))
-          ((string= sleft  "available") t)
-          ((string= sright "available") nil)
-          ((string= sleft  "installed") t)
-          ((string= sright "installed") nil)
-          ((string= sleft  "held") t)
-          ((string= sright "held") nil)
-          ((string= sleft  "built-in") t)
-          ((string= sright "built-in") nil)
-          ((string= sleft  "obsolete") t)
-          ((string= sright  "obsolete") nil)
-          (t (string< sleft sright)))))
-
-(defun package-menu--description-predicate (left right)
-  (let ((sleft  (car (cddr left)))
-        (sright (car (cddr right))))
-    (if (string= sleft sright)
-        (package-menu--name-predicate left right)
-      (string< sleft sright))))
-
-(defun package-menu--name-predicate (left right)
-  (string< (symbol-name (caar left))
-           (symbol-name (caar right))))
-
-(defun package-menu-sort-by-column (&optional e)
-  "Sort the package menu by the column of the mouse click E."
-  (interactive "e")
-  (let* ((pos (event-start e))
-         (obj (posn-object pos))
-         (col (if obj
-                  (get-text-property (cdr obj) 'column-name (car obj))
-                (get-text-property (posn-point pos) 'column-name)))
-         (buf (window-buffer (posn-window (event-start e)))))
-    (with-current-buffer buf
-      (when (eq major-mode 'package-menu-mode)
-        (setq package-menu-sort-key col)
-        (package--generate-package-list)))))
-
-(defun package--list-packages (&optional packages)
-  "Generate and pop to the *Packages* buffer.
-Optional PACKAGES is a list of names of packages (symbols) to
-list; the default is to display everything in `package-alist'."
-  (require 'finder-inf nil t)
-  (let ((buf (get-buffer-create "*Packages*")))
-    (with-current-buffer buf
-      (package-menu-mode)
-      (set (make-local-variable 'package-menu-package-list) packages)
-      (set (make-local-variable 'package-menu-sort-key) nil)
-      (package--generate-package-list))
-    ;; The package menu buffer has keybindings.  If the user types
-    ;; `M-x list-packages', that suggests it should become current.
-    (switch-to-buffer buf)))
+(defun package-menu--version-predicate (A B)
+  (let ((vA (or (aref (cadr A) 1)  '(0)))
+        (vB (or (aref (cadr B) 1) '(0))))
+    (if (version-list-= vA vB)
+        (package-menu--name-predicate A B)
+      (version-list-< vA vB))))
+
+(defun package-menu--status-predicate (A B)
+  (let ((sA (aref (cadr A) 2))
+        (sB (aref (cadr B) 2)))
+    (cond ((string= sA sB)
+           (package-menu--name-predicate A B))
+          ((string= sA  "available") t)
+          ((string= sB "available") nil)
+          ((string= sA  "installed") t)
+          ((string= sB "installed") nil)
+          ((string= sA  "held") t)
+          ((string= sB "held") nil)
+          ((string= sA  "built-in") t)
+          ((string= sB "built-in") nil)
+          ((string= sA  "obsolete") t)
+          ((string= sB  "obsolete") nil)
+          (t (string< sA sB)))))
+
+(defun package-menu--description-predicate (A B)
+  (let ((dA (aref (cadr A) 3))
+        (dB (aref (cadr B) 3)))
+    (if (string= dA dB)
+        (package-menu--name-predicate A B)
+      (string< dA dB))))
+
+(defun package-menu--name-predicate (A B)
+  (string< (symbol-name (caar A))
+           (symbol-name (caar B))))
 
 ;;;###autoload
-(defun list-packages ()
+(defun list-packages (&optional no-fetch)
   "Display a list of packages.
-Fetches the updated list of packages before displaying.
+This first fetches the updated list of packages before
+displaying, unless a prefix argument NO-FETCH is specified.
 The list is displayed in a buffer named `*Packages*'."
-  (interactive)
+  (interactive "P")
+  (require 'finder-inf nil t)
   ;; Initialize the package system if necessary.
   (unless package--initialized
     (package-initialize t))
-  (package-refresh-contents)
-  (package--list-packages))
+  (unless no-fetch
+    (package-refresh-contents))
+  (let ((buf (get-buffer-create "*Packages*")))
+    (with-current-buffer buf
+      (package-menu-mode)
+      (package-menu--generate))
+    ;; The package menu buffer has keybindings.  If the user types
+    ;; `M-x list-packages', that suggests it should become current.
+    (switch-to-buffer buf)))
 
 ;;;###autoload
 (defalias 'package-list-packages 'list-packages)
@@ -1722,7 +1590,7 @@ The list is displayed in a buffer named `*Packages*'."
 Does not fetch the updated list of packages before displaying.
 The list is displayed in a buffer named `*Packages*'."
   (interactive)
-  (package--list-packages))
+  (list-packages t))
 
 (provide 'package)
 
diff --git a/lisp/emacs-lisp/tabulated-list.el b/lisp/emacs-lisp/tabulated-list.el
new file mode 100644
index 00000000000..03ee59dd89c
--- /dev/null
+++ b/lisp/emacs-lisp/tabulated-list.el
@@ -0,0 +1,355 @@
+;;; tabulated-list.el --- generic major mode for tabulated lists.
+
+;; Copyright (C) 2011 Free Software Foundation, Inc.
+
+;; Author: Chong Yidong <cyd@stupidchicken.com>
+;; Keywords: extensions, lisp
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 3, or (at your option)
+;; any later version.
+
+;; 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.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; This file defines `tabulated-list-mode', a generic major mode for displaying
+;; lists of tabulated data, intended for other major modes to inherit from.  It
+;; provides several utility routines, e.g. for pretty-printing lines of
+;; tabulated data to fit into the appropriate columns.
+
+;; For usage information, see the documentation of `tabulated-list-mode'.
+
+;; This package originated from Tom Tromey's Package Menu mode, extended and
+;; generalized to be used by other modes.
+
+;;; Code:
+
+(defvar tabulated-list-format nil
+  "The format of the current Tabulated List mode buffer.
+This should be a vector of elements (NAME WIDTH SORT), where:
+ - NAME is a string describing the column.
+ - WIDTH is the width to reserve for the column.
+   For the final element, its numerical value is ignored.
+ - SORT specifies how to sort entries by this column.
+   If nil, this column cannot be used for sorting.
+   If t, sort by comparing the string value printed in the column.
+   Otherwise, it should be a predicate function suitable for
+   `sort', accepting arguments with the same form as the elements
+   of `tabulated-list-entries'.")
+(make-variable-buffer-local 'tabulated-list-format)
+
+(defvar tabulated-list-entries nil
+  "Entries displayed in the current Tabulated List buffer.
+This should be either a function, or a list.
+If a list, each element has the form (ID [DESC1 ... DESCN]),
+where:
+ - ID is nil, or a Lisp object uniquely identifying this entry,
+   which is used to keep the cursor on the \"same\" entry when
+   rearranging the list.  Comparison is done with `equal'.
+
+ - Each DESC is a column descriptor, one for each column
+   specified in `tabulated-list-format'.  A descriptor is either
+   a string, which is printed as-is, or a list (LABEL . PROPS),
+   which means to use `insert-text-button' to insert a text
+   button with label LABEL and button properties PROPS.
+   The string, or button label, must not contain any newline.
+
+If `tabulated-list-entries' is a function, it is called with no
+arguments and must return a list of the above form.")
+(make-variable-buffer-local 'tabulated-list-entries)
+
+(defvar tabulated-list-padding 0
+  "Number of characters preceding each Tabulated List mode entry.
+By default, lines are padded with spaces, but you can use the
+function `tabulated-list-put-tag' to change this.")
+(make-variable-buffer-local 'tabulated-list-padding)
+
+(defvar tabulated-list-revert-hook nil
+  "Hook run before reverting a Tabulated List buffer.
+This is commonly used to recompute `tabulated-list-entries'.")
+
+(defvar tabulated-list-printer 'tabulated-list-print-entry
+  "Function for inserting a Tabulated List entry at point.
+It is called with two arguments, ID and COLS.  ID is a Lisp
+object identifying the entry, and COLS is a vector of column
+descriptors, as documented in `tabulated-list-entries'.")
+(make-variable-buffer-local 'tabulated-list-printer)
+
+(defvar tabulated-list-sort-key nil
+  "Sort key for the current Tabulated List mode buffer.
+If nil, no additional sorting is performed.
+Otherwise, this should be a cons cell (NAME . FLIP).
+NAME is a string matching one of the column names in
+`tabulated-list-format' (the corresponding SORT entry in
+`tabulated-list-format' then specifies how to sort).  FLIP, if
+non-nil, means to invert the resulting sort.")
+(make-variable-buffer-local 'tabulated-list-sort-key)
+
+(defun tabulated-list-get-id (&optional pos)
+  "Obtain the entry ID of the Tabulated List mode entry at POS.
+This is an ID object from `tabulated-list-entries', or nil.
+POS, if omitted or nil, defaults to point."
+  (get-text-property (or pos (point)) 'tabulated-list-id))
+
+(defun tabulated-list-put-tag (tag &optional advance)
+  "Put TAG in the padding area of the current line.
+TAG should be a string, with length <= `tabulated-list-padding'.
+If ADVANCE is non-nil, move forward by one line afterwards."
+  (unless (stringp tag)
+    (error "Invalid argument to `tabulated-list-put-tag'"))
+  (unless (> tabulated-list-padding 0)
+    (error "Unable to tag the current line"))
+  (save-excursion
+    (beginning-of-line)
+    (when (get-text-property (point) 'tabulated-list-id)
+      (let ((beg (point))
+            (inhibit-read-only t))
+        (forward-char tabulated-list-padding)
+        (insert-and-inherit
+         (if (<= (length tag) tabulated-list-padding)
+             (concat tag
+                     (make-string (- tabulated-list-padding (length tag))
+                                  ?\s))
+           (substring tag 0 tabulated-list-padding)))
+        (delete-region beg (+ beg tabulated-list-padding)))))
+  (if advance
+      (forward-line)))
+
+(defvar tabulated-list-mode-map
+  (let ((map (copy-keymap special-mode-map)))
+    (set-keymap-parent map button-buffer-map)
+    (define-key map "n" 'next-line)
+    (define-key map "p" 'previous-line)
+    (define-key map [follow-link] 'mouse-face)
+    (define-key map [mouse-2] 'mouse-select-window)
+    map)
+  "Local keymap for `tabulated-list-mode' buffers.")
+
+(defvar tabulated-list-sort-button-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map [header-line mouse-1] 'tabulated-list-col-sort)
+    (define-key map [header-line mouse-2] 'tabulated-list-col-sort)
+    (define-key map [follow-link] 'mouse-face)
+    map)
+  "Local keymap for `tabulated-list-mode' sort buttons.")
+
+(defun tabulated-list-init-header ()
+  "Set up header line for the Tabulated List buffer."
+  (let ((x tabulated-list-padding)
+        (button-props `(help-echo "Click to sort by column"
+                        mouse-face highlight
+                        keymap ,tabulated-list-sort-button-map))
+        (cols nil))
+    (if (> tabulated-list-padding 0)
+        (push (propertize " " 'display `(space :align-to ,x)) cols))
+    (dotimes (n (length tabulated-list-format))
+      (let* ((col (aref tabulated-list-format n))
+             (width (nth 1 col))
+             (label (car col)))
+        (setq x (+ x 1 width))
+        (and (<= tabulated-list-padding 0)
+             (= n 0)
+             (setq label (concat " " label)))
+        (push
+         (cond
+          ;; An unsortable column
+          ((not (nth 2 col)) label)
+          ;; The selected sort column
+          ((equal (car col) (car tabulated-list-sort-key))
+           (apply 'propertize
+                  (concat label
+                          (cond
+                           ((> (+ 2 (length label)) width)
+                            "")
+                           ((cdr tabulated-list-sort-key)
+                            " ▲")
+                           (t " ▼")))
+                  'face 'bold
+                  'tabulated-list-column-name (car col)
+                  button-props))
+          ;; Unselected sortable column.
+          (t (apply 'propertize label
+                    'tabulated-list-column-name (car col)
+                    button-props)))
+         cols))
+      (push (propertize " "
+                        'display (list 'space :align-to x)
+                        'face 'fixed-pitch)
+            cols))
+    (setq header-line-format (mapconcat 'identity (nreverse cols) ""))))
+
+(defun tabulated-list-revert (&rest ignored)
+  "The `revert-buffer-function' for `tabulated-list-mode'.
+It runs `tabulated-list-revert-hook', then calls `tabulated-list-print'."
+  (interactive)
+  (unless (derived-mode-p 'tabulated-list-mode)
+    (error "The current buffer is not in Tabulated List mode"))
+  (run-hooks 'tabulated-list-revert-hook)
+  (tabulated-list-print t))
+
+(defun tabulated-list-print (&optional remember-pos)
+  "Populate the current Tabulated List mode buffer.
+This sorts the `tabulated-list-entries' list if sorting is
+specified by `tabulated-list-sort-key'.  It then erases the
+buffer and inserts the entries with `tabulated-list-printer'.
+
+Optional argument REMEMBER-POS, if non-nil, means to move point
+to the entry with the same ID element as the current line."
+  (let ((inhibit-read-only t)
+        (entries (if (functionp 'tabulated-list-entries)
+                     (funcall tabulated-list-entries)
+                   tabulated-list-entries))
+        entry-id saved-pt saved-col)
+    (and remember-pos
+         (setq entry-id (tabulated-list-get-id))
+         (setq saved-col (current-column)))
+    (erase-buffer)
+    ;; Sort the buffers, if necessary.
+    (when tabulated-list-sort-key
+      (let ((sort-column (car tabulated-list-sort-key))
+            (len (length tabulated-list-format))
+            (n 0)
+            sorter)
+        ;; Which column is to be sorted?
+        (while (and (< n len)
+                    (not (equal (car (aref tabulated-list-format n))
+                                sort-column)))
+          (setq n (1+ n)))
+        (when (< n len)
+          (setq sorter (nth 2 (aref tabulated-list-format n)))
+          (when (eq sorter t)
+            (setq sorter ; Default sorter checks column N:
+                  (lambda (A B)
+                    (setq A (aref (cadr A) n))
+                    (setq B (aref (cadr B) n))
+                    (string< (if (stringp A) A (car A))
+                             (if (stringp B) B (car B))))))
+          (setq entries (sort entries sorter))
+          (if (cdr tabulated-list-sort-key)
+              (setq entries (nreverse entries)))
+          (unless (functionp 'tabulated-list-entries)
+            (setq tabulated-list-entries entries)))))
+    ;; Print the resulting list.
+    (dolist (elt entries)
+      (and entry-id
+           (equal entry-id (car elt))
+           (setq saved-pt (point)))
+      (apply tabulated-list-printer elt))
+    (set-buffer-modified-p nil)
+    ;; If REMEMBER-POS was specified, move to the "old" location.
+    (if saved-pt
+        (progn (goto-char saved-pt)
+               (move-to-column saved-col))
+      (goto-char (point-min)))))
+
+(defun tabulated-list-print-entry (id cols)
+  "Insert a Tabulated List entry at point.
+This is the default `tabulated-list-printer' function.  ID is a
+Lisp object identifying the entry to print, and COLS is a vector
+of column descriptors."
+  (let ((beg (point))
+        (x (max tabulated-list-padding 0))
+        (len (length tabulated-list-format)))
+    (if (> tabulated-list-padding 0)
+        (insert (make-string x ?\s)))
+    (dotimes (n len)
+      (let* ((format (aref tabulated-list-format n))
+             (desc   (aref cols n))
+             (width  (nth 1 format))
+             (label  (if (stringp desc) desc (car desc)))
+             (help-echo (concat (car format) ": " label)))
+        ;; Truncate labels if necessary.
+        (and (> width 6)
+             (> (length label) width)
+             (setq label (concat (substring desc 0 (- width 3))
+                                 "...")))
+        (if (stringp desc)
+            (insert (propertize label 'help-echo help-echo))
+          (apply 'insert-text-button label (cdr desc)))
+        (setq x (+ x 1 width)))
+      ;; No need to append any spaces if this is the last column.
+      (if (< (1+ n) len)
+          (indent-to x 1)))
+    (insert ?\n)
+    (put-text-property beg (point) 'tabulated-list-id id)))
+
+(defun tabulated-list-col-sort (&optional e)
+  "Sort Tabulated List entries by the column of the mouse click E."
+  (interactive "e")
+  (let* ((pos (event-start e))
+         (obj (posn-object pos))
+         (name (get-text-property (if obj (cdr obj) (posn-point pos))
+                                  'tabulated-list-column-name
+                                  (car obj))))
+    (with-current-buffer (window-buffer (posn-window pos))
+      (when (derived-mode-p 'tabulated-list-mode)
+        ;; Flip the sort order on a second click.
+        (if (equal name (car tabulated-list-sort-key))
+            (setcdr tabulated-list-sort-key
+                    (not (cdr tabulated-list-sort-key)))
+          (setq tabulated-list-sort-key (cons name nil)))
+        (tabulated-list-init-header)
+        (tabulated-list-print t)))))
+
+;;; The mode definition:
+
+;;;###autoload
+(define-derived-mode tabulated-list-mode special-mode "Tabulated"
+  "Generic major mode for browsing a list of items.
+This mode is usually not used directly; instead, other major
+modes are derived from it, using `define-derived-mode'.
+
+In this major mode, the buffer is divided into multiple columns,
+which are labelled using the header line.  Each non-empty line
+belongs to one \"entry\", and the entries can be sorted according
+to their column values.
+
+An inheriting mode should usually do the following in their body:
+
+ - Set `tabulated-list-format', specifying the column format.
+ - Set `tabulated-list-revert-hook', if the buffer contents need
+   to be specially recomputed prior to `revert-buffer'.
+ - Maybe set a `tabulated-list-entries' function (see below).
+ - Maybe set `tabulated-list-printer' (see below).
+ - Maybe set `tabulated-list-padding'.
+ - Call `tabulated-list-init-header' to initialize `header-line-format'
+   according to `tabulated-list-format'.
+
+An inheriting mode is usually accompanied by a \"list-FOO\"
+command (e.g. `list-packages', `list-processes').  This command
+creates or switches to a buffer and enables the major mode in
+that buffer.  If `tabulated-list-entries' is not a function, the
+command should initialize it to a list of entries for displaying.
+Finally, it should call `tabulated-list-print'.
+
+`tabulated-list-print' calls the printer function specified by
+`tabulated-list-printer', once for each entry.  The default
+printer is `tabulated-list-print-entry', but a mode that keeps
+data in an ewoc may instead specify a printer function (e.g., one
+that calls `ewoc-enter-last'), with `tabulated-list-print-entry'
+as the ewoc pretty-printer."
+  (setq truncate-lines t)
+  (setq buffer-read-only t)
+  (set (make-local-variable 'revert-buffer-function)
+       'tabulated-list-revert))
+
+(put 'tabulated-list-mode 'mode-class 'special)
+
+(provide 'tabulated-list)
+
+;; Local Variables:
+;; coding: utf-8
+;; lexical-binding: t
+;; End:
+
+;;; tabulated-list.el ends here
diff --git a/lisp/files.el b/lisp/files.el
index e87c25f3575..5b29f3790e8 100644
--- a/lisp/files.el
+++ b/lisp/files.el
@@ -1140,6 +1140,37 @@ it means chase no more than that many links and then stop."
         (setq count (1+ count))))
     newname))
 
+;; A handy function to display file sizes in human-readable form.
+;; See http://en.wikipedia.org/wiki/Kibibyte for the reference.
+(defun file-size-human-readable (file-size &optional flavor)
+  "Produce a string showing FILE-SIZE in human-readable form.
+
+Optional second argument FLAVOR controls the units and the display format:
+
+ If FLAVOR is nil or omitted, each kilobyte is 1024 bytes and the produced
+    suffixes are \"k\", \"M\", \"G\", \"T\", etc.
+ If FLAVOR is `si', each kilobyte is 1000 bytes and the produced suffixes
+    are \"k\", \"M\", \"G\", \"T\", etc.
+ If FLAVOR is `iec', each kilobyte is 1024 bytes and the produced suffixes
+    are \"KiB\", \"MiB\", \"GiB\", \"TiB\", etc."
+  (let ((power (if (or (null flavor) (eq flavor 'iec))
+                   1024.0
+                 1000.0))
+        (post-fixes
+         ;; none, kilo, mega, giga, tera, peta, exa, zetta, yotta
+         (list "" "k" "M" "G" "T" "P" "E" "Z" "Y")))
+    (while (and (>= file-size power) (cdr post-fixes))
+      (setq file-size (/ file-size power)
+            post-fixes (cdr post-fixes)))
+    (format (if (> (mod file-size 1.0) 0.05)
+                "%.1f%s%s"
+              "%.0f%s%s")
+            file-size
+            (if (and (eq flavor 'iec) (string= (car post-fixes) "k"))
+                "K"
+              (car post-fixes))
+            (if (eq flavor 'iec) "iB" ""))))
+
 (defun make-temp-file (prefix &optional dir-flag suffix)
   "Create a temporary file.
 The returned file name (created by appending some random characters at the end
@@ -2100,10 +2131,8 @@ the file contents into it using `insert-file-contents-literally'."
           (confirm-nonexistent-file-or-buffer))))
   (switch-to-buffer (find-file-noselect filename nil t)))
 
-(defvar after-find-file-from-revert-buffer nil)
-
 (defun after-find-file (&optional error warn noauto
-                                  after-find-file-from-revert-buffer
+                                  _after-find-file-from-revert-buffer
                                   nomodes)
   "Called after finding a file and by the default revert function.
 Sets buffer mode, parses local variables.
@@ -2111,8 +2140,8 @@ Optional args ERROR, WARN, and NOAUTO: ERROR non-nil means there was an
 error in reading the file.  WARN non-nil means warn if there
 exists an auto-save file more recent than the visited file.
 NOAUTO means don't mess with auto-save mode.
-Fourth arg AFTER-FIND-FILE-FROM-REVERT-BUFFER non-nil
- means this call was from `revert-buffer'.
+Fourth arg AFTER-FIND-FILE-FROM-REVERT-BUFFER is ignored
+\(see `revert-buffer-in-progress-p' for similar functionality).
 Fifth arg NOMODES non-nil means don't alter the file's modes.
 Finishes by calling the functions in `find-file-hook'
 unless NOMODES is non-nil."
@@ -5004,6 +5033,10 @@ hook functions.
 If `revert-buffer-function' is used to override the normal revert
 mechanism, this hook is not used.")
 
+(defvar revert-buffer-in-progress-p nil
+  "Non-nil if a `revert-buffer' operation is in progress, nil otherwise.
+This is true even if a `revert-buffer-function' is being used.")
+
 (defvar revert-buffer-internal-hook)
 
 (defun revert-buffer (&optional ignore-auto noconfirm preserve-modes)
@@ -5046,10 +5079,12 @@ non-nil, it is called instead of rereading visited file contents."
   ;; interface, but leaving the programmatic interface the same.
   (interactive (list (not current-prefix-arg)))
   (if revert-buffer-function
-      (funcall revert-buffer-function ignore-auto noconfirm)
+      (let ((revert-buffer-in-progress-p t))
+        (funcall revert-buffer-function ignore-auto noconfirm))
     (with-current-buffer (or (buffer-base-buffer (current-buffer))
                              (current-buffer))
-      (let* ((auto-save-p (and (not ignore-auto)
+      (let* ((revert-buffer-in-progress-p t)
+             (auto-save-p (and (not ignore-auto)
                                (recent-auto-save-p)
                                buffer-auto-save-file-name
                                (file-readable-p buffer-auto-save-file-name)
@@ -5140,7 +5175,7 @@ non-nil, it is called instead of rereading visited file contents."
                  ;; have changed the truename.
                  (setq buffer-file-truename
                        (abbreviate-file-name (file-truename buffer-file-name)))
-                 (after-find-file nil nil t t preserve-modes)
+                 (after-find-file nil nil t nil preserve-modes)
                  ;; Run after-revert-hook as it was before we reverted.
                  (setq-default revert-buffer-internal-hook global-hook)
                  (if local-hook
@@ -6142,8 +6177,8 @@ With prefix ARG, silently save all file-visiting buffers, then kill."
                     (setq active t))
                (setq processes (cdr processes)))
              (or (not active)
-                 (list-processes t)
-                 (yes-or-no-p "Active processes exist; kill them and exit anyway? "))))
+                 (progn (list-processes t)
+                        (yes-or-no-p "Active processes exist; kill them and exit anyway? ")))))
        ;; Query the user for other things, perhaps.
        (run-hook-with-args-until-failure 'kill-emacs-query-functions)
        (or (null confirm-kill-emacs)
diff --git a/lisp/follow.el b/lisp/follow.el
index 7f4093dd442..c76085f6dcb 100644
--- a/lisp/follow.el
+++ b/lisp/follow.el
@@ -1061,7 +1061,7 @@ Return the selected window."
 ;; it wasn't just moved here. (i.e. M-> shall not unconditionally place
 ;; the point in the selected window.)
 ;;
-;; (Compability cludge: in Emacs `window-end' is equal to `point-max';
+;; (Compatibility cludge: in Emacs `window-end' is equal to `point-max';
 ;; in XEmacs, it is equal to `point-max + 1'. Should I really bother
 ;; checking `window-end' now when I check `end-of-buffer' explicitly?)
 
diff --git a/lisp/gnus/ChangeLog b/lisp/gnus/ChangeLog
index b79a5de55e1..baabe5f65b9 100644
--- a/lisp/gnus/ChangeLog
+++ b/lisp/gnus/ChangeLog
@@ -1,10 +1,53 @@
+2011-04-07  Teodor Zlatanov  <tzz@lifelogs.com>
+
+        * gnus-registry.el (gnus-registry-handle-action): More debugging.
+
+        * gnus-start.el (gnus-gnus-to-newsrc-format): Add a way to run
+        interactively so the newsrc file can contain foreign groups too.
+        Useful for debugging but not much for users.
+
+2011-04-07  David Engster  <dengste@eml.cc>
+
+        * registry.el (registry-usage-test): Only do
+        `registry-lookup-breaks-before-lexbind' testing for Emacs24 with
+        lexical binding.
+
+2011-04-06  David Engster  <dengste@eml.cc>
+
+        * registry.el, gnus-registry.el: Use `ignore-errors' instead of third
+        argument NOERROR for `require', since XEmacs 21.4 does not support it.
+
+2011-04-06  David Engster  <dengste@eml.cc>
+
+        * registry.el (initialize-instance): Change :after to :AFTER to be
+        compatible with old EIEIO version in XEmacs.
+
+2011-04-06  Teodor Zlatanov  <tzz@lifelogs.com>
+
+        * gnus-registry.el (gnus-registry-post-process-groups)
+        (gnus-registry--split-fancy-with-parent-internal): Fix splitting bugs
+        and provide better messaging.
+
+2011-04-06  David Engster  <dengste@eml.cc>
+
+        * Makefile.in (fail-on-warning): New rule to compile with warnings as
+        errors.
+
+        * dgnushack.el (dgnushack-compile-error-on-warn): New function to call
+        dgnushack-compile with error-on-warn enabled, and to signal an error if
+        clean compilation failed.
+        (dgnushack-compile): New argument 'error-on-warn'.  If non-nil, compile
+        with `byte-compile-error-on-warn'.  Return nil if errors occured.
+
 2011-04-06  Teodor Zlatanov  <tzz@lifelogs.com>
 
-        * gnus-registry.el: Don't use ERT if it's not available.
+        * gnus-registry.el: Don't use ERT if it's not available.  Load it
+        unconditionally anyway, discarding errors.
         (gnus-registry-delete-entries): New convenience function.
         (gnus-registry-import-eld): Import from old .eld registry.
 
-        * registry.el: Don't use ERT if it's not available.
+        * registry.el: Don't use ERT if it's not available.  Load it
+        unconditionally anyway, discarding errors.
 
         * proto-stream.el (gnutls-negotiate): Revert inadvertent commit of the
         version from the Claudio Bley GnuTLS patch (extra optional parameters
@@ -15171,7 +15214,7 @@
         * smime-ldap.el (smime-ldap-search): Add compatibility for XEmacs.
 
         * smime.el (smime-cert-by-ldap-1): Handle certificates distributed
-        in PEM format.  Adjust to the XEmacs compability.
+        in PEM format.  Adjust to the XEmacs compatibility.
 
 2005-05-30  Reiner Steib  <Reiner.Steib@gmx.de>
 
diff --git a/lisp/gnus/gnus-registry.el b/lisp/gnus/gnus-registry.el
index 511012df577..9824fc26f16 100644
--- a/lisp/gnus/gnus-registry.el
+++ b/lisp/gnus/gnus-registry.el
@@ -58,9 +58,11 @@
 (eval-when-compile (require 'cl))
 
 (eval-when-compile
-  (when (null (require 'ert nil t))
+  (when (null (ignore-errors (require 'ert)))
     (defmacro* ert-deftest (name () &body docstring-keys-and-body))))
 
+(ignore-errors
+  (require 'ert))
 (require 'gnus)
 (require 'gnus-int)
 (require 'gnus-sum)
@@ -319,6 +321,9 @@ This is not required after changing `gnus-registry-cache-file'."
     (gnus-registry-handle-action id nil to subject sender)))
 
 (defun gnus-registry-handle-action (id from to subject sender)
+  (gnus-message
+   10
+   "gnus-registry-handle-action %S" (list id from to subject sender))
   (let ((db gnus-registry-db)
         ;; safe if not found
         (entry (gnus-registry-get-or-make-entry id)))
@@ -394,85 +399,83 @@ See the Info node `(gnus)Fancy Mail Splitting' for more details."
            &allow-other-keys)
   (gnus-message
    10
-   "gnus-registry--split-fancy-with-parent-internal: %S" spec)
+   "gnus-registry--split-fancy-with-parent-internal %S" spec)
   (let ((db gnus-registry-db)
         found)
-    ;; this is a big if-else statement.  it uses
+    ;; this is a big chain of statements.  it uses
     ;; gnus-registry-post-process-groups to filter the results after
     ;; every step.
-    (cond
-     ;; the references string must be valid and parse to valid references
-     (references
+    ;; the references string must be valid and parse to valid references
+    (when references
+      (gnus-message
+       9
+       "%s is tracing references %s"
+       log-agent refstr)
       (dolist (reference (nreverse references))
-        (gnus-message
-         9
-         "%s is looking for matches for reference %s from [%s]"
-         log-agent reference refstr)
-        (setq found
-              (loop for group in (gnus-registry-get-id-key reference 'group)
-                    when (gnus-registry-follow-group-p group)
-                    do (gnus-message
-                        7
-                        "%s traced the reference %s from [%s] to group %s"
-                        log-agent reference refstr group)
-                    collect group)))
+        (gnus-message 9 "%s is looking up %s" log-agent reference)
+        (loop for group in (gnus-registry-get-id-key reference 'group)
+              when (gnus-registry-follow-group-p group)
+              do (gnus-message 7 "%s traced %s to %s" log-agent reference group)
+              do (push group found)))
       ;; filter the found groups and return them
       ;; the found groups are the full groups
       (setq found (gnus-registry-post-process-groups
                    "references" refstr found)))
 
      ;; else: there were no matches, try the extra tracking by sender
-     ((and (memq 'sender gnus-registry-track-extra)
-           sender
-           (gnus-grep-in-list
-            sender
-            gnus-registry-unfollowed-addresses))
-      (let ((groups (apply
-                     'append
-                     (mapcar
-                      (lambda (reference)
-                        (gnus-registry-get-id-key reference 'group))
-                      (registry-lookup-secondary-value db 'sender sender)))))
-        (setq found
-              (loop for group in groups
-                    when (gnus-registry-follow-group-p group)
-                  do (gnus-message
-                      ;; raise level of messaging if gnus-registry-track-extra
-                      (if gnus-registry-track-extra 7 9)
-                      "%s (extra tracking) traced sender '%s' to groups %s"
-                      log-agent sender found)
-                  collect group)))
-
-      ;; filter the found groups and return them
-      ;; the found groups are NOT the full groups
-      (setq found (gnus-registry-post-process-groups
-                   "sender" sender found)))
+     (when (and (null found)
+                (memq 'sender gnus-registry-track-extra)
+                sender
+                (gnus-grep-in-list
+                 sender
+                 gnus-registry-unfollowed-addresses))
+       (let ((groups (apply
+                      'append
+                      (mapcar
+                       (lambda (reference)
+                         (gnus-registry-get-id-key reference 'group))
+                       (registry-lookup-secondary-value db 'sender sender)))))
+         (setq found
+               (loop for group in groups
+                     when (gnus-registry-follow-group-p group)
+                     do (gnus-message
+                         ;; warn more if gnus-registry-track-extra
+                         (if gnus-registry-track-extra 7 9)
+                         "%s (extra tracking) traced sender '%s' to %s"
+                         log-agent sender group)
+                     collect group)))
+
+       ;; filter the found groups and return them
+       ;; the found groups are NOT the full groups
+       (setq found (gnus-registry-post-process-groups
+                    "sender" sender found)))
 
      ;; else: there were no matches, now try the extra tracking by subject
-     ((and (memq 'subject gnus-registry-track-extra)
-           subject
-           (< gnus-registry-minimum-subject-length (length subject)))
-      (let ((groups (apply
-                     'append
-                     (mapcar
-                      (lambda (reference)
-                        (gnus-registry-get-id-key reference 'group))
-                      (registry-lookup-secondary-value db 'subject subject)))))
-        (setq found
-              (loop for group in groups
-                    when (gnus-registry-follow-group-p group)
-                    do (gnus-message
-                        ;; raise level of messaging if gnus-registry-track-extra
-                        (if gnus-registry-track-extra 7 9)
-                        "%s (extra tracking) traced subject '%s' to groups %s"
-                        log-agent subject found)
-                    collect group))
-      ;; filter the found groups and return them
-      ;; the found groups are NOT the full groups
-      (setq found (gnus-registry-post-process-groups
-                   "subject" subject found)))))
-    ;; after the (cond) we extract the actual value safely
-    (car-safe found)))
+     (when (and (null found)
+                (memq 'subject gnus-registry-track-extra)
+                subject
+                (< gnus-registry-minimum-subject-length (length subject)))
+       (let ((groups (apply
+                      'append
+                      (mapcar
+                       (lambda (reference)
+                         (gnus-registry-get-id-key reference 'group))
+                       (registry-lookup-secondary-value db 'subject subject)))))
+         (setq found
+               (loop for group in groups
+                     when (gnus-registry-follow-group-p group)
+                     do (gnus-message
+                         ;; warn more if gnus-registry-track-extra
+                         (if gnus-registry-track-extra 7 9)
+                         "%s (extra tracking) traced subject '%s' to %s"
+                         log-agent subject group)
+                     collect group))
+         ;; filter the found groups and return them
+         ;; the found groups are NOT the full groups
+         (setq found (gnus-registry-post-process-groups
+                      "subject" subject found))))
+     ;; after the (cond) we extract the actual value safely
+     (car-safe found)))
 
 (defun gnus-registry-post-process-groups (mode key groups)
   "Inspects GROUPS found by MODE for KEY to determine which ones to follow.
@@ -489,25 +492,48 @@ Foreign methods are not supported so they are rejected.
 Reduces the list to a single group, or complains if that's not
 possible.  Uses `gnus-registry-split-strategy'."
   (let ((log-agent "gnus-registry-post-process-group")
-        out)
-
-    ;; the strategy can be nil, in which case groups is nil
-    (setq groups
+        (desc (format "%d groups" (length groups)))
+        out chosen)
+    ;; the strategy can be nil, in which case chosen is nil
+    (setq chosen
           (case gnus-registry-split-strategy
-            ;; first strategy
+            ;; default, take only one-element lists into chosen
+            ((nil)
+             (and (= (length groups) 1)
+                  (car-safe groups)))
+
             ((first)
-             (and groups (list (car-safe groups))))
+             (car-safe groups))
 
             ((majority)
              (let ((freq (make-hash-table
                           :size 256
                           :test 'equal)))
-               (mapc (lambda (x) (puthash x (1+ (gethash x freq 0)) freq))
+               (mapc (lambda (x) (let ((x (gnus-group-short-name x)))
+                              (puthash x (1+ (gethash x freq 0)) freq)))
                      groups)
-               (list (car-safe
-                      (sort groups (lambda (a b)
-                                     (> (gethash a freq 0)
-                                        (gethash b freq 0))))))))))
+               (setq desc (format "%d groups, %d unique"
+                                  (length groups)
+                                  (hash-table-count freq)))
+               (car-safe
+                (sort groups
+                      (lambda (a b)
+                        (> (gethash (gnus-group-short-name a) freq 0)
+                           (gethash (gnus-group-short-name b) freq 0)))))))))
+
+    (if chosen
+        (gnus-message
+         9
+         "%s: strategy %s on %s produced %s"
+         log-agent gnus-registry-split-strategy desc chosen)
+      (gnus-message
+       9
+       "%s: strategy %s on %s did not produce an answer"
+       log-agent
+       (or gnus-registry-split-strategy "default")
+       desc))
+
+    (setq groups (and chosen (list chosen)))
 
     (dolist (group groups)
       (let ((m1 (gnus-find-method-for-group group))
@@ -517,18 +543,20 @@ possible.  Uses `gnus-registry-split-strategy'."
         (if (gnus-methods-equal-p m1 m2)
             (progn
               ;; this is REALLY just for debugging
-              (gnus-message
-               10
-               "%s stripped group %s to %s"
-               log-agent group short-name)
+              (when (not (equal group short-name))
+                (gnus-message
+                 10
+                 "%s: stripped group %s to %s"
+                 log-agent group short-name))
               (add-to-list 'out short-name))
           ;; else...
           (gnus-message
            7
-           "%s ignored foreign group %s"
+           "%s: ignored foreign group %s"
            log-agent group))))
 
-    ;; is there just one group?
+    (setq out (delq nil out))
+
     (cond
      ((= (length out) 1) out)
      ((null out)
diff --git a/lisp/gnus/gnus-start.el b/lisp/gnus/gnus-start.el
index fa582c58aee..d9d218c6cba 100644
--- a/lisp/gnus/gnus-start.el
+++ b/lisp/gnus/gnus-start.el
@@ -2873,7 +2873,8 @@ If FORCE is non-nil, the .newsrc file is read."
       (pop list))
     (nreverse olist)))
 
-(defun gnus-gnus-to-newsrc-format ()
+(defun gnus-gnus-to-newsrc-format (&optional foreign-ok)
+  (interactive (list (gnus-y-or-n-p "write foreign groups too? ")))
   ;; Generate and save the .newsrc file.
   (with-current-buffer (create-file-buffer gnus-current-startup-file)
     (let ((newsrc (cdr gnus-newsrc-alist))
@@ -2895,7 +2896,8 @@ If FORCE is non-nil, the .newsrc file is read."
         ;; Don't write foreign groups to .newsrc.
         (when (or (null (setq method (gnus-info-method info)))
                   (equal method "native")
-                  (inline (gnus-server-equal method gnus-select-method)))
+                  (inline (gnus-server-equal method gnus-select-method))
+                  foreign-ok)
           (insert (gnus-info-group info)
                   (if (> (gnus-info-level info) gnus-level-subscribed)
                       "!" ":"))
diff --git a/lisp/gnus/registry.el b/lisp/gnus/registry.el
index cc03b20662d..3c402cb361a 100644
--- a/lisp/gnus/registry.el
+++ b/lisp/gnus/registry.el
@@ -78,9 +78,12 @@
 ;;; Code:
 
 (eval-when-compile
-  (when (null (require 'ert nil t))
+  (when (null (ignore-errors (require 'ert)))
     (defmacro* ert-deftest (name () &body docstring-keys-and-body))))
 
+(ignore-errors
+  (require 'ert))
+
 (eval-when-compile (require 'cl))
 (eval-and-compile
   (or (ignore-errors (progn
@@ -128,7 +131,7 @@
          :type hash-table
          :documentation "The data hashtable.")))
 
-(defmethod initialize-instance :after ((this registry-db) slots)
+(defmethod initialize-instance :AFTER ((this registry-db) slots)
   "Set value of data slot of THIS after initialization."
   (with-slots (data tracker) this
     (unless (member :data slots)
@@ -354,12 +357,13 @@ Removes only entries without the :precious keys."
     (should (= 58 (caadr (registry-lookup db '(1 58 99)))))
     (message "Grouped individual lookup")
     (should (= 3 (length (registry-lookup db '(1 58 99)))))
-    (message "Individual lookup (breaks before lexbind)")
-    (should (= 58
-               (caadr (registry-lookup-breaks-before-lexbind db '(1 58 99)))))
-    (message "Grouped individual lookup (breaks before lexbind)")
-    (should (= 3
-               (length (registry-lookup-breaks-before-lexbind db '(1 58 99)))))
+    (when (boundp 'lexical-binding)
+      (message "Individual lookup (breaks before lexbind)")
+      (should (= 58
+                 (caadr (registry-lookup-breaks-before-lexbind db '(1 58 99)))))
+      (message "Grouped individual lookup (breaks before lexbind)")
+      (should (= 3
+                 (length (registry-lookup-breaks-before-lexbind db '(1 58 99))))))
     (message "Search")
     (should (= n (length (registry-search db :all t))))
     (should (= n (length (registry-search db :member '((sender "me"))))))
diff --git a/lisp/help.el b/lisp/help.el
index e148e5ef6ab..b7f46a02155 100644
--- a/lisp/help.el
+++ b/lisp/help.el
@@ -1256,6 +1256,15 @@ Select help window if the actual value of the user option
        ;; Reset `help-window' to nil to avoid confusing future calls of
        ;; `help-mode-finish' with plain `with-output-to-temp-buffer'.
        (setq help-window nil))))
+
+;; Called from C, on encountering `help-char' when reading a char.
+;; Don't print to *Help*; that would clobber Help history.
+(defun help-form-show ()
+  "Display the output of a non-nil `help-form'."
+  (let ((msg (eval help-form)))
+    (if (stringp msg)
+        (with-output-to-temp-buffer " *Char Help*"
+          (princ msg)))))
 
 (provide 'help)
 
diff --git a/lisp/ls-lisp.el b/lisp/ls-lisp.el
index 55ec835831a..9314f934dc1 100644
--- a/lisp/ls-lisp.el
+++ b/lisp/ls-lisp.el
@@ -62,8 +62,6 @@
 
 ;;; Code:
 
-(eval-when-compile (require 'cl))
-
 (defgroup ls-lisp nil
   "Emulate the ls program completely in Emacs Lisp."
   :version "21.1"
@@ -726,13 +724,7 @@ All ls time options, namely c, t and u, are handled."
                   ls-lisp-filesize-f-fmt
                 ls-lisp-filesize-d-fmt)
               file-size)
-    (if (< file-size 1024)
-        (format " %4d" file-size)
-      (do ((file-size (/ file-size 1024.0) (/ file-size 1024.0))
-           ;; kilo, mega, giga, tera, peta, exa
-           (post-fixes (list "k" "M" "G" "T" "P" "E") (cdr post-fixes)))
-          ((< file-size 1024)
-           (format " %3.0f%s"  file-size (car post-fixes)))))))
+    (format " %7s" (file-size-human-readable file-size))))
 
 (provide 'ls-lisp)
 
diff --git a/lisp/man.el b/lisp/man.el
index c8c2f8653e2..7a9e6e3cca5 100644
--- a/lisp/man.el
+++ b/lisp/man.el
@@ -254,8 +254,7 @@ Used in `bookmark-set' to get the default bookmark name."
   "Regular expression describing a manpage section within parentheses.")
 
 (defvar Man-page-header-regexp
-  (if (and (string-match "-solaris2\\." system-configuration)
-           (not (string-match "-solaris2\\.[123435]$" system-configuration)))
+  (if (string-match "-solaris2\\." system-configuration)
       (concat "^[-A-Za-z0-9_].*[ \t]\\(" Man-name-regexp
               "(\\(" Man-section-regexp "\\))\\)$")
     (concat "^[ \t]*\\(" Man-name-regexp
diff --git a/lisp/net/browse-url.el b/lisp/net/browse-url.el
index 24dbfc0c30a..8f91fbb26b1 100644
--- a/lisp/net/browse-url.el
+++ b/lisp/net/browse-url.el
@@ -1111,8 +1111,7 @@ URL in a new window."
                  browse-url-firefox-program
                  (append
                   browse-url-firefox-arguments
-                  (if (or (featurep 'dos-w32)
-                          (string-match "win32" system-configuration))
+                  (if (memq system-type '(windows-nt ms-dos))
                       (list url)
                     (list "-remote"
                           (concat "openURL("
diff --git a/lisp/net/rlogin.el b/lisp/net/rlogin.el
index 91b4aa7d72e..e2619e3bf79 100644
--- a/lisp/net/rlogin.el
+++ b/lisp/net/rlogin.el
@@ -60,14 +60,9 @@
   :group 'rlogin)
 
 (defcustom rlogin-process-connection-type
-  (save-match-data
-    ;; Solaris 2.x `rlogin' will spew a bunch of ioctl error messages if
-    ;; stdin isn't a tty.
-    (cond ((and (boundp 'system-configuration)
-                (stringp system-configuration)
-                (string-match "-solaris2" system-configuration))
-           t)
-          (t nil)))
+  ;; Solaris 2.x `rlogin' will spew a bunch of ioctl error messages if
+  ;; stdin isn't a tty.
+  (and (string-match-p "-solaris2" system-configuration) t)
   "If non-nil, use a pty for the local rlogin process.
 If nil, use a pipe (if pipes are supported on the local system).
 
@@ -115,19 +110,19 @@ this variable is set from that."
   :type '(choice (const nil) string)
   :group 'rlogin)
 
-;; Initialize rlogin mode map.
-(defvar rlogin-mode-map '())
-(cond
- ((null rlogin-mode-map)
-  (setq rlogin-mode-map (if (consp shell-mode-map)
-                            (cons 'keymap shell-mode-map)
-                          (copy-keymap shell-mode-map)))
-  (define-key rlogin-mode-map "\C-c\C-c" 'rlogin-send-Ctrl-C)
-  (define-key rlogin-mode-map "\C-c\C-d" 'rlogin-send-Ctrl-D)
-  (define-key rlogin-mode-map "\C-c\C-z" 'rlogin-send-Ctrl-Z)
-  (define-key rlogin-mode-map "\C-c\C-\\" 'rlogin-send-Ctrl-backslash)
-  (define-key rlogin-mode-map "\C-d" 'rlogin-delchar-or-send-Ctrl-D)
-  (define-key rlogin-mode-map "\C-i" 'rlogin-tab-or-complete)))
+(defvar rlogin-mode-map
+  (let ((map (if (consp shell-mode-map)
+                 (cons 'keymap shell-mode-map)
+               (copy-keymap shell-mode-map))))
+    (define-key rlogin-mode-map "\C-c\C-c" 'rlogin-send-Ctrl-C)
+    (define-key rlogin-mode-map "\C-c\C-d" 'rlogin-send-Ctrl-D)
+    (define-key rlogin-mode-map "\C-c\C-z" 'rlogin-send-Ctrl-Z)
+    (define-key rlogin-mode-map "\C-c\C-\\" 'rlogin-send-Ctrl-backslash)
+    (define-key rlogin-mode-map "\C-d" 'rlogin-delchar-or-send-Ctrl-D)
+    (define-key rlogin-mode-map "\C-i" 'rlogin-tab-or-complete)
+    map)
+  "Keymap for `rlogin-mode'.")
+
 
 
 ;;;###autoload (add-hook 'same-window-regexps (purecopy "^\\*rlogin-.*\\*\\(\\|<[0-9]+>\\)"))
@@ -175,7 +170,6 @@ variable."
                 (read-from-minibuffer "rlogin arguments (hostname first): "
                                       nil nil nil 'rlogin-history)
                 current-prefix-arg))
-
   (let* ((process-connection-type rlogin-process-connection-type)
          (args (if rlogin-explicit-args
                    (append (split-string input-args)
@@ -192,7 +186,6 @@ variable."
          (buffer-name (if (string= user (user-login-name))
                           (format "*rlogin-%s*" host)
                         (format "*rlogin-%s@%s*" user host))))
-
     (cond ((null buffer))
           ((stringp buffer)
            (setq buffer-name buffer))
@@ -202,32 +195,26 @@ variable."
            (setq buffer-name (format "%s<%d>" buffer-name buffer)))
           (t
            (setq buffer-name (generate-new-buffer-name buffer-name))))
-
     (setq buffer (get-buffer-create buffer-name))
     (pop-to-buffer buffer-name)
-
     (unless (comint-check-proc buffer-name)
       (comint-exec buffer buffer-name rlogin-program nil args)
-
       (rlogin-mode)
-
       (make-local-variable 'rlogin-host)
       (setq rlogin-host host)
       (make-local-variable 'rlogin-remote-user)
       (setq rlogin-remote-user user)
-
-      (condition-case ()
-          (cond ((eq rlogin-directory-tracking-mode t)
-                 ;; Do this here, rather than calling the tracking mode
-                 ;; function, to avoid a gratuitous resync check; the default
-                 ;; should be the user's home directory, be it local or remote.
-                 (setq comint-file-name-prefix
-                       (concat "/" rlogin-remote-user "@" rlogin-host ":"))
-                 (cd-absolute comint-file-name-prefix))
-                ((null rlogin-directory-tracking-mode))
-                (t
-                 (cd-absolute (concat comint-file-name-prefix "~/"))))
-        (error nil)))))
+      (ignore-errors
+        (cond ((eq rlogin-directory-tracking-mode t)
+               ;; Do this here, rather than calling the tracking mode
+               ;; function, to avoid a gratuitous resync check; the default
+               ;; should be the user's home directory, be it local or remote.
+               (setq comint-file-name-prefix
+                     (concat "/" rlogin-remote-user "@" rlogin-host ":"))
+               (cd-absolute comint-file-name-prefix))
+              ((null rlogin-directory-tracking-mode))
+              (t
+               (cd-absolute (concat comint-file-name-prefix "~/"))))))))
 
 (put 'rlogin-mode 'mode-class 'special)
 
@@ -302,8 +289,7 @@ local one share the same directories (e.g. through NFS)."
   (process-send-string nil "\C-\\"))
 
 (defun rlogin-delchar-or-send-Ctrl-D (arg)
-  "\
-Delete ARG characters forward, or send a C-d to process if at end of buffer."
+  "Delete ARG characters forward, or send a C-d to process if at end of buffer."
   (interactive "p")
   (if (eobp)
       (rlogin-send-Ctrl-D)
diff --git a/lisp/play/morse.el b/lisp/play/morse.el
index b88f1b264cb..fa0887c0ac5 100644
--- a/lisp/play/morse.el
+++ b/lisp/play/morse.el
@@ -231,7 +231,7 @@ Geospatial-Intelligence Agency at http://www.nga.mil/")
         (if (null (looking-at "[a-z]+"))
             (forward-char 1)
           (setq str (buffer-substring (match-beginning 0) (match-end 0)))
-          (if (null (setq nato (rassoc str nato-alphabet)))
+          (if (null (setq nato (rassoc (capitalize str) nato-alphabet)))
               (goto-char (match-end 0))
             (replace-match
                   (if (string-equal "(" (car nato))
diff --git a/lisp/replace.el b/lisp/replace.el
index 928c3170c65..0ed716966ed 100644
--- a/lisp/replace.el
+++ b/lisp/replace.el
@@ -772,26 +772,29 @@ a previously found match."
     (define-key map "\C-c\C-f" 'next-error-follow-minor-mode)
     (define-key map [menu-bar] (make-sparse-keymap))
     (define-key map [menu-bar occur]
-      `(cons ,(purecopy "Occur") map))
+      (cons (purecopy "Occur") map))
     (define-key map [next-error-follow-minor-mode]
-      (menu-bar-make-mm-toggle next-error-follow-minor-mode
-                               "Auto Occurrence Display"
-                               "Display another occurrence when moving the cursor"))
+      `(menu-item ,(purecopy "Auto Occurrence Display")
+                  next-error-follow-minor-mode
+                  :help ,(purecopy
+                          "Display another occurrence when moving the cursor")
+                  :button (:toggle . (and (boundp 'next-error-follow-minor-mode)
+                                          next-error-follow-minor-mode))))
     (define-key map [separator-1] menu-bar-separator)
     (define-key map [kill-this-buffer]
-      `(menu-item ,(purecopy "Kill occur buffer") kill-this-buffer
+      `(menu-item ,(purecopy "Kill Occur Buffer") kill-this-buffer
                   :help ,(purecopy "Kill the current *Occur* buffer")))
     (define-key map [quit-window]
-      `(menu-item ,(purecopy "Quit occur window") quit-window
+      `(menu-item ,(purecopy "Quit Occur Window") quit-window
                   :help ,(purecopy "Quit the current *Occur* buffer.  Bury it, and maybe delete the selected frame")))
     (define-key map [revert-buffer]
-      `(menu-item ,(purecopy "Revert occur buffer") revert-buffer
+      `(menu-item ,(purecopy "Revert Occur Buffer") revert-buffer
                   :help ,(purecopy "Replace the text in the *Occur* buffer with the results of rerunning occur")))
     (define-key map [clone-buffer]
-      `(menu-item ,(purecopy "Clone occur buffer") clone-buffer
+      `(menu-item ,(purecopy "Clone Occur Buffer") clone-buffer
                   :help ,(purecopy "Create and return a twin copy of the current *Occur* buffer")))
     (define-key map [occur-rename-buffer]
-      `(menu-item ,(purecopy "Rename occur buffer") occur-rename-buffer
+      `(menu-item ,(purecopy "Rename Occur Buffer") occur-rename-buffer
                   :help ,(purecopy "Rename the current *Occur* buffer to *Occur: original-buffer-name*.")))
     (define-key map [separator-2] menu-bar-separator)
     (define-key map [occur-mode-goto-occurrence-other-window]
@@ -804,10 +807,10 @@ a previously found match."
       `(menu-item ,(purecopy "Display Occurrence") occur-mode-display-occurrence
                   :help ,(purecopy "Display in another window the occurrence the current line describes")))
     (define-key map [occur-next]
-      `(menu-item ,(purecopy "Move to next match") occur-next
+      `(menu-item ,(purecopy "Move to Next Match") occur-next
                   :help ,(purecopy "Move to the Nth (default 1) next match in an Occur mode buffer")))
     (define-key map [occur-prev]
-      `(menu-item ,(purecopy "Move to previous match") occur-prev
+      `(menu-item ,(purecopy "Move to Previous Match") occur-prev
                   :help ,(purecopy "Move to the Nth (default 1) previous match in an Occur mode buffer")))
     map)
   "Keymap for `occur-mode'.")
diff --git a/lisp/saveplace.el b/lisp/saveplace.el
index c10b5cbb7ec..2d1586d895a 100644
--- a/lisp/saveplace.el
+++ b/lisp/saveplace.el
@@ -285,7 +285,7 @@ may have changed\) back to `save-place-alist'."
   (let ((cell (assoc buffer-file-name save-place-alist)))
     (if cell
         (progn
-          (or after-find-file-from-revert-buffer
+          (or revert-buffer-in-progress-p
               (goto-char (cdr cell)))
           ;; and make sure it will be saved again for later
           (setq save-place t)))))
diff --git a/lisp/simple.el b/lisp/simple.el
index a414fc77a39..f0560c48a3b 100644
--- a/lisp/simple.el
+++ b/lisp/simple.el
@@ -2690,7 +2690,95 @@ support pty association, if PROGRAM is nil."
   (let ((fh (find-file-name-handler default-directory 'start-file-process)))
     (if fh (apply fh 'start-file-process name buffer program program-args)
       (apply 'start-process name buffer program program-args))))
-
+
+;;;; Process menu
+
+(defvar tabulated-list-format)
+(defvar tabulated-list-entries)
+(defvar tabulated-list-sort-key)
+(declare-function tabulated-list-init-header  "tabulated-list" ())
+(declare-function tabulated-list-print "tabulated-list" ())
+
+(defvar process-menu-query-only nil)
+
+(define-derived-mode process-menu-mode tabulated-list-mode "Process Menu"
+  "Major mode for listing the processes called by Emacs."
+  (setq tabulated-list-format [("Process" 15 t)
+                               ("Status"   7 t)
+                               ("Buffer"  15 t)
+                               ("TTY"     12 t)
+                               ("Command"  0 t)])
+  (make-local-variable 'process-menu-query-only)
+  (setq tabulated-list-sort-key (cons "Process" nil))
+  (add-hook 'tabulated-list-revert-hook 'list-processes--refresh nil t)
+  (tabulated-list-init-header))
+
+(defun list-processes--refresh ()
+  "Recompute the list of processes for the Process List buffer."
+  (setq tabulated-list-entries nil)
+  (dolist (p (process-list))
+    (when (or (not process-menu-query-only)
+              (process-query-on-exit-flag p))
+      (let* ((buf (process-buffer p))
+             (type (process-type p))
+             (name (process-name p))
+             (status (symbol-name (process-status p)))
+             (buf-label (if (buffer-live-p buf)
+                            `(,(buffer-name buf)
+                              face link
+                              help-echo ,(concat "Visit buffer `"
+                                                 (buffer-name buf) "'")
+                              follow-link t
+                              process-buffer ,buf
+                              action process-menu-visit-buffer)
+                          "--"))
+             (tty (or (process-tty-name p) "--"))
+             (cmd
+              (if (memq type '(network serial))
+                  (let ((contact (process-contact p t)))
+                    (if (eq type 'network)
+                        (format "(%s %s)"
+                                (if (plist-get contact :type)
+                                    "datagram"
+                                  "network")
+                                (if (plist-get contact :server)
+                                    (format "server on %s"
+                                            (plist-get contact :server))
+                                  (format "connection to %s"
+                                          (plist-get contact :host))))
+                      (format "(serial port %s%s)"
+                              (or (plist-get contact :port) "?")
+                              (let ((speed (plist-get contact :speed)))
+                                (if speed
+                                    (format " at %s b/s" speed)
+                                  "")))))
+                (mapconcat 'identity (process-command p) " "))))
+        (push (list p (vector name status buf-label tty cmd))
+              tabulated-list-entries)))))
+
+(defun process-menu-visit-buffer (button)
+  (display-buffer (button-get button 'process-buffer)))
+
+(defun list-processes (&optional query-only buffer)
+  "Display a list of all processes.
+If optional argument QUERY-ONLY is non-nil, only processes with
+the query-on-exit flag set are listed.
+Any process listed as exited or signaled is actually eliminated
+after the listing is made.
+Optional argument BUFFER specifies a buffer to use, instead of
+\"*Process List\".
+The return value is always nil."
+  (interactive)
+  (or (fboundp 'process-list)
+      (error "Asynchronous subprocesses are not supported on this system"))
+  (unless (bufferp buffer)
+    (setq buffer (get-buffer-create "*Process List*")))
+  (with-current-buffer buffer
+    (process-menu-mode)
+    (setq process-menu-query-only query-only)
+    (list-processes--refresh)
+    (tabulated-list-print))
+  (display-buffer buffer))
 
 (defvar universal-argument-map
   (let ((map (make-sparse-keymap)))
diff --git a/lisp/vc/log-edit.el b/lisp/vc/log-edit.el
index 54a2cb4f196..b3f5cfb78f7 100644
--- a/lisp/vc/log-edit.el
+++ b/lisp/vc/log-edit.el
@@ -531,13 +531,25 @@ If you want to abort the commit, simply delete the buffer."
         (shrink-window-if-larger-than-buffer)
         (selected-window)))))
 
+(defun log-edit-empty-buffer-p ()
+  "Return non-nil if the buffer is \"empty\"."
+  (or (= (point-min) (point-max))
+      (save-excursion
+        (goto-char (point-min))
+        (while (and (looking-at "^\\(Summary: \\)?$")
+                    (zerop (forward-line 1))))
+        (eobp))))
+
 (defun log-edit-insert-cvs-template ()
   "Insert the template specified by the CVS administrator, if any.
 This simply uses the local CVS/Template file."
   (interactive)
   (when (or (called-interactively-p 'interactive)
-            (= (point-min) (point-max)))
+            (log-edit-empty-buffer-p))
+    ;; Should the template take precedence over an empty Summary:,
+    ;; ie should we first erase the buffer?
     (when (file-readable-p "CVS/Template")
+      (goto-char (point-max))
       (insert-file-contents "CVS/Template"))))
 
 (defun log-edit-insert-cvs-rcstemplate ()
@@ -546,8 +558,9 @@ This contacts the repository to get the rcstemplate file and
 can thus take some time."
   (interactive)
   (when (or (called-interactively-p 'interactive)
-            (= (point-min) (point-max)))
+            (log-edit-empty-buffer-p))
     (when (file-readable-p "CVS/Root")
+      (goto-char (point-max))
       ;; Ignore the stderr stuff, even if it's an error.
       (call-process "cvs" nil '(t nil) nil
                     "checkout" "-p" "CVSROOT/rcstemplate"))))
diff --git a/lisp/vc/vc-annotate.el b/lisp/vc/vc-annotate.el
index 479dbb5caea..271fce12429 100644
--- a/lisp/vc/vc-annotate.el
+++ b/lisp/vc/vc-annotate.el
@@ -489,7 +489,7 @@ Return a cons (REV . FILENAME)."
   "Visit the log of the revision at line.
 If the VC backend supports it, only show the log entry for the revision.
 If a *vc-change-log* buffer exists and already shows a log for
-the file in question, search for the log entry required and move point ."
+the file in question, search for the log entry required and move point."
   (interactive)
   (if (not (equal major-mode 'vc-annotate-mode))
       (message "Cannot be invoked outside of a vc annotate buffer")