upstream

53 files changed, 1894 insertions, 777 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 87904b8313b..8de59875674 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,13 +1,311 @@
+2012-09-10  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/lisp-mode.el (emacs-list-byte-code-comment-re): New var.
+        (emacs-lisp-byte-code-comment)
+        (emacs-lisp-byte-code-syntax-propertize, emacs-lisp-byte-code-mode):
+        New functions.
+        (eval-sexp-add-defvars): Don't skip defvars in column >0.
+        (eval-defun-2): Remove bogus interactive spec.
+        (lisp-indent-line): Remove redundant whole-exp code, now done in
+        indent-according-to-mode.
+        (save-match-data): Remove redundant indent data.
+
+        * emacs-lisp/benchmark.el (benchmark-run, benchmark-run-compiled):
+        Use `declare'.
+
+2012-09-09  Juri Linkov  <juri@jurta.org>
+
+        * replace.el (replace-regexp-lax-whitespace): New defcustom.
+        (replace-lax-whitespace, query-replace-regexp)
+        (query-replace-regexp-eval, replace-regexp): Doc fix.
+        (perform-replace, replace-highlight): Let-bind
+        isearch-lax-whitespace to replace-lax-whitespace and
+        isearch-regexp-lax-whitespace to replace-regexp-lax-whitespace.
+
+        * isearch.el (isearch-query-replace): Let-bind
+        replace-lax-whitespace to isearch-lax-whitespace and
+        replace-regexp-lax-whitespace to
+        isearch-regexp-lax-whitespace.  (Bug#10885)
+
+2012-09-09  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * eshell/em-unix.el (eshell/sudo): Explicitly drop return value.
+
+2012-09-09  Alan Mackenzie  <acm@muc.de>
+
+        * progmodes/cc-engine.el (c-state-cache-init):
+        Initialise c-state-semi-nonlit-pos-cache\(-limit\)? properly.
+        (c-record-parse-state-state):
+        Record c-state-semi-nonlit-pos-cache\(-limit\)?.
+
+2012-09-09  Andreas Schwab  <schwab@linux-m68k.org>
+
+        * register.el (register-separator): Rename from
+        separator-register.  All uses changed.  Doc fix.
+        (register): Fix version.
+
+2012-09-09  Chong Yidong  <cyd@gnu.org>
+
+        * replace.el (query-replace-map): Bind four new symbols for
+        requesting window scrolling.
+
+        * subr.el (y-or-n-p): Handle the window-scrolling bindings in
+        query-replace-map (Bug#8948).
+
+        * custom.el (custom-theme-load-confirm): Use y-or-n-p.
+
+        * emacs-lisp/map-ynp.el (map-y-or-n-p): Don't bind scrolling keys
+        since they are now in query-replace-map.
+
+        * window.el (scroll-other-window-down): Make the arg optional.
+
+2012-09-09  Chong Yidong  <cyd@gnu.org>
+
+        * files.el (hack-local-variables-confirm): Use quit-window to kill
+        the *Local Variables* buffer.
+
+2012-09-08  Dmitry Gutov  <dgutov@yandex.ru>
+
+        * progmodes/ruby-mode.el (ruby-toggle-block): Guess the current block,
+        not just expect to be at its beginning.  Adjust callees.
+        Succeed when do-end block has no space before the pipe character.
+        (ruby-brace-to-do-end): When the original block is one-liner,
+        convert to multiline.  Reindent the result.
+
+2012-09-08  Jambunathan K  <kjambunathan@gmail.com>
+
+        * register.el (register): New group.
+        (register-separator): New user option.
+        (increment-register): Route it to `append-to-register', if
+        register contains text.  Implication is that `C-x r +' can now be
+        used for appending to a text register (bug#12217).
+        (append-to-register, prepend-to-register): Add separator based on
+        `register-separator.
+
+2012-09-08  Alan Mackenzie  <acm@muc.de>
+
+        AWK Mode: make auto-newline work when there's "==" in the pattern.
+        * progmodes/cc-cmds.el (c-point-syntax): Handle virtual semicolons
+        correctly.
+        * progmodes/cc-engine.el (c-guess-basic-syntax CASE 5A.3):
+        Test more rigorously for "=" token.
+
+2012-09-08  Dmitry Gutov  <dgutov@yandex.ru>
+
+        * progmodes/ruby-mode.el (ruby-match-expression-expansion):
+        Only fail when reached LIMIT.
+
+2012-09-08  Chong Yidong  <cyd@gnu.org>
+
+        * dired.el (dired-mode-map): Don't bind M-=.
+
+        * dired-aux.el (dired-diff): Use backup file as default.
+
+2012-09-08  Drew Adams  <drew.adams@oracle.com>
+
+        * subr.el (add-to-history): Fix delete usage (Bug#12314).
+
+2012-09-08  Chong Yidong  <cyd@gnu.org>
+
+        * subr.el (syntax-after, syntax-class): Doc fix.
+
+2012-09-08  Martin Rudalics  <rudalics@gmx.at>
+
+        * window.el (display-buffer-in-previous-window): New buffer
+        display action function.
+
+        * emacs-lisp/debug.el (debugger-bury-or-kill): New option.
+        (debugger-previous-window): New variable.
+        (debug): Rewrite using display-buffer-in-previous-window,
+        quit-restore-window and debugger-bury-or-kill.  (Bug#8789)
+
+2012-09-07  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/byte-run.el (defun): Tweak message.  Simplify code.
+
+2012-09-07  Matt McClure  <mlm@aya.yale.edu>  (tiny change)
+
+        * progmodes/python.el (python-shell-send-string):
+        When default-directory is remote, create temp file on remote
+        filesystem.
+        (python-shell-send-file): When file is remote, pass local view of
+        file paths to remote Python interpreter.  (Bug#12340)
+
+2012-09-07  Chong Yidong  <cyd@gnu.org>
+
+        * window.el (switch-to-buffer): Doc fix (Bug#12181).
+
+        * files.el (after-find-file): Don't fail on a read-only buffer if
+        require-final-newline is `visit' or `visit-save' (Bug#11156).
+
+        * subr.el (read-char-choice): Allow quitting via ESC ESC.
+
+        * userlock.el (ask-user-about-supersession-threat):
+        Use read-char-choice (Bug#12093).
+
+2012-09-07  Chong Yidong  <cyd@gnu.org>
+
+        * subr.el (buffer-narrowed-p): New function.
+
+        * ses.el (ses-widen):
+        * simple.el (count-words--buffer-message):
+        * net/browse-url.el (browse-url-of-buffer): Use it
+
+        * simple.el (count-words-region): Don't signal an error if there
+        is a non-nil prefix arg and the mark is not set.
+
+        * help.el (describe-key-briefly): Allow the message to be seen
+        when invoked from the minibuffer (Bug#7014).
+
+2012-09-07  Dmitry Gutov  <dgutov@yandex.ru>
+
+        * progmodes/ruby-mode.el (ruby-end-of-defun)
+        (ruby-beginning-of-defun): Simplify, allow indentation before
+        block beginning and end keywords.
+        (ruby-beginning-of-defun): Only consider 3 keywords defun beginners.
+        (ruby-end-of-defun): Expect that the point is at the beginning of
+        the defun.
+
+2012-09-06  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/cl-macs.el (cl--do-arglist): Understand _ on &key args
+        (bug#12367).
+        (cl--make-usage-args): Strip _ from argument names.
+
+2012-09-06  Rüdiger Sonderfeld  <ruediger@c-plusplus.de>
+
+        * progmodes/vhdl-mode.el (vhdl-speedbar-initialize): Don't use
+        obsolete alias speedbar-key-map.
+        (vhdl-doc-variable, vhdl-doc-mode): Use called-interactively-p.
+        (vhdl-index-menu-init): Don't use obsolete variable
+        font-lock-maximum-size.
+
+2012-09-06  Chong Yidong  <cyd@gnu.org>
+
+        * frame.el (window-system-version): Mark as obsolete.
+
+        * speedbar.el (speedbar-update-flag, speedbar-mode): Remove uses
+        of obsolete variable speedbar-key-map.
+
+2012-09-06  Juri Linkov  <juri@jurta.org>
+
+        * replace.el (replace-lax-whitespace): New defcustom.
+        (query-replace, query-replace-regexp, query-replace-regexp-eval)
+        (replace-string, replace-regexp): Mention it in docstrings.
+        (perform-replace, replace-highlight): Let-bind
+        isearch-lax-whitespace and isearch-regexp-lax-whitespace according
+        to the values of replace-lax-whitespace and regexp-flag.
+        Don't let-bind search-whitespace-regexp.  (Bug#10885)
+
+        * isearch.el (isearch-query-replace): Let-bind
+        replace-lax-whitespace instead of let-binding
+        replace-search-function and replace-re-search-function.
+        (isearch-lazy-highlight-search): Let-bind isearch-lax-whitespace
+        and isearch-regexp-lax-whitespace to lazy-highlight variables.
+        (isearch-toggle-symbol): Set isearch-regexp to nil
+        in isearch-word mode (like in isearch-toggle-word).
+
+2012-09-06  Juri Linkov  <juri@jurta.org>
+
+        * replace.el (replace-search-function)
+        (replace-re-search-function): Set default values to nil.
+        (perform-replace): Let-bind isearch-related variables based on
+        replace-related values, call `isearch-search-fun' and let-bind
+        the result to `search-function'.  Remove code that sets
+        `search-function' and `search-string' separately for
+        `delimited-flag'.
+        (replace-highlight): Add new argument `delimited-flag' and
+        rename other arguments to the names used in `perform-replace'.
+        Let-bind `isearch-word' to the argument `delimited-flag'.
+        (Bug#10885, bug#10887)
+
+2012-09-07  Dmitry Gutov  <dgutov@yandex.ru>
+
+        * progmodes/ruby-mode.el (ruby-indent-beg-re): Add pieces from
+        ruby-beginning-of-indent, simplify, allow all keywords to have
+        indentation before them.
+        (ruby-beginning-of-indent): Adjust for above.  Search until the
+        found point is not inside a string or comment.
+        (ruby-font-lock-keywords): Allow symbols to start with "@"
+        character, give them higher priority than variables.
+        (ruby-syntax-propertize-function)
+        (ruby-font-lock-syntactic-keywords): Remove the "not comments"
+        matchers.  Expression expansions are not comments when inside a
+        string, and there comment syntax status is irrelevant.
+        (ruby-match-expression-expansion): New function.  Check that
+        expression expansion is inside a string, and it's not escaped.
+        (ruby-font-lock-keywords): Use it.
+
+2012-09-05  Martin Rudalics  <rudalics@gmx.at>
+
+        * help.el (temp-buffer-max-height): New default value.
+        (temp-buffer-resize-frames): New option.
+        (resize-temp-buffer-window): Optionally resize frame.
+
+        * window.el (fit-frame-to-buffer-bottom-margin): New option.
+        (fit-frame-to-buffer): New function.
+
+2012-09-05  Glenn Morris  <rgm@gnu.org>
+
+        * emulation/cua-rect.el (cua--init-rectangles):
+        * textmodes/picture.el (picture-mode-map):
+        * play/blackbox.el (blackbox-mode-map): Remap right-char and left-char
+        like forward-char and backward-char.  (Bug#12317)
+
+2012-09-05  Leo Liu  <sdl.web@gmail.com>
+
+        * progmodes/flymake.el (flymake-warning-re): New variable.
+        (flymake-parse-line): Use it.
+
+2012-09-05  Glenn Morris  <rgm@gnu.org>
+
+        * calendar/holidays.el (holiday-christian-holidays):
+        Rename an entry.  (Bug#12289)
+
+2012-09-05  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * progmodes/sh-script.el (sh-font-lock-paren): Don't burp at BOB
+        (bug#12222).
+
+2012-09-04  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * loadup.el: Load macroexp.  Remove hack.
+        * emacs-lisp/macroexp.el (macroexp--eval-if-compile): New function.
+        (macroexp--expand-all): Use it to get better warnings.
+        (macroexp--backtrace, macroexp--trim-backtrace-frame)
+        (internal-macroexpand-for-load): New functions.
+        (macroexp--pending-eager-loads): New var.
+        (emacs-startup-hook): New hack to replace one in loadup.el.
+        * emacs-lisp/cl-macs.el (cl--compiler-macro-list*)
+        (cl--compiler-macro-cXXr): Move to top, before they can be used.
+        (cl-psetf): Simplify.
+        (cl-defstruct): Add indent rule.
+
+2012-09-04  Lars Ingebrigtsen  <larsi@gnus.org>
+
+        * mail/smtpmail.el (smtpmail-send-it): Prefer the From: header
+        over `user-mail-address' for the SMTP MAIL FROM envelope.
+        (smtpmail-via-smtp): Ditto.
+
+2012-09-04  Dmitry Gutov  <dgutov@yandex.ru>
+
+        * progmodes/ruby-mode.el: Clean up keybindings.
+        (ruby-mode-map): Don't bind ruby-electric-brace,
+        ruby-beginning-of-defun, ruby-end-of-defun, ruby-mark-defun,
+        backward-kill-word, reindent-then-newline-and-indent.
+        (ruby-mark-defun): Remove.
+        (ruby-electric-brace): Remove.  Obsoleted by electric-indent-chars.
+        (ruby-mode): Set local beginning-of-defun-function and
+        end-of-defun-function values.
+
 2012-09-03  Martin Rudalics  <rudalics@gmx.at>
 
         * window.el (temp-buffer-window-setup-hook)
         (temp-buffer-window-show-hook): New hooks.
         (temp-buffer-window-setup, temp-buffer-window-show)
         (with-temp-buffer-window): New functions.
-        (fit-window-to-buffer): Remove unused optional argument
-        OVERRIDE.
-        (special-display-popup-frame): Make sure the window used shows
-        BUFFER.
+        (fit-window-to-buffer): Remove unused optional argument OVERRIDE.
+        (special-display-popup-frame): Make sure the window used shows BUFFER.
 
         * help.el (temp-buffer-resize-mode): Fix doc-string.
         (resize-temp-buffer-window): New optional argument WINDOW.
@@ -149,8 +447,8 @@
 2012-08-29  Michael Albinus  <michael.albinus@gmx.de>
 
         * eshell/esh-ext.el (eshell-external-command): Do not examine
-        remote shell scripts.  See
-        <https://bugs.launchpad.net/ubuntu/+source/emacs23/+bug/1035790>.
+        remote shell scripts.
+        See <https://bugs.launchpad.net/ubuntu/+source/emacs23/+bug/1035790>.
 
         * net/tramp-sh.el (tramp-remote-path): Add "/sbin" and
         "/usr/local/sbin".
diff --git a/lisp/calendar/holidays.el b/lisp/calendar/holidays.el
index 043d402f612..9643a1e2905 100644
--- a/lisp/calendar/holidays.el
+++ b/lisp/calendar/holidays.el
@@ -250,7 +250,7 @@ See the documentation for `calendar-holidays' for details."
     (if calendar-christian-all-holidays-flag
         (append
          (holiday-fixed 1 6 "Epiphany")
-         (holiday-julian 12 25 "Eastern Orthodox Christmas")
+         (holiday-julian 12 25 "Christmas (Julian calendar)")
          (holiday-greek-orthodox-easter)
          (holiday-fixed 8 15 "Assumption")
          (holiday-advent 0 "Advent")))))
diff --git a/lisp/custom.el b/lisp/custom.el
index fb166dd35f7..3eb2895888d 100644
--- a/lisp/custom.el
+++ b/lisp/custom.el
@@ -1223,38 +1223,19 @@ Return t if THEME was successfully loaded, nil otherwise."
   "Query the user about loading a Custom theme that may not be safe.
 The theme should be in the current buffer.  If the user agrees,
 query also about adding HASH to `custom-safe-themes'."
-  (if noninteractive
-      nil
-    (let ((exit-chars '(?y ?n ?\s))
-          window prompt char)
-      (save-window-excursion
-        (rename-buffer "*Custom Theme*" t)
-        (emacs-lisp-mode)
-        (setq window (display-buffer (current-buffer)))
-        (setq prompt
-              (format "Loading a theme can run Lisp code.  Really load?%s"
-                      (if (and window
-                               (< (line-number-at-pos (point-max))
-                                  (window-body-height)))
-                          " (y or n) "
-                        (push ?\C-v exit-chars)
-                        "\nType y or n, or C-v to scroll: ")))
-        (goto-char (point-min))
-        (while (null char)
-          (setq char (read-char-choice prompt exit-chars))
-          (when (eq char ?\C-v)
-            (if window
-                (with-selected-window window
-                  (condition-case nil
-                      (scroll-up)
-                    (error (goto-char (point-min))))))
-            (setq char nil)))
-        (when (memq char '(?\s ?y))
-          ;; Offer to save to `custom-safe-themes'.
-          (and (or custom-file user-init-file)
-               (y-or-n-p "Treat this theme as safe in future sessions? ")
-               (customize-push-and-save 'custom-safe-themes (list hash)))
-          t)))))
+  (unless noninteractive
+    (save-window-excursion
+      (rename-buffer "*Custom Theme*" t)
+      (emacs-lisp-mode)
+      (setq window (pop-to-buffer (current-buffer)))
+      (goto-char (point-min))
+      (prog1 (when (y-or-n-p "Loading a theme can run Lisp code.  Really load? ")
+               ;; Offer to save to `custom-safe-themes'.
+               (and (or custom-file user-init-file)
+                    (y-or-n-p "Treat this theme as safe in future sessions? ")
+                    (customize-push-and-save 'custom-safe-themes (list hash)))
+               t)
+        (quit-window)))))
 
 (defun custom-theme-name-valid-p (name)
   "Return t if NAME is a valid name for a Custom theme, nil otherwise.
diff --git a/lisp/dired-aux.el b/lisp/dired-aux.el
index 6186f762e0a..1f8e8068de3 100644
--- a/lisp/dired-aux.el
+++ b/lisp/dired-aux.el
@@ -54,43 +54,30 @@ into this list; they also should call `dired-log' to log the errors.")
 ;;;###autoload
 (defun dired-diff (file &optional switches)
   "Compare file at point with file FILE using `diff'.
-FILE defaults to the file at the mark.  (That's the mark set by
-\\[set-mark-command], not by Dired's \\[dired-mark] command.)
-The prompted-for FILE is the first file given to `diff'.
+If called interactively, prompt for FILE; if the file at point
+has a backup file, use that as the default.
+
+FILE is the first file given to `diff'.
 With prefix arg, prompt for second argument SWITCHES,
 which is the string of command switches for `diff'."
   (interactive
    (let* ((current (dired-get-filename t))
-          ;; Get the file at the mark.
-          (file-at-mark (if (mark t)
-                            (save-excursion (goto-char (mark t))
-                                            (dired-get-filename t t))))
-          ;; Use it as default if it's not the same as the current file,
-          ;; and the target dir is the current dir or the mark is active.
-          (default (if (and (not (equal file-at-mark current))
-                            (or (equal (dired-dwim-target-directory)
-                                       (dired-current-directory))
-                                mark-active))
-                       file-at-mark))
-          (target-dir (if default
-                          (dired-current-directory)
-                        (dired-dwim-target-directory)))
-          (defaults (dired-dwim-target-defaults (list current) target-dir)))
-     (require 'diff)
-     (list
-      (minibuffer-with-setup-hook
-          (lambda ()
-            (set (make-local-variable 'minibuffer-default-add-function) nil)
-            (setq minibuffer-default defaults))
-        (read-file-name
-         (format "Diff %s with%s: " current
-                 (if default (format " (default %s)" default) ""))
-         target-dir default t))
-      (if current-prefix-arg
-          (read-string "Options for diff: "
-                       (if (stringp diff-switches)
-                           diff-switches
-                         (mapconcat 'identity diff-switches " ")))))))
+          (oldf (file-newest-backup current))
+          (dir (if oldf (file-name-directory oldf))))
+     (list (read-file-name
+            (format "Diff %s with%s: "
+                    (file-name-nondirectory current)
+                    (if oldf
+                        (concat " (default "
+                                (file-name-nondirectory oldf)
+                                ")")
+                      ""))
+            dir oldf t)
+           (if current-prefix-arg
+               (read-string "Options for diff: "
+                            (if (stringp diff-switches)
+                                diff-switches
+                              (mapconcat 'identity diff-switches " ")))))))
   (let ((current (dired-get-filename t)))
     (when (or (equal (expand-file-name file)
                      (expand-file-name current))
diff --git a/lisp/dired.el b/lisp/dired.el
index cd27b6b6404..f4ae027181a 100644
--- a/lisp/dired.el
+++ b/lisp/dired.el
@@ -1410,7 +1410,6 @@ Do so according to the former subdir alist OLD-SUBDIR-ALIST."
     (define-key map "&" 'dired-do-async-shell-command)
     ;; Comparison commands
     (define-key map "=" 'dired-diff)
-    (define-key map "\M-=" 'dired-backup-diff)
     ;; Tree Dired commands
     (define-key map "\M-\C-?" 'dired-unmark-all-files)
     (define-key map "\M-\C-d" 'dired-tree-down)
@@ -3745,14 +3744,15 @@ Ask means pop up a menu for the user to select one of copy, move or link."
 ;;;;;;  dired-run-shell-command dired-do-shell-command dired-do-async-shell-command
 ;;;;;;  dired-clean-directory dired-do-print dired-do-touch dired-do-chown
 ;;;;;;  dired-do-chgrp dired-do-chmod dired-compare-directories dired-backup-diff
-;;;;;;  dired-diff) "dired-aux" "dired-aux.el" "9499f79f5853da0aa93d26465c7bf3a1")
+;;;;;;  dired-diff) "dired-aux" "dired-aux.el" "4b260eda371d319a6c8e8e5ec917e287")
 ;;; Generated autoloads from dired-aux.el
 
 (autoload 'dired-diff "dired-aux" "\
 Compare file at point with file FILE using `diff'.
-FILE defaults to the file at the mark.  (That's the mark set by
-\\[set-mark-command], not by Dired's \\[dired-mark] command.)
-The prompted-for FILE is the first file given to `diff'.
+If called interactively, prompt for FILE; if the file at point
+has a backup file, use that as the default.
+
+FILE is the first file given to `diff'.
 With prefix arg, prompt for second argument SWITCHES,
 which is the string of command switches for `diff'.
 
diff --git a/lisp/emacs-lisp/benchmark.el b/lisp/emacs-lisp/benchmark.el
index 646be3e1b71..9029c81f279 100644
--- a/lisp/emacs-lisp/benchmark.el
+++ b/lisp/emacs-lisp/benchmark.el
@@ -53,6 +53,7 @@ FORMS once.
 Return a list of the total elapsed time for execution, the number of
 garbage collections that ran, and the time taken by garbage collection.
 See also `benchmark-run-compiled'."
+  (declare (indent 1) (debug t))
   (unless (natnump repetitions)
     (setq forms (cons repetitions forms)
           repetitions 1))
@@ -69,8 +70,6 @@ See also `benchmark-run-compiled'."
                 `(benchmark-elapse ,@forms))
              (- gcs-done ,gcs)
              (- gc-elapsed ,gc)))))
-(put 'benchmark-run 'edebug-form-spec t)
-(put 'benchmark-run 'lisp-indent-function 2)
 
 ;;;###autoload
 (defmacro benchmark-run-compiled (&optional repetitions &rest forms)
@@ -78,6 +77,7 @@ See also `benchmark-run-compiled'."
 This is like `benchmark-run', but what is timed is a funcall of the
 byte code obtained by wrapping FORMS in a `lambda' and compiling the
 result.  The overhead of the `lambda's is accounted for."
+  (declare (indent 1) (debug t))
   (unless (natnump repetitions)
     (setq forms (cons repetitions forms)
           repetitions 1))
@@ -96,8 +96,6 @@ result.  The overhead of the `lambda's is accounted for."
                                           (funcall ,lambda-code))))
                 `(benchmark-elapse (funcall ,code)))
              (- gcs-done ,gcs) (- gc-elapsed ,gc)))))
-(put 'benchmark-run-compiled 'edebug-form-spec t)
-(put 'benchmark-run-compiled 'lisp-indent-function 2)
 
 ;;;###autoload
 (defun benchmark (repetitions form)
diff --git a/lisp/emacs-lisp/byte-run.el b/lisp/emacs-lisp/byte-run.el
index 9b66c8ffd60..d1382f42b19 100644
--- a/lisp/emacs-lisp/byte-run.el
+++ b/lisp/emacs-lisp/byte-run.el
@@ -185,11 +185,10 @@ The return value is undefined.
                    ((and (featurep 'cl)
                          (memq (car x)  ;C.f. cl-do-proclaim.
                                '(special inline notinline optimize warn)))
-                    (if (null (stringp docstring))
-                        (push (list 'declare x) body)
-                      (setcdr body (cons (list 'declare x) (cdr body))))
+                    (push (list 'declare x)
+                          (if (stringp docstring) (cdr body) body))
                     nil)
-                   (t (message "Warning: Unknown defun property %S in %S"
+                   (t (message "Warning: Unknown defun property `%S' in %S"
                                (car x) name)))))
                    decls))
           (def (list 'defalias
diff --git a/lisp/emacs-lisp/cl-loaddefs.el b/lisp/emacs-lisp/cl-loaddefs.el
index d4da1f59a85..f2bc7cc9d3c 100644
--- a/lisp/emacs-lisp/cl-loaddefs.el
+++ b/lisp/emacs-lisp/cl-loaddefs.el
@@ -249,8 +249,7 @@ Remove from SYMBOL's plist the property PROPNAME and its value.
 
 ;;;***
 
-;;;### (autoloads (cl--compiler-macro-cXXr cl--compiler-macro-list*
-;;;;;;  cl--compiler-macro-adjoin cl-defsubst cl-compiler-macroexpand
+;;;### (autoloads (cl--compiler-macro-adjoin cl-defsubst cl-compiler-macroexpand
 ;;;;;;  cl-define-compiler-macro cl-assert cl-check-type cl-typep
 ;;;;;;  cl-deftype cl-defstruct cl-callf2 cl-callf cl-letf* cl-letf
 ;;;;;;  cl-rotatef cl-shiftf cl-remf cl-psetf cl-declare cl-the cl-locally
@@ -260,9 +259,20 @@ Remove from SYMBOL's plist the property PROPNAME and its value.
 ;;;;;;  cl-do cl-loop cl-return-from cl-return cl-block cl-etypecase
 ;;;;;;  cl-typecase cl-ecase cl-case cl-load-time-value cl-eval-when
 ;;;;;;  cl-destructuring-bind cl-function cl-defmacro cl-defun cl-gentemp
-;;;;;;  cl-gensym) "cl-macs" "cl-macs.el" "a1ca04b3f2acc7c9b06f45ef5486d443")
+;;;;;;  cl-gensym cl--compiler-macro-cXXr cl--compiler-macro-list*)
+;;;;;;  "cl-macs" "cl-macs.el" "00526d56a1062b9c308cf37b59374f2b")
 ;;; Generated autoloads from cl-macs.el
 
+(autoload 'cl--compiler-macro-list* "cl-macs" "\
+
+
+\(fn FORM ARG &rest OTHERS)" nil nil)
+
+(autoload 'cl--compiler-macro-cXXr "cl-macs" "\
+
+
+\(fn FORM X)" nil nil)
+
 (autoload 'cl-gensym "cl-macs" "\
 Generate a new uninterned symbol.
 The name is made by appending a number to PREFIX, default \"G\".
@@ -659,6 +669,8 @@ value, that slot cannot be set via `setf'.
 
 (put 'cl-defstruct 'doc-string-elt '2)
 
+(put 'cl-defstruct 'lisp-indent-function '1)
+
 (autoload 'cl-deftype "cl-macs" "\
 Define NAME as a new data type.
 The type name can then be used in `cl-typecase', `cl-check-type', etc.
@@ -722,16 +734,6 @@ surrounded by (cl-block NAME ...).
 
 \(fn FORM A LIST &rest KEYS)" nil nil)
 
-(autoload 'cl--compiler-macro-list* "cl-macs" "\
-
-
-\(fn FORM ARG &rest OTHERS)" nil nil)
-
-(autoload 'cl--compiler-macro-cXXr "cl-macs" "\
-
-
-\(fn FORM X)" nil nil)
-
 ;;;***
 
 ;;;### (autoloads (cl-tree-equal cl-nsublis cl-sublis cl-nsubst-if-not
diff --git a/lisp/emacs-lisp/cl-macs.el b/lisp/emacs-lisp/cl-macs.el
index 81a451dbbb4..e385a80c1f3 100644
--- a/lisp/emacs-lisp/cl-macs.el
+++ b/lisp/emacs-lisp/cl-macs.el
@@ -58,6 +58,33 @@
 
 ;;; Initialization.
 
+;; Place compiler macros at the beginning, otherwise uses of the corresponding
+;; functions can lead to recursive-loads that prevent the calls from
+;; being optimized.
+
+;;;###autoload
+(defun cl--compiler-macro-list* (_form arg &rest others)
+  (let* ((args (reverse (cons arg others)))
+         (form (car args)))
+    (while (setq args (cdr args))
+      (setq form `(cons ,(car args) ,form)))
+    form))
+
+;;;###autoload
+(defun cl--compiler-macro-cXXr (form x)
+  (let* ((head (car form))
+         (n (symbol-name (car form)))
+         (i (- (length n) 2)))
+    (if (not (string-match "c[ad]+r\\'" n))
+        (if (and (fboundp head) (symbolp (symbol-function head)))
+            (cl--compiler-macro-cXXr (cons (symbol-function head) (cdr form))
+                                     x)
+          (error "Compiler macro for cXXr applied to non-cXXr form"))
+      (while (> i (match-beginning 0))
+        (setq x (list (if (eq (aref n i) ?a) 'car 'cdr) x))
+        (setq i (1- i)))
+      x)))
+
 ;;; Some predicates for analyzing Lisp forms.
 ;; These are used by various
 ;; macro expanders to optimize the results in certain common cases.
@@ -366,9 +393,14 @@ its argument list allows full Common Lisp conventions."
       (mapcar (lambda (x)
                 (cond
                  ((symbolp x)
-                  (if (eq ?\& (aref (symbol-name x) 0))
-                      (setq state x)
-                    (make-symbol (upcase (symbol-name x)))))
+                  (let ((first (aref (symbol-name x) 0)))
+                    (if (eq ?\& first)
+                        (setq state x)
+                      ;; Strip a leading underscore, since it only
+                      ;; means that this argument is unused.
+                      (make-symbol (upcase (if (eq ?_ first)
+                                               (substring (symbol-name x) 1)
+                                             (symbol-name x)))))))
                  ((not (consp x)) x)
                  ((memq state '(nil &rest)) (cl--make-usage-args x))
                  (t      ;(VAR INITFORM SVAR) or ((KEYWORD VAR) INITFORM SVAR).
@@ -452,7 +484,13 @@ its argument list allows full Common Lisp conventions."
           (let ((arg (pop args)))
             (or (consp arg) (setq arg (list arg)))
             (let* ((karg (if (consp (car arg)) (caar arg)
-                           (intern (format ":%s" (car arg)))))
+                           (let ((name (symbol-name (car arg))))
+                             ;; Strip a leading underscore, since it only
+                             ;; means that this argument is unused, but
+                             ;; shouldn't affect the key's name (bug#12367).
+                             (if (eq ?_ (aref name 0))
+                                 (setq name (substring name 1)))
+                             (intern (format ":%s" name)))))
                    (varg (if (consp (car arg)) (cl-cadar arg) (car arg)))
                    (def (if (cdr arg) (cadr arg)
                           (or (car cl--bind-defs) (cadr (assq varg cl--bind-defs)))))
@@ -1425,8 +1463,15 @@ Valid clauses are:
           cl--loop-accum-var))))
 
 (defun cl--loop-build-ands (clauses)
+  "Return various representations of (and . CLAUSES).
+CLAUSES is a list of Elisp expressions, where clauses of the form
+\(progn E1 E2 E3 .. t) are the focus of particular optimizations.
+The return value has shape (COND BODY COMBO)
+such that COMBO is equivalent to (and . CLAUSES)."
   (let ((ands nil)
         (body nil))
+    ;; Look through `clauses', trying to optimize (progn ,@A t) (progn ,@B) ,@C
+    ;; into (progn ,@A ,@B) ,@C.
     (while clauses
       (if (and (eq (car-safe (car clauses)) 'progn)
                (eq (car (last (car clauses))) t))
@@ -1437,6 +1482,7 @@ Valid clauses are:
                                              (cl-cdadr clauses)
                                            (list (cadr clauses))))
                                   (cddr clauses)))
+            ;; A final (progn ,@A t) is moved outside of the `and'.
             (setq body (cdr (butlast (pop clauses)))))
         (push (pop clauses) ands)))
     (setq ands (or (nreverse ands) (list t)))
@@ -1905,8 +1951,6 @@ See Info node `(cl)Declarations' for details."
         (cl-do-proclaim (pop specs) nil)))
   nil)
 
-
-
 ;;; The standard modify macros.
 
 ;; `setf' is now part of core Elisp, defined in gv.el.
@@ -1929,7 +1973,7 @@ before assigning any PLACEs to the corresponding values.
       (or p (error "Odd number of arguments to cl-psetf"))
       (pop p))
     (if simple
-        `(progn (setf ,@args) nil)
+        `(progn (setq ,@args) nil)
       (setq args (reverse args))
       (let ((expr `(setf ,(cadr args) ,(car args))))
         (while (setq args (cddr args))
@@ -2119,7 +2163,7 @@ one keyword is supported, `:read-only'.  If this has a non-nil
 value, that slot cannot be set via `setf'.
 
 \(fn NAME SLOTS...)"
-  (declare (doc-string 2)
+  (declare (doc-string 2) (indent 1)
            (debug
             (&define                    ;Makes top-level form not be wrapped.
              [&or symbolp
@@ -2597,14 +2641,6 @@ surrounded by (cl-block NAME ...).
       `(if (cl-member ,a ,list ,@keys) ,list (cons ,a ,list))
     form))
 
-;;;###autoload
-(defun cl--compiler-macro-list* (_form arg &rest others)
-  (let* ((args (reverse (cons arg others)))
-         (form (car args)))
-    (while (setq args (cdr args))
-      (setq form `(cons ,(car args) ,form)))
-    form))
-
 (defun cl--compiler-macro-get (_form sym prop &optional def)
   (if def
       `(cl-getf (symbol-plist ,sym) ,prop ,def)
@@ -2616,21 +2652,6 @@ surrounded by (cl-block NAME ...).
         (cl--make-type-test temp (cl--const-expr-val type)))
     form))
 
-;;;###autoload
-(defun cl--compiler-macro-cXXr (form x)
-  (let* ((head (car form))
-         (n (symbol-name (car form)))
-         (i (- (length n) 2)))
-    (if (not (string-match "c[ad]+r\\'" n))
-        (if (and (fboundp head) (symbolp (symbol-function head)))
-            (cl--compiler-macro-cXXr (cons (symbol-function head) (cdr form))
-                                     x)
-          (error "Compiler macro for cXXr applied to non-cXXr form"))
-      (while (> i (match-beginning 0))
-        (setq x (list (if (eq (aref n i) ?a) 'car 'cdr) x))
-        (setq i (1- i)))
-      x)))
-
 (dolist (y '(cl-first cl-second cl-third cl-fourth
              cl-fifth cl-sixth cl-seventh
              cl-eighth cl-ninth cl-tenth
diff --git a/lisp/emacs-lisp/debug.el b/lisp/emacs-lisp/debug.el
index 7bc93a19d1a..188c0800eb8 100644
--- a/lisp/emacs-lisp/debug.el
+++ b/lisp/emacs-lisp/debug.el
@@ -48,6 +48,39 @@ the middle is discarded, and just the beginning and end are displayed."
   :group 'debugger
   :version "21.1")
 
+(defcustom debugger-bury-or-kill 'bury
+  "How to proceed with the debugger buffer when exiting `debug'.
+The value used here affects the behavior of operations on any
+window previously showing the debugger buffer.
+
+`nil' means that if its window is not deleted when exiting the
+  debugger, invoking `switch-to-prev-buffer' will usually show
+  the debugger buffer again.
+
+`append' means that if the window is not deleted, the debugger
+  buffer moves to the end of the window's previous buffers so
+  it's less likely that a future invocation of
+  `switch-to-prev-buffer' will switch to it.  Also, it moves the
+  buffer to the end of the frame's buffer list.
+
+`bury' means that if the window is not deleted, its buffer is
+  removed from the window's list of previous buffers.  Also, it
+  moves the buffer to the end of the frame's buffer list.  This
+  value provides the most reliable remedy to not have
+  `switch-to-prev-buffer' switch to the debugger buffer again
+  without killing the buffer.
+
+`kill' means to kill the debugger buffer.
+
+The value used here is passed to `quit-restore-window'."
+  :type '(choice
+          (const :tag "Keep alive" nil)
+          (const :tag "Append" 'append)
+          (const :tag "Bury" 'bury)
+          (const :tag "Kill" 'kill))
+  :group 'debugger
+  :version "24.2")
+
 (defvar debug-function-list nil
   "List of functions currently set for debug on entry.")
 
@@ -60,6 +93,9 @@ the middle is discarded, and just the beginning and end are displayed."
 (defvar debugger-old-buffer nil
   "This is the buffer that was current when the debugger was entered.")
 
+(defvar debugger-previous-window nil
+  "This is the window last showing the debugger buffer.")
+
 (defvar debugger-previous-backtrace nil
   "The contents of the previous backtrace (including text properties).
 This is to optimize `debugger-make-xrefs'.")
@@ -133,7 +169,7 @@ first will be printed into the backtrace buffer."
                (with-current-buffer (get-buffer "*Backtrace*")
                  (list major-mode (buffer-string)))))
           (debugger-buffer (get-buffer-create "*Backtrace*"))
-          (debugger-old-buffer (current-buffer))
+          (debugger-window nil)
           (debugger-step-after-exit nil)
           (debugger-will-be-back nil)
           ;; Don't keep reading from an executing kbd macro!
@@ -184,78 +220,63 @@ first will be printed into the backtrace buffer."
             (cursor-in-echo-area nil))
         (unwind-protect
             (save-excursion
-              (save-window-excursion
-                (with-no-warnings
-                  (setq unread-command-char -1))
-                (when (eq (car debugger-args) 'debug)
-                  ;; Skip the frames for backtrace-debug, byte-code,
-                  ;; and implement-debug-on-entry.
-                  (backtrace-debug 4 t)
-                  ;; Place an extra debug-on-exit for macro's.
-                  (when (eq 'lambda (car-safe (cadr (backtrace-frame 4))))
-                    (backtrace-debug 5 t)))
-                (pop-to-buffer debugger-buffer)
-                (debugger-mode)
-                (debugger-setup-buffer debugger-args)
-                (when noninteractive
-                  ;; If the backtrace is long, save the beginning
-                  ;; and the end, but discard the middle.
-                  (when (> (count-lines (point-min) (point-max))
-                           debugger-batch-max-lines)
-                    (goto-char (point-min))
-                    (forward-line (/ 2 debugger-batch-max-lines))
-                    (let ((middlestart (point)))
-                      (goto-char (point-max))
-                      (forward-line (- (/ 2 debugger-batch-max-lines)
-                                       debugger-batch-max-lines))
-                      (delete-region middlestart (point)))
-                    (insert "...\n"))
+              (with-no-warnings
+                (setq unread-command-char -1))
+              (when (eq (car debugger-args) 'debug)
+                ;; Skip the frames for backtrace-debug, byte-code,
+                ;; and implement-debug-on-entry.
+                (backtrace-debug 4 t)
+                ;; Place an extra debug-on-exit for macro's.
+                (when (eq 'lambda (car-safe (cadr (backtrace-frame 4))))
+                  (backtrace-debug 5 t)))
+              (pop-to-buffer
+               debugger-buffer
+               `((display-buffer-reuse-window
+                  display-buffer-in-previous-window)
+                  . (,(when debugger-previous-window
+                        `(previous-window . ,debugger-previous-window)))))
+              (setq debugger-window (selected-window))
+              (setq debugger-previous-window debugger-window)
+              (debugger-mode)
+              (debugger-setup-buffer debugger-args)
+              (when noninteractive
+                ;; If the backtrace is long, save the beginning
+                ;; and the end, but discard the middle.
+                (when (> (count-lines (point-min) (point-max))
+                         debugger-batch-max-lines)
                   (goto-char (point-min))
-                  (message "%s" (buffer-string))
-                  (kill-emacs -1))
+                  (forward-line (/ 2 debugger-batch-max-lines))
+                  (let ((middlestart (point)))
+                    (goto-char (point-max))
+                    (forward-line (- (/ 2 debugger-batch-max-lines)
+                                     debugger-batch-max-lines))
+                    (delete-region middlestart (point)))
+                  (insert "...\n"))
+                (goto-char (point-min))
+                (message "%s" (buffer-string))
+                (kill-emacs -1))
+              (message "")
+              (let ((standard-output nil)
+                    (buffer-read-only t))
                 (message "")
-                (let ((standard-output nil)
-                      (buffer-read-only t))
-                  (message "")
-                  ;; Make sure we unbind buffer-read-only in the right buffer.
-                  (save-excursion
-                    (recursive-edit)))))
-          ;; Kill or at least neuter the backtrace buffer, so that users
-          ;; don't try to execute debugger commands in an invalid context.
-          (if (get-buffer-window debugger-buffer 0)
-              ;; Still visible despite the save-window-excursion?  Maybe it
-              ;; it's in a pop-up frame.  It would be annoying to delete and
-              ;; recreate it every time the debugger stops, so instead we'll
-              ;; erase it (and maybe hide it) but keep it alive.
-              (with-current-buffer debugger-buffer
-                (with-selected-window (get-buffer-window debugger-buffer 0)
-                  (when (and (window-dedicated-p (selected-window))
-                             (not debugger-will-be-back))
-                    ;; If the window is not dedicated, burying the buffer
-                    ;; will mean that the frame created for it is left
-                    ;; around showing some random buffer, and next time we
-                    ;; pop to the debugger buffer we'll create yet
-                    ;; another frame.
-                    ;; If debugger-will-be-back is non-nil, the frame
-                    ;; would need to be de-iconified anyway immediately
-                    ;; after when we re-enter the debugger, so iconifying it
-                    ;; here would cause flashing.
-                    ;; Drew Adams is not happy with this: he wants to frame
-                    ;; to be left at the top-level, still working on how
-                    ;; best to do that.
-                    (bury-buffer))))
-            (unless debugger-previous-state
-              (kill-buffer debugger-buffer)))
-          ;; Restore the previous state of the debugger-buffer, in case we were
-          ;; in a recursive invocation of the debugger.
-          (when (buffer-live-p debugger-buffer)
-            (with-current-buffer debugger-buffer
-              (let ((inhibit-read-only t))
-                (erase-buffer)
-                (if (null debugger-previous-state)
-                    (fundamental-mode)
-                  (insert (nth 1 debugger-previous-state))
-                  (funcall (nth 0 debugger-previous-state))))))
+                ;; Make sure we unbind buffer-read-only in the right buffer.
+                (save-excursion
+                  (recursive-edit))))
+          (when (and (window-live-p debugger-window)
+                     (eq (window-buffer debugger-window) debugger-buffer))
+            ;; Unshow debugger-buffer.
+            (quit-restore-window debugger-window debugger-bury-or-kill))
+          ;; Restore previous state of debugger-buffer in case we were
+          ;; in a recursive invocation of the debugger, otherwise just
+          ;; erase the buffer and put it into fundamental mode.
+          (when (buffer-live-p debugger-buffer)
+            (with-current-buffer debugger-buffer
+              (let ((inhibit-read-only t))
+                (erase-buffer)
+                (if (null debugger-previous-state)
+                    (fundamental-mode)
+                  (insert (nth 1 debugger-previous-state))
+                  (funcall (nth 0 debugger-previous-state))))))
           (with-timeout-unsuspend debugger-with-timeout-suspend)
           (set-match-data debugger-outer-match-data)))
       ;; Put into effect the modified values of these variables
diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index 666e31f690f..64aac4b81db 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -431,6 +431,61 @@ if that value is non-nil."
   (add-hook 'completion-at-point-functions
             'lisp-completion-at-point nil 'local))
 
+;;; Emacs Lisp Byte-Code mode
+
+(eval-and-compile
+  (defconst emacs-list-byte-code-comment-re
+    (concat "\\(#\\)@\\([0-9]+\\) "
+            ;; Make sure it's a docstring and not a lazy-loaded byte-code.
+            "\\(?:[^(]\\|([^\"]\\)")))
+
+(defun emacs-lisp-byte-code-comment (end &optional _point)
+  "Try to syntactically mark the #@NNN ....^_ docstrings in byte-code files."
+  (let ((ppss (syntax-ppss)))
+    (when (and (nth 4 ppss)
+               (eq (char-after (nth 8 ppss)) ?#))
+      (let* ((n (save-excursion
+                  (goto-char (nth 8 ppss))
+                  (when (looking-at emacs-list-byte-code-comment-re)
+                    (string-to-number (match-string 2)))))
+             ;; `maxdiff' tries to make sure the loop below terminates.
+             (maxdiff n))
+        (when n
+          (let* ((bchar (match-end 2))
+                 (b (position-bytes bchar)))
+            (goto-char (+ b n))
+            (while (let ((diff (- (position-bytes (point)) b n)))
+                     (unless (zerop diff)
+                       (when (> diff maxdiff) (setq diff maxdiff))
+                       (forward-char (- diff))
+                       (setq maxdiff (if (> diff 0) diff
+                                       (max (1- maxdiff) 1)))
+                       t))))
+          (if (<= (point) end)
+              (put-text-property (1- (point)) (point)
+                                 'syntax-table
+                                 (string-to-syntax "> b"))
+            (goto-char end)))))))
+
+(defun emacs-lisp-byte-code-syntax-propertize (start end)
+  (emacs-lisp-byte-code-comment end (point))
+  (funcall
+   (syntax-propertize-rules
+    (emacs-list-byte-code-comment-re
+     (1 (prog1 "< b" (emacs-lisp-byte-code-comment end (point))))))
+   start end))
+
+(add-to-list 'auto-mode-alist '("\\.elc\\'" . emacs-lisp-byte-code-mode))
+(define-derived-mode emacs-lisp-byte-code-mode emacs-lisp-mode
+  "Elisp-Byte-Code"
+  "Major mode for *.elc files."
+  ;; TODO: Add way to disassemble byte-code under point.
+  (setq-local open-paren-in-column-0-is-defun-start nil)
+  (setq-local syntax-propertize-function
+              #'emacs-lisp-byte-code-syntax-propertize))
+
+;;; Generic Lisp mode.
+
 (defvar lisp-mode-map
   (let ((map (make-sparse-keymap))
         (menu-map (make-sparse-keymap "Lisp")))
@@ -730,10 +785,12 @@ POS specifies the starting position where EXP was found and defaults to point."
       (let ((vars ()))
         (goto-char (point-min))
         (while (re-search-forward
-                "^(def\\(?:var\\|const\\|custom\\)[ \t\n]+\\([^; '()\n\t]+\\)"
+                "(def\\(?:var\\|const\\|custom\\)[ \t\n]+\\([^; '()\n\t]+\\)"
                 pos t)
           (let ((var (intern (match-string 1))))
-            (unless (special-variable-p var)
+            (and (not (special-variable-p var))
+                 (save-excursion
+                   (zerop (car (syntax-ppss (match-beginning 0)))))
               (push var vars))))
         `(progn ,@(mapcar (lambda (v) `(defvar ,v)) vars) ,exp)))))
 
@@ -820,7 +877,6 @@ if it already has a value.\)
 
 With argument, insert value in current buffer after the defun.
 Return the result of evaluation."
-  (interactive "P")
   ;; FIXME: the print-length/level bindings should only be applied while
   ;; printing, not while evaluating.
   (let ((debug-on-error eval-expression-debug-on-error)
@@ -925,6 +981,7 @@ rigidly along with this one."
     (if (or (null indent) (looking-at "\\s<\\s<\\s<"))
         ;; Don't alter indentation of a ;;; comment line
         ;; or a line that starts in a string.
+        ;; FIXME: inconsistency: comment-indent moves ;;; to column 0.
         (goto-char (- (point-max) pos))
       (if (and (looking-at "\\s<") (not (looking-at "\\s<\\s<")))
           ;; Single-semicolon comment lines should be indented
@@ -939,18 +996,7 @@ rigidly along with this one."
       ;; If initial point was within line's indentation,
       ;; position after the indentation.  Else stay at same point in text.
       (if (> (- (point-max) pos) (point))
-          (goto-char (- (point-max) pos)))
-      ;; If desired, shift remaining lines of expression the same amount.
-      (and whole-exp (not (zerop shift-amt))
-           (save-excursion
-             (goto-char beg)
-             (forward-sexp 1)
-             (setq end (point))
-             (goto-char beg)
-             (forward-line 1)
-             (setq beg (point))
-             (> end beg))
-           (indent-code-rigidly beg end shift-amt)))))
+          (goto-char (- (point-max) pos))))))
 
 (defvar calculate-lisp-indent-last-sexp)
 
@@ -1230,7 +1276,6 @@ Lisp function does not specify a special indentation."
 (put 'prog2 'lisp-indent-function 2)
 (put 'save-excursion 'lisp-indent-function 0)
 (put 'save-restriction 'lisp-indent-function 0)
-(put 'save-match-data 'lisp-indent-function 0)
 (put 'save-current-buffer 'lisp-indent-function 0)
 (put 'let 'lisp-indent-function 1)
 (put 'let* 'lisp-indent-function 1)
diff --git a/lisp/emacs-lisp/macroexp.el b/lisp/emacs-lisp/macroexp.el
index 70eab149837..394225d697e 100644
--- a/lisp/emacs-lisp/macroexp.el
+++ b/lisp/emacs-lisp/macroexp.el
@@ -100,6 +100,17 @@ each clause."
     (error (message "Compiler-macro error for %S: %S" (car form) err)
            form)))
 
+(defun macroexp--eval-if-compile (&rest _forms)
+  "Pseudo function used internally by macroexp to delay warnings.
+The purpose is to delay warnings to bytecomp.el, so they can use things
+like `byte-compile-log-warning' to get better file-and-line-number data
+and also to avoid outputting the warning during normal execution."
+  nil)
+(put 'macroexp--eval-if-compile 'byte-compile
+     (lambda (form)
+       (mapc (lambda (x) (funcall (eval x))) (cdr form))
+       (byte-compile-constant nil)))
+
 (defun macroexp--expand-all (form)
   "Expand all macros in FORM.
 This is an internal version of `macroexpand-all'.
@@ -112,14 +123,17 @@ Assumes the caller has bound `macroexpand-all-environment'."
       (macroexpand (macroexp--all-forms form 1)
                    macroexpand-all-environment)
     ;; Normal form; get its expansion, and then expand arguments.
-    (let ((new-form (macroexpand form macroexpand-all-environment)))
-      (when (and (not (eq form new-form)) ;It was a macro call.
-                 (car-safe form)
-                 (symbolp (car form))
-                 (get (car form) 'byte-obsolete-info)
-                 (fboundp 'byte-compile-warn-obsolete))
-        (byte-compile-warn-obsolete (car form)))
-      (setq form new-form))
+    (let ((new-form
+           (macroexpand form macroexpand-all-environment)))
+      (setq form
+            (if (and (not (eq form new-form)) ;It was a macro call.
+                     (car-safe form)
+                     (symbolp (car form))
+                     (get (car form) 'byte-obsolete-info))
+                `(progn (macroexp--eval-if-compile
+                         (lambda () (byte-compile-warn-obsolete ',(car form))))
+                        ,new-form)
+              new-form)))
     (pcase form
       (`(cond . ,clauses)
        (macroexp--cons 'cond (macroexp--all-clauses clauses) form))
@@ -323,6 +337,86 @@ symbol itself."
   "Return non-nil if EXP can be copied without extra cost."
   (or (symbolp exp) (macroexp-const-p exp)))
 
+;;; Load-time macro-expansion.
+
+;; Because macro-expansion used to be more lazy, eager macro-expansion
+;; tends to bump into previously harmless/unnoticeable cyclic-dependencies.
+;; So, we have to delay macro-expansion like we used to when we detect
+;; such a cycle, and we also want to help coders resolve those cycles (since
+;; they can be non-obvious) by providing a usefully trimmed backtrace
+;; (hopefully) highlighting the problem.
+
+(defun macroexp--backtrace ()
+  "Return the Elisp backtrace, more recent frames first."
+  (let ((bt ())
+        (i 0))
+    (while
+        (let ((frame (backtrace-frame i)))
+          (when frame
+            (push frame bt)
+            (setq i (1+ i)))))
+    (nreverse bt)))
+
+(defun macroexp--trim-backtrace-frame (frame)
+  (pcase frame
+    (`(,_ macroexpand (,head . ,_) . ,_) `(macroexpand (,head …)))
+    (`(,_ internal-macroexpand-for-load (,head ,second . ,_) . ,_)
+     (if (or (symbolp second)
+             (and (eq 'quote (car-safe second))
+                  (symbolp (cadr second))))
+         `(macroexpand-all (,head ,second …))
+       '(macroexpand-all …)))
+    (`(,_ load-with-code-conversion ,name . ,_)
+     `(load ,(file-name-nondirectory name)))))
+
+(defvar macroexp--pending-eager-loads nil
+  "Stack of files currently undergoing eager macro-expansion.")
+
+(defun internal-macroexpand-for-load (form)
+  ;; Called from the eager-macroexpansion in readevalloop.
+  (cond
+   ;; Don't repeat the same warning for every top-level element.
+   ((eq 'skip (car macroexp--pending-eager-loads)) form)
+   ;; If we detect a cycle, skip macro-expansion for now, and output a warning
+   ;; with a trimmed backtrace.
+   ((and load-file-name (member load-file-name macroexp--pending-eager-loads))
+    (let* ((bt (delq nil
+                     (mapcar #'macroexp--trim-backtrace-frame
+                             (macroexp--backtrace))))
+           (elem `(load ,(file-name-nondirectory load-file-name)))
+           (tail (member elem (cdr (member elem bt)))))
+      (if tail (setcdr tail (list '…)))
+      (if (eq (car-safe (car bt)) 'macroexpand-all) (setq bt (cdr bt)))
+      (message "Warning: Eager macro-expansion skipped due to cycle:\n  %s"
+               (mapconcat #'prin1-to-string (nreverse bt) " => "))
+      (push 'skip macroexp--pending-eager-loads)
+      form))
+   (t
+    (condition-case err
+        (let ((macroexp--pending-eager-loads
+               (cons load-file-name macroexp--pending-eager-loads)))
+          (macroexpand-all form))
+      (error
+       ;; Hopefully this shouldn't happen thanks to the cycle detection,
+       ;; but in case it does happen, let's catch the error and give the
+       ;; code a chance to macro-expand later.
+       (message "Eager macro-expansion failure: %S" err)
+       form)))))
+
+;; ¡¡¡ Big Ugly Hack !!!
+;; src/bootstrap-emacs is mostly used to compile .el files, so it needs
+;; macroexp, bytecomp, cconv, and byte-opt to be fast.  Generally this is done
+;; by compiling those files first, but this only makes a difference if those
+;; files are not preloaded.  But macroexp.el is preloaded so we reload it if
+;; the current version is interpreted and there's a compiled version available.
+(eval-when-compile
+  (add-hook 'emacs-startup-hook
+            (lambda ()
+              (and (not (byte-code-function-p
+                         (symbol-function 'macroexpand-all)))
+                   (locate-library "macroexp.elc")
+                   (load "macroexp.elc")))))
+
 (provide 'macroexp)
 
 ;;; macroexp.el ends here
diff --git a/lisp/emacs-lisp/map-ynp.el b/lisp/emacs-lisp/map-ynp.el
index e7806440bf3..289751f4944 100644
--- a/lisp/emacs-lisp/map-ynp.el
+++ b/lisp/emacs-lisp/map-ynp.el
@@ -123,16 +123,6 @@ Returns the number of actions taken."
             map
             (let ((map (make-sparse-keymap)))
               (set-keymap-parent map query-replace-map)
-              (define-key map [?\C-\M-v] 'scroll-other-window)
-              (define-key map [M-next] 'scroll-other-window)
-              (define-key map [?\C-\M-\S-v] 'scroll-other-window-down)
-              (define-key map [M-prior] 'scroll-other-window-down)
-              ;; The above are rather inconvenient, so maybe we should
-              ;; provide the non-other keys for the other-scroll as well.
-              ;; (define-key map [?\C-v] 'scroll-other-window)
-              ;; (define-key map [next] 'scroll-other-window)
-              ;; (define-key map [?\M-v] 'scroll-other-window-down)
-              ;; (define-key map [prior] 'scroll-other-window-down)
               (dolist (elt action-alist)
                 (define-key map (vector (car elt)) (vector (nth 1 elt))))
               map)))
diff --git a/lisp/emacs-lisp/pcase.el b/lisp/emacs-lisp/pcase.el
index 4aeed7e4d0e..09e47b69b91 100644
--- a/lisp/emacs-lisp/pcase.el
+++ b/lisp/emacs-lisp/pcase.el
@@ -60,6 +60,8 @@
 ;; is in a loop, the repeated macro-expansion becomes terribly costly, so we
 ;; memoize previous macro expansions to try and avoid recomputing them
 ;; over and over again.
+;; FIXME: Now that macroexpansion is also performed when loading an interpreted
+;; file, this is not a real problem any more.
 (defconst pcase--memoize (make-hash-table :weakness 'key :test 'eq))
 ;; (defconst pcase--memoize-1 (make-hash-table :test 'eq))
 ;; (defconst pcase--memoize-2 (make-hash-table :weakness 'key :test 'equal))
diff --git a/lisp/emulation/cua-rect.el b/lisp/emulation/cua-rect.el
index 39ce5901524..f63d79adf47 100644
--- a/lisp/emulation/cua-rect.el
+++ b/lisp/emulation/cua-rect.el
@@ -1423,7 +1423,9 @@ With prefix arg, indent to that column."
   (define-key cua--rectangle-keymap [remap set-mark-command]    'cua-toggle-rectangle-mark)
 
   (define-key cua--rectangle-keymap [remap forward-char]        'cua-resize-rectangle-right)
+  (define-key cua--rectangle-keymap [remap right-char]          'cua-resize-rectangle-right)
   (define-key cua--rectangle-keymap [remap backward-char]       'cua-resize-rectangle-left)
+  (define-key cua--rectangle-keymap [remap left-char]           'cua-resize-rectangle-left)
   (define-key cua--rectangle-keymap [remap next-line]           'cua-resize-rectangle-down)
   (define-key cua--rectangle-keymap [remap previous-line]       'cua-resize-rectangle-up)
   (define-key cua--rectangle-keymap [remap end-of-line]         'cua-resize-rectangle-eol)
diff --git a/lisp/eshell/em-unix.el b/lisp/eshell/em-unix.el
index 58402e37508..d3ddab8af1b 100644
--- a/lisp/eshell/em-unix.el
+++ b/lisp/eshell/em-unix.el
@@ -1111,7 +1111,7 @@ Execute a COMMAND as the superuser or another USER.")
                                   (substring prefix 0 -1) user host dir)
                         (format "/sudo:%s@%s:%s" user host dir))))
                 ;; Ensure, that Tramp has connected to that construct already.
-                (file-exists-p default-directory)
+                (ignore (file-exists-p default-directory))
                 (eshell-named-command (car orig-args) (cdr orig-args))))))))
 
 (put 'eshell/sudo 'eshell-no-numeric-conversions t)
diff --git a/lisp/files.el b/lisp/files.el
index 6528632c841..4acdb542089 100644
--- a/lisp/files.el
+++ b/lisp/files.el
@@ -2145,7 +2145,7 @@ unless NOMODES is non-nil."
          (not buffer-read-only)
          (save-excursion
            (goto-char (point-max))
-           (insert "\n")))
+           (ignore-errors (insert "\n"))))
     (when (and buffer-read-only
                view-read-only
                (not (eq (get major-mode 'mode-class) 'special)))
@@ -2951,20 +2951,16 @@ UNSAFE-VARS is the list of those that aren't marked as safe or risky.
 RISKY-VARS is the list of those that are marked as risky.
 If these settings come from directory-local variables, then
 DIR-NAME is the name of the associated directory.  Otherwise it is nil."
-  (if noninteractive
-      nil
-    (save-window-excursion
-      (let* ((name (or dir-name
-                       (if buffer-file-name
-                           (file-name-nondirectory buffer-file-name)
-                         (concat "buffer " (buffer-name)))))
-             (offer-save (and (eq enable-local-variables t)
-                              unsafe-vars))
-             (exit-chars
-              (if offer-save '(?! ?y ?n ?\s ?\C-g) '(?y ?n ?\s ?\C-g)))
-             (buf (pop-to-buffer "*Local Variables*"))
-             prompt char)
-        (set (make-local-variable 'cursor-type) nil)
+  (unless noninteractive
+    (let ((name (cond (dir-name)
+                      (buffer-file-name
+                       (file-name-nondirectory buffer-file-name))
+                      ((concat "buffer " (buffer-name)))))
+          (offer-save (and (eq enable-local-variables t)
+                           unsafe-vars))
+          (buf (get-buffer-create "*Local Variables*")))
+      ;; Set up the contents of the *Local Variables* buffer.
+      (with-current-buffer buf
         (erase-buffer)
         (cond
          (unsafe-vars
@@ -2999,25 +2995,35 @@ n  -- to ignore the local variables list.")
           (let ((print-escape-newlines t))
             (prin1 (cdr elt) buf))
           (insert "\n"))
-        (setq prompt
-              (format "Please type %s%s: "
-                      (if offer-save "y, n, or !" "y or n")
-                      (if (< (line-number-at-pos) (window-body-height))
-                          ""
-                        (push ?\C-v exit-chars)
-                        ", or C-v to scroll")))
-        (goto-char (point-min))
-        (while (null char)
-          (setq char (read-char-choice prompt exit-chars t))
-          (when (eq char ?\C-v)
-            (condition-case nil
-                (scroll-up)
-              (error (goto-char (point-min))))
-            (setq char nil)))
-        (kill-buffer buf)
-        (when (and offer-save (= char ?!) unsafe-vars)
-          (customize-push-and-save 'safe-local-variable-values unsafe-vars))
-        (memq char '(?! ?\s ?y))))))
+        (set (make-local-variable 'cursor-type) nil)
+        (set-buffer-modified-p nil)
+        (goto-char (point-min)))
+
+      ;; Display the buffer and read a choice.
+      (save-window-excursion
+        (pop-to-buffer buf)
+        (let* ((exit-chars '(?y ?n ?\s ?\C-g ?\C-v))
+               (prompt (format "Please type %s%s: "
+                               (if offer-save "y, n, or !" "y or n")
+                               (if (< (line-number-at-pos (point-max))
+                                      (window-body-height))
+                                   ""
+                                 (push ?\C-v exit-chars)
+                                 ", or C-v to scroll")))
+               char)
+          (if offer-save (push ?! exit-chars))
+          (while (null char)
+            (setq char (read-char-choice prompt exit-chars t))
+            (when (eq char ?\C-v)
+              (condition-case nil
+                  (scroll-up)
+                (error (goto-char (point-min))
+                       (recenter 1)))
+              (setq char nil)))
+          (when (and offer-save (= char ?!) unsafe-vars)
+            (customize-push-and-save 'safe-local-variable-values unsafe-vars))
+          (prog1 (memq char '(?! ?\s ?y))
+            (quit-window t)))))))
 
 (defun hack-local-variables-prop-line (&optional mode-only)
   "Return local variables specified in the -*- line.
diff --git a/lisp/frame.el b/lisp/frame.el
index 01225639ecf..c182a964820 100644
--- a/lisp/frame.el
+++ b/lisp/frame.el
@@ -1657,6 +1657,10 @@ terminals, cursor blinking is controlled by the terminal."
 
 (make-variable-buffer-local 'show-trailing-whitespace)
 
+;; Defined in dispnew.c.
+(make-obsolete-variable
+ 'window-system-version "it does not give useful information." "24.3")
+
 (provide 'frame)
 
 ;;; frame.el ends here
diff --git a/lisp/gnus/ChangeLog b/lisp/gnus/ChangeLog
index a4e3d9bde2b..5644c394f7e 100644
--- a/lisp/gnus/ChangeLog
+++ b/lisp/gnus/ChangeLog
@@ -1,3 +1,112 @@
+2012-09-10  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * qp.el (quoted-printable-decode-region): Inline+CSE+strength-reduction.
+
+2012-09-07  Chong Yidong  <cyd@gnu.org>
+
+        * gnus-util.el
+        (gnus-put-text-property-excluding-characters-with-faces): Restore.
+
+        * gnus-salt.el (gnus-tree-highlight-node):
+        * gnus-sum.el (gnus-summary-highlight-line):
+        * gnus-group.el (gnus-group-highlight-line): Revert use of add-face.
+
+2012-09-06  Lars Ingebrigtsen  <larsi@gnus.org>
+
+        * gnus-util.el: Fix compilation error on XEmacs 21.4.
+
+2012-09-06  Juri Linkov  <juri@jurta.org>
+
+        * gnus-group.el (gnus-read-ephemeral-gmane-group): Change the naming
+        scheme for buffer names to be more consistent with other group and
+        article buffer names in Gnus.
+
+2012-09-06  Lars Ingebrigtsen  <larsi@gnus.org>
+
+        * gnus-util.el
+        (gnus-put-text-property-excluding-characters-with-faces): Remove.
+
+        * gnus-compat.el: Define compat function `add-face' from Wolfgang
+        Jenkner.
+
+        * gnus-group.el (gnus-group-highlight-line): Use combining faces.
+
+        * gnus-sum.el (gnus-summary-highlight-line): Ditto.
+
+        * gnus-salt.el (gnus-tree-highlight-node): Ditto.
+
+2012-09-06  Katsumi Yamaoka  <yamaoka@jpl.org>
+
+        * gnus-score.el (gnus-score-decode-text-parts): Use #' for
+        mm-text-parts used in labels macro to make it work with XEmacs 21.5.
+
+        * gnus-util.el (gnus-string-prefix-p): New function, an alias to
+        string-prefix-p in Emacs >=23.2.
+
+        * nnmaildir.el (nnmaildir--ensure-suffix, nnmaildir--add-flag)
+        (nnmaildir--remove-flag, nnmaildir--scan): Use gnus-string-match-p
+        instead of string-match-p.
+        (nnmaildir--scan): Use gnus-string-prefix-p instead of string-prefix-p.
+
+2012-09-06  Kenichi Handa  <handa@gnu.org>
+
+        * qp.el (quoted-printable-decode-region): Fix previous change; handle
+        lowercase a..f.
+
+2012-09-05  Magnus Henoch  <magnus.henoch@gmail.com>
+
+        * nnmaildir.el (nnmaildir--article-set-flags): Fix compilation error.
+
+2012-09-05  Martin Stjernholm  <mast@lysator.liu.se>
+
+        * gnus-demon.el (gnus-demon-init): Fixed regression when IDLE is t and
+        TIME is set.
+
+2012-09-05  Juri Linkov  <juri@jurta.org>
+
+        * gnus-group.el (gnus-read-ephemeral-bug-group): Allow opening more
+        than one group at a time (bug#11961).
+
+2012-09-05  Julien Danjou  <julien@danjou.info>
+
+        * gnus-srvr.el (gnus-server-open-server): Don't message on failure:
+        this hide the real reason with a message giving absolutely no hint.
+
+2012-09-05  Lars Ingebrigtsen  <larsi@gnus.org>
+
+        * gnus-group.el (gnus-group-mark-article-read): Propagate the read mark
+        to the backend (bug#11804).
+
+        * message.el (message-insert-newsgroups): Don't insert newsgroup
+        duplicates (bug#12275).
+
+2012-09-05  John Wiegley  <johnw@newartisans.com>
+
+        * gnus.el (gnus-expand-group-parameters): Allow regexp substitutions in
+        sieve rules.
+
+2012-09-05  Jan Tatarik  <jan.tatarik@gmail.com>
+
+        * gnus-score.el (gnus-score-decode-text-parts): Use #' for the local
+        function.
+
+        * gnus-logic.el (gnus-advanced-body): Allow scoring on decoded bodies.
+
+        * gnus-score.el (gnus-score-decode-text-parts): Ditto.
+
+2012-09-05  Magnus Henoch  <magnus.henoch@gmail.com>
+
+        * nnmaildir.el: Make nnmaildir understand and write maildir flags.
+        That is, rename files from "unique:2," to "unique:2,S" for "seen", etc.
+        This should make nnmaildir more usable with offlineimap.
+
+2012-09-03  Lars Ingebrigtsen  <larsi@gnus.org>
+
+        * gnus-notifications.el (gnus-notifications-notify): Use it.
+
+        * gnus-fun.el (gnus-funcall-no-warning): New function to silence
+        warnings on XEmacs.
+
 2012-09-01  Paul Eggert  <eggert@cs.ucla.edu>
 
         Better seeds for (random).
@@ -2291,8 +2400,6 @@
 
 2011-06-30  Lars Magne Ingebrigtsen  <larsi@gnus.org>
 
-        * dgnushack.el: Autoload sha1 on XEmacs.
-
         * gnus-group.el (gnus-read-ephemeral-emacs-bug-group): Take an optional
         quit window configuration.
 
diff --git a/lisp/gnus/gnus-demon.el b/lisp/gnus/gnus-demon.el
index 115c5777448..671c566d09f 100644
--- a/lisp/gnus/gnus-demon.el
+++ b/lisp/gnus/gnus-demon.el
@@ -144,9 +144,12 @@ marked with SPECIAL."
                         (* (gnus-demon-time-to-step time) gnus-demon-timestep))
                        (t
                         (* time gnus-demon-timestep))))
-           (idle (if (numberp idle)
-                     (* idle gnus-demon-timestep)
-                   idle))
+           (idle (cond ((numberp idle)
+                        (* idle gnus-demon-timestep))
+                       ((and (eq idle t) (numberp time))
+                        time)
+                       (t
+                        idle)))
 
            (timer
             (cond
diff --git a/lisp/gnus/gnus-fun.el b/lisp/gnus/gnus-fun.el
index f33eb910c6a..f5e1c5ad691 100644
--- a/lisp/gnus/gnus-fun.el
+++ b/lisp/gnus/gnus-fun.el
@@ -278,6 +278,10 @@ colors of the displayed X-Faces."
           values))
   (mapconcat 'identity values " ")))
 
+(defun gnus-funcall-no-warning (function &rest args)
+  (when (fboundp function)
+    (apply function args)))
+
 (provide 'gnus-fun)
 
 ;;; gnus-fun.el ends here
diff --git a/lisp/gnus/gnus-group.el b/lisp/gnus/gnus-group.el
index 2f6fc0ccd19..8c7d0165976 100644
--- a/lisp/gnus/gnus-group.el
+++ b/lisp/gnus/gnus-group.el
@@ -2388,7 +2388,7 @@ specified by `gnus-gmane-group-download-format'."
                group start (+ start range)))
       (write-region (point-min) (point-max) tmpfile)
       (gnus-group-read-ephemeral-group
-       (format "%s.start-%s.range-%s" group start range)
+       (format "nndoc+ephemeral:%s.start-%s.range-%s" group start range)
        `(nndoc ,tmpfile
                (nndoc-article-type mbox))))
     (delete-file tmpfile)))
@@ -2481,7 +2481,8 @@ the bug number, and browsing the URL must return mbox output."
                          "/.*$" ""))))
       (write-region (point-min) (point-max) tmpfile)
       (gnus-group-read-ephemeral-group
-       "gnus-read-ephemeral-bug"
+       (format "nndoc+ephemeral:bug#%s"
+               (mapconcat 'number-to-string ids ","))
        `(nndoc ,tmpfile
                (nndoc-article-type mbox))
        nil window-conf))
@@ -4670,6 +4671,8 @@ you the groups that have both dormant articles and cached articles."
               (setq mark gnus-expirable-mark))
             (setq mark (gnus-request-update-mark
                         group article mark))
+            (gnus-request-set-mark
+             group (list (list (list article) 'add '(read))))
             (gnus-mark-article-as-read article mark)
             (setq gnus-newsgroup-active (gnus-active group))
             (when active
diff --git a/lisp/gnus/gnus-logic.el b/lisp/gnus/gnus-logic.el
index 954295438c9..a440b779930 100644
--- a/lisp/gnus/gnus-logic.el
+++ b/lisp/gnus/gnus-logic.el
@@ -180,46 +180,51 @@
     (setq header "article"))
   (with-current-buffer nntp-server-buffer
     (let* ((request-func (cond ((string= "head" header)
-                                'gnus-request-head)
-                               ((string= "body" header)
-                                'gnus-request-body)
-                               (t 'gnus-request-article)))
-           ofunc article)
+                                'gnus-request-head)
+                               ;; We need to peek at the headers to detect the
+                               ;; content encoding
+                               ((string= "body" header)
+                                'gnus-request-article)
+                               (t 'gnus-request-article)))
+           ofunc article handles)
       ;; Not all backends support partial fetching.  In that case, we
       ;; just fetch the entire article.
       (unless (gnus-check-backend-function
-               (intern (concat "request-" header))
-               gnus-newsgroup-name)
-        (setq ofunc request-func)
-        (setq request-func 'gnus-request-article))
+               (intern (concat "request-" header))
+               gnus-newsgroup-name)
+        (setq ofunc request-func)
+        (setq request-func 'gnus-request-article))
       (setq article (mail-header-number gnus-advanced-headers))
       (gnus-message 7 "Scoring article %s..." article)
       (when (funcall request-func article gnus-newsgroup-name)
-        (goto-char (point-min))
-        ;; If just parts of the article is to be searched and the
-        ;; backend didn't support partial fetching, we just narrow to
-        ;; the relevant parts.
-        (when ofunc
-          (if (eq ofunc 'gnus-request-head)
-              (narrow-to-region
-               (point)
-               (or (search-forward "\n\n" nil t) (point-max)))
-            (narrow-to-region
-             (or (search-forward "\n\n" nil t) (point))
-             (point-max))))
-        (let* ((case-fold-search (not (eq (downcase (symbol-name type))
-                                          (symbol-name type))))
-               (search-func
-                (cond ((memq type '(r R regexp Regexp))
-                       're-search-forward)
-                      ((memq type '(s S string String))
-                       'search-forward)
-                      (t
-                       (error "Invalid match type: %s" type)))))
-          (goto-char (point-min))
-          (prog1
-              (funcall search-func match nil t)
-            (widen)))))))
+        (when (string= "body" header)
+          (setq handles (gnus-score-decode-text-parts)))
+        (goto-char (point-min))
+        ;; If just parts of the article is to be searched and the
+        ;; backend didn't support partial fetching, we just narrow to
+        ;; the relevant parts.
+        (when ofunc
+          (if (eq ofunc 'gnus-request-head)
+              (narrow-to-region
+               (point)
+               (or (search-forward "\n\n" nil t) (point-max)))
+            (narrow-to-region
+             (or (search-forward "\n\n" nil t) (point))
+             (point-max))))
+        (let* ((case-fold-search (not (eq (downcase (symbol-name type))
+                                          (symbol-name type))))
+               (search-func
+                (cond ((memq type '(r R regexp Regexp))
+                       're-search-forward)
+                      ((memq type '(s S string String))
+                       'search-forward)
+                      (t
+                       (error "Invalid match type: %s" type)))))
+          (goto-char (point-min))
+          (prog1
+              (funcall search-func match nil t)
+            (widen)))
+        (when handles (mm-destroy-parts handles))))))
 
 (provide 'gnus-logic)
 
diff --git a/lisp/gnus/gnus-notifications.el b/lisp/gnus/gnus-notifications.el
index c5129958997..f9c2d309a35 100644
--- a/lisp/gnus/gnus-notifications.el
+++ b/lisp/gnus/gnus-notifications.el
@@ -29,13 +29,16 @@
 
 ;;; Code:
 
-(require 'notifications nil t)
+(ignore-errors
+  (require 'notifications))
 (require 'gnus-sum)
 (require 'gnus-group)
 (require 'gnus-int)
 (require 'gnus-art)
 (require 'gnus-util)
-(require 'google-contacts nil t)        ; Optional
+(ignore-errors
+  (require 'google-contacts))        ; Optional
+(require 'gnus-fun)
 
 (defgroup gnus-notifications nil
   "Send notifications on new message in Gnus."
@@ -81,12 +84,14 @@ not get notifications."
   "Send a notification about a new mail.
 Return a notification id if any, or t on success."
   (if (fboundp 'notifications-notify)
-      (notifications-notify
+      (gnus-funcall-no-warning
+       'notifications-notify
        :title from
        :body subject
        :actions '("read" "Read")
        :on-action 'gnus-notifications-action
-       :app-icon (image-search-load-path "gnus/gnus.png")
+       :app-icon (gnus-funcall-no-warning
+                  'image-search-load-path "gnus/gnus.png")
        :app-name "Gnus"
        :category "email.arrived"
        :timeout gnus-notifications-timeout
@@ -100,7 +105,8 @@ Return a notification id if any, or t on success."
   (let ((google-photo (when (and gnus-notifications-use-google-contacts
                                  (fboundp 'google-contacts-get-photo))
                         (ignore-errors
-                          (google-contacts-get-photo mail-address)))))
+                          (gnus-funcall-no-warning
+                           'google-contacts-get-photo mail-address)))))
     (if google-photo
         google-photo
       (when gnus-notifications-use-gravatar
diff --git a/lisp/gnus/gnus-score.el b/lisp/gnus/gnus-score.el
index f24d889216e..f215b845514 100644
--- a/lisp/gnus/gnus-score.el
+++ b/lisp/gnus/gnus-score.el
@@ -1717,105 +1717,140 @@ score in `gnus-newsgroup-scored' by SCORE."
           (setq entries rest)))))
   nil)
 
+(defun gnus-score-decode-text-parts ()
+  (labels ((mm-text-parts (handle)
+                        (cond ((stringp (car handle))
+                               (let ((parts (mapcan #'mm-text-parts (cdr handle))))
+                                 (if (equal "multipart/alternative" (car handle))
+                                     ;; pick the first supported alternative
+                                     (list (car parts))
+                                   parts)))
+
+                              ((bufferp (car handle))
+                               (when (string-match "^text/" (mm-handle-media-type handle))
+                                 (list handle)))
+
+                              (t (mapcan #'mm-text-parts handle))))
+           (my-mm-display-part (handle)
+                               (when handle
+                                 (save-restriction
+                                   (narrow-to-region (point) (point))
+                                   (mm-display-inline handle)
+                                   (goto-char (point-max))))))
+
+    (let (;(mm-text-html-renderer 'w3m-standalone)
+          (handles (mm-dissect-buffer t)))
+      (save-excursion
+        (article-goto-body)
+        (delete-region (point) (point-max))
+        (mapc #'my-mm-display-part (mm-text-parts handles))
+        handles))))
+
 (defun gnus-score-body (scores header now expire &optional trace)
-  (if gnus-agent-fetching
-      nil
-    (save-excursion
-      (setq gnus-scores-articles
-            (sort gnus-scores-articles
-                  (lambda (a1 a2)
-                    (< (mail-header-number (car a1))
-                       (mail-header-number (car a2))))))
-      (set-buffer nntp-server-buffer)
-      (save-restriction
-        (let* ((buffer-read-only nil)
-               (articles gnus-scores-articles)
-               (all-scores scores)
-               (request-func (cond ((string= "head" header)
-                                    'gnus-request-head)
-                                   ((string= "body" header)
-                                    'gnus-request-body)
-                                   (t 'gnus-request-article)))
-               entries alist ofunc article last)
-          (when articles
-            (setq last (mail-header-number (caar (last articles))))
-          ;; Not all backends support partial fetching.  In that case,
-            ;; we just fetch the entire article.
-            (unless (gnus-check-backend-function
-                     (and (string-match "^gnus-" (symbol-name request-func))
-                          (intern (substring (symbol-name request-func)
-                                             (match-end 0))))
-                     gnus-newsgroup-name)
-              (setq ofunc request-func)
-              (setq request-func 'gnus-request-article))
-            (while articles
-              (setq article (mail-header-number (caar articles)))
-              (gnus-message 7 "Scoring article %s of %s..." article last)
-              (widen)
-              (when (funcall request-func article gnus-newsgroup-name)
-                (goto-char (point-min))
-            ;; If just parts of the article is to be searched, but the
-            ;; backend didn't support partial fetching, we just narrow
-                ;; to the relevant parts.
-                (when ofunc
-                  (if (eq ofunc 'gnus-request-head)
-                      (narrow-to-region
-                       (point)
-                       (or (search-forward "\n\n" nil t) (point-max)))
-                    (narrow-to-region
-                     (or (search-forward "\n\n" nil t) (point))
-                     (point-max))))
-                (setq scores all-scores)
-                ;; Find matches.
-                (while scores
-                  (setq alist (pop scores)
-                        entries (assoc header alist))
-                  (while (cdr entries) ;First entry is the header index.
-                    (let* ((rest (cdr entries))
-                           (kill (car rest))
-                           (match (nth 0 kill))
-                           (type (or (nth 3 kill) 's))
-                           (score (or (nth 1 kill)
-                                      gnus-score-interactive-default-score))
-                           (date (nth 2 kill))
-                           (found nil)
-                           (case-fold-search
-                            (not (or (eq type 'R) (eq type 'S)
-                                     (eq type 'Regexp) (eq type 'String))))
-                           (search-func
-                            (cond ((or (eq type 'r) (eq type 'R)
-                                       (eq type 'regexp) (eq type 'Regexp))
-                                   're-search-forward)
-                                  ((or (eq type 's) (eq type 'S)
-                                       (eq type 'string) (eq type 'String))
-                                   'search-forward)
-                                  (t
-                                   (error "Invalid match type: %s" type)))))
-                      (goto-char (point-min))
-                      (when (funcall search-func match nil t)
-                        ;; Found a match, update scores.
-                        (setcdr (car articles) (+ score (cdar articles)))
-                        (setq found t)
-                        (when trace
-                          (push
-                           (cons (car-safe (rassq alist gnus-score-cache))
-                                 kill)
-                           gnus-score-trace)))
-                      ;; Update expire date
-                      (unless trace
-                        (cond
-                         ((null date))  ;Permanent entry.
-                         ((and found gnus-update-score-entry-dates)
-                          ;; Match, update date.
-                          (gnus-score-set 'touched '(t) alist)
-                          (setcar (nthcdr 2 kill) now))
-                         ((and expire (< date expire)) ;Old entry, remove.
-                          (gnus-score-set 'touched '(t) alist)
-                          (setcdr entries (cdr rest))
-                          (setq rest entries))))
-                      (setq entries rest)))))
-              (setq articles (cdr articles)))))))
-    nil))
+    (if gnus-agent-fetching
+       nil
+     (save-excursion
+       (setq gnus-scores-articles
+             (sort gnus-scores-articles
+                   (lambda (a1 a2)
+                     (< (mail-header-number (car a1))
+                        (mail-header-number (car a2))))))
+       (set-buffer nntp-server-buffer)
+       (save-restriction
+         (let* ((buffer-read-only nil)
+                (articles gnus-scores-articles)
+                (all-scores scores)
+                (request-func (cond ((string= "head" header)
+                                     'gnus-request-head)
+                                    ;; We need to peek at the headers to detect
+                                    ;; the content encoding
+                                    ((string= "body" header)
+                                     'gnus-request-article)
+                                    (t 'gnus-request-article)))
+                entries alist ofunc article last)
+           (when articles
+             (setq last (mail-header-number (caar (last articles))))
+             ;; Not all backends support partial fetching.  In that case,
+             ;; we just fetch the entire article.
+             (unless (gnus-check-backend-function
+                      (and (string-match "^gnus-" (symbol-name request-func))
+                           (intern (substring (symbol-name request-func)
+                                              (match-end 0))))
+                      gnus-newsgroup-name)
+               (setq ofunc request-func)
+               (setq request-func 'gnus-request-article))
+             (while articles
+               (setq article (mail-header-number (caar articles)))
+               (gnus-message 7 "Scoring article %s of %s..." article last)
+               (widen)
+               (let (handles)
+                 (when (funcall request-func article gnus-newsgroup-name)
+                  (when (string= "body" header)
+                    (setq handles (gnus-score-decode-text-parts)))
+                  (goto-char (point-min))
+                  ;; If just parts of the article is to be searched, but the
+                  ;; backend didn't support partial fetching, we just narrow
+                  ;; to the relevant parts.
+                  (when ofunc
+                    (if (eq ofunc 'gnus-request-head)
+                        (narrow-to-region
+                         (point)
+                         (or (search-forward "\n\n" nil t) (point-max)))
+                      (narrow-to-region
+                       (or (search-forward "\n\n" nil t) (point))
+                       (point-max))))
+                  (setq scores all-scores)
+                  ;; Find matches.
+                  (while scores
+                    (setq alist (pop scores)
+                          entries (assoc header alist))
+                    (while (cdr entries) ;First entry is the header index.
+                      (let* ((rest (cdr entries))
+                             (kill (car rest))
+                             (match (nth 0 kill))
+                             (type (or (nth 3 kill) 's))
+                             (score (or (nth 1 kill)
+                                        gnus-score-interactive-default-score))
+                             (date (nth 2 kill))
+                             (found nil)
+                             (case-fold-search
+                              (not (or (eq type 'R) (eq type 'S)
+                                       (eq type 'Regexp) (eq type 'String))))
+                             (search-func
+                              (cond ((or (eq type 'r) (eq type 'R)
+                                         (eq type 'regexp) (eq type 'Regexp))
+                                     're-search-forward)
+                                    ((or (eq type 's) (eq type 'S)
+                                         (eq type 'string) (eq type 'String))
+                                     'search-forward)
+                                    (t
+                                     (error "Invalid match type: %s" type)))))
+                        (goto-char (point-min))
+                        (when (funcall search-func match nil t)
+                          ;; Found a match, update scores.
+                          (setcdr (car articles) (+ score (cdar articles)))
+                          (setq found t)
+                          (when trace
+                            (push
+                             (cons (car-safe (rassq alist gnus-score-cache))
+                                   kill)
+                             gnus-score-trace)))
+                        ;; Update expire date
+                        (unless trace
+                          (cond
+                           ((null date)) ;Permanent entry.
+                           ((and found gnus-update-score-entry-dates)
+                            ;; Match, update date.
+                            (gnus-score-set 'touched '(t) alist)
+                            (setcar (nthcdr 2 kill) now))
+                           ((and expire (< date expire)) ;Old entry, remove.
+                            (gnus-score-set 'touched '(t) alist)
+                            (setcdr entries (cdr rest))
+                            (setq rest entries))))
+                        (setq entries rest))))
+                  (when handles (mm-destroy-parts handles))))
+               (setq articles (cdr articles)))))))
+     nil))
 
 (defun gnus-score-thread (scores header now expire &optional trace)
   (gnus-score-followup scores header now expire trace t))
diff --git a/lisp/gnus/gnus-srvr.el b/lisp/gnus/gnus-srvr.el
index 66509c939dc..f58cb80311a 100644
--- a/lisp/gnus/gnus-srvr.el
+++ b/lisp/gnus/gnus-srvr.el
@@ -490,8 +490,7 @@ The following commands are available:
       (error "No such server: %s" server))
     (gnus-server-set-status method 'ok)
     (prog1
-        (or (gnus-open-server method)
-            (progn (message "Couldn't open %s" server) nil))
+        (gnus-open-server method)
       (gnus-server-update-server server)
       (gnus-server-position-point))))
 
diff --git a/lisp/gnus/gnus-util.el b/lisp/gnus/gnus-util.el
index 26178afa864..4c5eabab723 100644
--- a/lisp/gnus/gnus-util.el
+++ b/lisp/gnus/gnus-util.el
@@ -1926,6 +1926,18 @@ Same as `string-match' except this function does not change the match data."
     (save-match-data
       (string-match regexp string start))))
 
+(if (fboundp 'string-prefix-p)
+    (defalias 'gnus-string-prefix-p 'string-prefix-p)
+  (defun gnus-string-prefix-p (str1 str2 &optional ignore-case)
+    "Return non-nil if STR1 is a prefix of STR2.
+If IGNORE-CASE is non-nil, the comparison is done without paying attention
+to case differences."
+    (and (<= (length str1) (length str2))
+         (let ((prefix (substring str2 0 (length str1))))
+           (if ignore-case
+               (string-equal (downcase str1) (downcase prefix))
+             (string-equal str1 prefix))))))
+
 (eval-and-compile
   (if (fboundp 'macroexpand-all)
       (defalias 'gnus-macroexpand-all 'macroexpand-all)
diff --git a/lisp/gnus/gnus.el b/lisp/gnus/gnus.el
index 5862e7807a2..8fbde5c8ecc 100644
--- a/lisp/gnus/gnus.el
+++ b/lisp/gnus/gnus.el
@@ -3824,12 +3824,28 @@ You should probably use `gnus-find-method-for-group' instead."
   "Go through PARAMETERS and expand them according to the match data."
   (let (new)
     (dolist (elem parameters)
-      (if (and (stringp (cdr elem))
-               (string-match "\\\\[0-9&]" (cdr elem)))
-          (push (cons (car elem)
-                      (gnus-expand-group-parameter match (cdr elem) group))
-                new)
-        (push elem new)))
+      (cond
+       ((and (stringp (cdr elem))
+             (string-match "\\\\[0-9&]" (cdr elem)))
+        (push (cons (car elem)
+                    (gnus-expand-group-parameter match (cdr elem) group))
+              new))
+       ;; For `sieve' group parameters, perform substitutions for every
+       ;; string within the match rule.  This allows for parameters such
+       ;; as:
+       ;;  ("list\\.\\(.*\\)"
+       ;;   (sieve header :is "list-id" "<\\1.domain.org>"))
+       ((eq 'sieve (car elem))
+        (push (mapcar (lambda (sieve-elem)
+                        (if (and (stringp sieve-elem)
+                                 (string-match "\\\\[0-9&]" sieve-elem))
+                            (gnus-expand-group-parameter match sieve-elem
+                                                         group)
+                          sieve-elem))
+                      (cdr elem))
+              new))
+       (t
+        (push elem new))))
     new))
 
 (defun gnus-group-fast-parameter (group symbol &optional allow-list)
@@ -3861,9 +3877,20 @@ The function `gnus-group-find-parameter' will do that for you."
               (when this-result
                 (setq result (car this-result))
                 ;; Expand if necessary.
-                (if (and (stringp result) (string-match "\\\\[0-9&]" result))
-                    (setq result (gnus-expand-group-parameter
-                                  (car head) result group)))))))
+                (cond
+                 ((and (stringp result) (string-match "\\\\[0-9&]" result))
+                  (setq result (gnus-expand-group-parameter
+                                (car head) result group)))
+                 ;; For `sieve' group parameters, perform substitutions
+                 ;; for every string within the match rule (see above).
+                 ((eq symbol 'sieve)
+                  (setq result
+                        (mapcar (lambda (elem)
+                                  (if (stringp elem)
+                                      (gnus-expand-group-parameter (car head)
+                                                                   elem group)
+                                    elem))
+                                result))))))))
         ;; Done.
         result))))
 
diff --git a/lisp/gnus/message.el b/lisp/gnus/message.el
index 18088423eb0..42911ce0648 100644
--- a/lisp/gnus/message.el
+++ b/lisp/gnus/message.el
@@ -3292,11 +3292,33 @@ or in the synonym headers, defined by `message-header-synonyms'."
 (defun message-insert-newsgroups ()
   "Insert the Newsgroups header from the article being replied to."
   (interactive)
-  (when (and (message-position-on-field "Newsgroups")
-             (mail-fetch-field "newsgroups")
-             (not (string-match "\\` *\\'" (mail-fetch-field "newsgroups"))))
-    (insert ","))
-  (insert (or (message-fetch-reply-field "newsgroups") "")))
+  (let ((old-newsgroups (mail-fetch-field "newsgroups"))
+        (new-newsgroups (message-fetch-reply-field "newsgroups"))
+        (first t)
+        insert-newsgroups)
+    (message-position-on-field "Newsgroups")
+    (cond
+     ((not new-newsgroups)
+      (error "No Newsgroups to insert"))
+     ((not old-newsgroups)
+      (insert new-newsgroups))
+     (t
+      (setq new-newsgroups (split-string new-newsgroups "[, ]+")
+            old-newsgroups (split-string old-newsgroups "[, ]+"))
+      (dolist (group new-newsgroups)
+        (unless (member group old-newsgroups)
+          (push group insert-newsgroups)))
+      (if (null insert-newsgroups)
+          (error "Newgroup%s already in the header"
+                 (if (> (length new-newsgroups) 1)
+                     "s" ""))
+        (when old-newsgroups
+          (setq first nil))
+        (dolist (group insert-newsgroups)
+          (unless first
+            (insert ","))
+          (setq first nil)
+          (insert group)))))))
 
 
 
diff --git a/lisp/gnus/nnmaildir.el b/lisp/gnus/nnmaildir.el
index 7139a528e11..74a693a9c61 100644
--- a/lisp/gnus/nnmaildir.el
+++ b/lisp/gnus/nnmaildir.el
@@ -77,6 +77,56 @@
 
 (defconst nnmaildir-version "Gnus")
 
+(defconst nnmaildir-flag-mark-mapping
+  '((?F . tick)
+    (?R . reply)
+    (?S . read))
+  "Alist mapping Maildir filename flags to Gnus marks.
+Maildir filenames are of the form \"unique-id:2,FLAGS\",
+where FLAGS are a string of characters in ASCII order.
+Some of the FLAGS correspond to Gnus marks.")
+
+(defsubst nnmaildir--mark-to-flag (mark)
+  "Find the Maildir flag that corresponds to MARK (an atom).
+Return a character, or `nil' if not found.
+See `nnmaildir-flag-mark-mapping'."
+  (car (rassq mark nnmaildir-flag-mark-mapping)))
+
+(defsubst nnmaildir--flag-to-mark (flag)
+  "Find the Gnus mark that corresponds to FLAG (a character).
+Return an atom, or `nil' if not found.
+See `nnmaildir-flag-mark-mapping'."
+  (cdr (assq flag nnmaildir-flag-mark-mapping)))
+
+(defun nnmaildir--ensure-suffix (filename)
+  "Ensure that FILENAME contains the suffix \":2,\"."
+  (if (gnus-string-match-p ":2," filename)
+      filename
+    (concat filename ":2,")))
+
+(defun nnmaildir--add-flag (flag suffix)
+  "Return a copy of SUFFIX where FLAG is set.
+SUFFIX should start with \":2,\"."
+  (unless (gnus-string-match-p "^:2," suffix)
+    (error "Invalid suffix `%s'" suffix))
+  (let* ((flags (substring suffix 3))
+         (flags-as-list (append flags nil))
+         (new-flags
+          (concat (gnus-delete-duplicates
+                   ;; maildir flags must be sorted
+                   (sort (cons flag flags-as-list) '<)))))
+    (concat ":2," new-flags)))
+
+(defun nnmaildir--remove-flag (flag suffix)
+  "Return a copy of SUFFIX where FLAG is cleared.
+SUFFIX should start with \":2,\"."
+  (unless (gnus-string-match-p "^:2," suffix)
+    (error "Invalid suffix `%s'" suffix))
+  (let* ((flags (substring suffix 3))
+         (flags-as-list (append flags nil))
+         (new-flags (concat (delq flag flags-as-list))))
+    (concat ":2," new-flags)))
+
 (defvar nnmaildir-article-file-name nil
   "*The filename of the most recently requested article.  This variable is set
 by nnmaildir-request-article.")
@@ -152,6 +202,16 @@ by nnmaildir-request-article.")
   (gnm           nil)                      ;; flag: split from mail-sources?
   (target-prefix nil :type string))        ;; symlink target prefix
 
+(defun nnmaildir--article-set-flags (article new-suffix curdir)
+  (let* ((prefix (nnmaildir--art-prefix article))
+         (suffix (nnmaildir--art-suffix article))
+         (article-file (concat curdir prefix suffix))
+         (new-name (concat curdir prefix new-suffix)))
+    (unless (file-exists-p article-file)
+      (error "Couldn't find article file %s" article-file))
+    (rename-file article-file new-name 'replace)
+    (setf (nnmaildir--art-suffix article) new-suffix)))
+
 (defun nnmaildir--expired-article (group article)
   (setf (nnmaildir--art-nov article) nil)
   (let ((flist  (nnmaildir--grp-flist group))
@@ -208,29 +268,33 @@ by nnmaildir-request-article.")
   (eval param))
 
 (defmacro nnmaildir--with-nntp-buffer (&rest body)
+  (declare (debug (body)))
   `(with-current-buffer nntp-server-buffer
      ,@body))
 (defmacro nnmaildir--with-work-buffer (&rest body)
+  (declare (debug (body)))
   `(with-current-buffer (get-buffer-create " *nnmaildir work*")
      ,@body))
 (defmacro nnmaildir--with-nov-buffer (&rest body)
+  (declare (debug (body)))
   `(with-current-buffer (get-buffer-create " *nnmaildir nov*")
      ,@body))
 (defmacro nnmaildir--with-move-buffer (&rest body)
+  (declare (debug (body)))
   `(with-current-buffer (get-buffer-create " *nnmaildir move*")
      ,@body))
 
-(defmacro nnmaildir--subdir (dir subdir)
-  `(file-name-as-directory (concat ,dir ,subdir)))
-(defmacro nnmaildir--srvgrp-dir (srv-dir gname)
-  `(nnmaildir--subdir ,srv-dir ,gname))
-(defmacro nnmaildir--tmp       (dir) `(nnmaildir--subdir ,dir "tmp"))
-(defmacro nnmaildir--new       (dir) `(nnmaildir--subdir ,dir "new"))
-(defmacro nnmaildir--cur       (dir) `(nnmaildir--subdir ,dir "cur"))
-(defmacro nnmaildir--nndir     (dir) `(nnmaildir--subdir ,dir ".nnmaildir"))
-(defmacro nnmaildir--nov-dir   (dir) `(nnmaildir--subdir ,dir "nov"))
-(defmacro nnmaildir--marks-dir (dir) `(nnmaildir--subdir ,dir "marks"))
-(defmacro nnmaildir--num-dir   (dir) `(nnmaildir--subdir ,dir "num"))
+(defsubst nnmaildir--subdir (dir subdir)
+  (file-name-as-directory (concat dir subdir)))
+(defsubst nnmaildir--srvgrp-dir (srv-dir gname)
+  (nnmaildir--subdir srv-dir gname))
+(defsubst nnmaildir--tmp       (dir) (nnmaildir--subdir dir "tmp"))
+(defsubst nnmaildir--new       (dir) (nnmaildir--subdir dir "new"))
+(defsubst nnmaildir--cur       (dir) (nnmaildir--subdir dir "cur"))
+(defsubst nnmaildir--nndir     (dir) (nnmaildir--subdir dir ".nnmaildir"))
+(defsubst nnmaildir--nov-dir   (dir) (nnmaildir--subdir dir "nov"))
+(defsubst nnmaildir--marks-dir (dir) (nnmaildir--subdir dir "marks"))
+(defsubst nnmaildir--num-dir   (dir) (nnmaildir--subdir dir "num"))
 
 (defmacro nnmaildir--unlink (file-arg)
   `(let ((file ,file-arg))
@@ -305,6 +369,7 @@ by nnmaildir-request-article.")
   string)
 
 (defmacro nnmaildir--condcase (errsym body &rest handler)
+  (declare (debug (sexp form body)))
   `(condition-case ,errsym
        (let ((system-messages-locale "C")) ,body)
      (error . ,handler)))
@@ -759,7 +824,7 @@ by nnmaildir-request-article.")
           (dolist (file  (funcall ls ndir nil "\\`[^.]" 'nosort))
             (setq x (concat ndir file))
             (and (time-less-p (nth 5 (file-attributes x)) (current-time))
-                 (rename-file x (concat cdir file ":2,"))))
+                 (rename-file x (concat cdir (nnmaildir--ensure-suffix file)))))
           (setf (nnmaildir--grp-new group) nattr))
         (setq cattr (nth 5 (file-attributes cdir)))
         (if (equal cattr (nnmaildir--grp-cur group))
@@ -784,11 +849,23 @@ by nnmaildir-request-article.")
                 cdir (nnmaildir--marks-dir nndir)
                 ndir (nnmaildir--subdir cdir "tick")
                 cdir (nnmaildir--subdir cdir "read"))
-          (dolist (file files)
-            (setq file (car file))
-            (if (or (not (file-exists-p (concat cdir file)))
-                    (file-exists-p (concat ndir file)))
-                (setq num (1+ num)))))
+          (dolist (prefix-suffix files)
+            (let ((prefix (car prefix-suffix))
+                  (suffix (cdr prefix-suffix)))
+              ;; increase num for each unread or ticked article
+              (when (or
+                     ;; first look for marks in suffix, if it's valid...
+                     (when (and (stringp suffix)
+                                (gnus-string-prefix-p ":2," suffix))
+                       (or
+                        (not (gnus-string-match-p
+                              (string (nnmaildir--mark-to-flag 'read)) suffix))
+                        (gnus-string-match-p
+                         (string (nnmaildir--mark-to-flag 'tick)) suffix)))
+                     ;; then look in marks directories
+                     (not (file-exists-p (concat cdir prefix)))
+                     (file-exists-p (concat ndir prefix)))
+                (incf num)))))
         (setf (nnmaildir--grp-cache group) (make-vector num nil))
         (let ((inhibit-quit t))
           (set (intern gname groups) group))
@@ -916,12 +993,15 @@ by nnmaildir-request-article.")
                   "\n")))))
   'group)
 
-(defun nnmaildir-request-marks (gname info &optional server)
-  (let ((group (nnmaildir--prepare server gname))
-        pgname flist always-marks never-marks old-marks dotfile num dir
-        markdirs marks mark ranges markdir article read end new-marks ls
-        old-mmth new-mmth mtime mark-sym existing missing deactivate-mark
-        article-list)
+(defun nnmaildir-request-update-info (gname info &optional server)
+  (let* ((group (nnmaildir--prepare server gname))
+         (curdir (nnmaildir--cur
+                  (nnmaildir--srvgrp-dir
+                   (nnmaildir--srv-dir nnmaildir--cur-server) gname)))
+         (curdir-mtime (nth 5 (file-attributes curdir)))
+         pgname flist always-marks never-marks old-marks dotfile num dir
+         all-marks marks mark ranges markdir read end new-marks ls
+         old-mmth new-mmth mtime mark-sym existing missing deactivate-mark)
     (catch 'return
       (unless group
         (setf (nnmaildir--srv-error nnmaildir--cur-server)
@@ -950,34 +1030,71 @@ by nnmaildir-request-article.")
             dir (nnmaildir--nndir dir)
             dir (nnmaildir--marks-dir dir)
             ls (nnmaildir--group-ls nnmaildir--cur-server pgname)
-            markdirs (funcall ls dir nil "\\`[^.]" 'nosort)
-            new-mmth (nnmaildir--up2-1 (length markdirs))
+            all-marks (gnus-delete-duplicates
+                       ;; get mark names from mark dirs and from flag
+                       ;; mappings
+                       (append
+                        (mapcar 'cdr nnmaildir-flag-mark-mapping)
+                        (mapcar 'intern (funcall ls dir nil "\\`[^.]" 'nosort))))
+            new-mmth (nnmaildir--up2-1 (length all-marks))
             new-mmth (make-vector new-mmth 0)
             old-mmth (nnmaildir--grp-mmth group))
-      (dolist (mark markdirs)
-        (setq markdir (nnmaildir--subdir dir mark)
-              mark-sym (intern mark)
+      (dolist (mark all-marks)
+        (setq markdir (nnmaildir--subdir dir (symbol-name mark))
               ranges nil)
         (catch 'got-ranges
-          (if (memq mark-sym never-marks) (throw 'got-ranges nil))
-          (when (memq mark-sym always-marks)
+          (if (memq mark never-marks) (throw 'got-ranges nil))
+          (when (memq mark always-marks)
             (setq ranges existing)
             (throw 'got-ranges nil))
-          (setq mtime (nth 5 (file-attributes markdir)))
-          (set (intern mark new-mmth) mtime)
-          (when (equal mtime (symbol-value (intern-soft mark old-mmth)))
-            (setq ranges (assq mark-sym old-marks))
+          ;; Find the mtime for this mark.  If this mark can be expressed as
+          ;; a filename flag, get the later of the mtimes for markdir and
+          ;; curdir, otherwise only the markdir counts.
+          (setq mtime
+                (let ((markdir-mtime (nth 5 (file-attributes markdir))))
+                  (cond
+                   ((null (nnmaildir--mark-to-flag mark))
+                    markdir-mtime)
+                   ((null markdir-mtime)
+                    curdir-mtime)
+                   ((null curdir-mtime)
+                    ;; this should never happen...
+                    markdir-mtime)
+                   ((time-less-p markdir-mtime curdir-mtime)
+                    curdir-mtime)
+                   (t
+                    markdir-mtime))))
+          (set (intern (symbol-name mark) new-mmth) mtime)
+          (when (equal mtime (symbol-value (intern-soft (symbol-name mark) old-mmth)))
+            (setq ranges (assq mark old-marks))
             (if ranges (setq ranges (cdr ranges)))
             (throw 'got-ranges nil))
-          (setq article-list nil)
-          (dolist (prefix (funcall ls markdir nil "\\`[^.]" 'nosort))
-            (setq article (nnmaildir--flist-art flist prefix))
-            (if article
-                (setq article-list
-                      (cons (nnmaildir--art-num article) article-list))))
-          (setq ranges (gnus-add-to-range ranges (sort article-list '<))))
-        (if (eq mark-sym 'read) (setq read ranges)
-          (if ranges (setq marks (cons (cons mark-sym ranges) marks)))))
+          (let ((article-list nil))
+            ;; Consider the article marked if it either has the flag in the
+            ;; filename, or is in the markdir.  As you'd rarely remove a
+            ;; flag/mark, this should avoid losing information in the most
+            ;; common usage pattern.
+            (or
+             (let ((flag (nnmaildir--mark-to-flag mark)))
+               ;; If this mark has a corresponding maildir flag...
+               (when flag
+                 (let ((regexp
+                        (concat "\\`[^.].*:2,[A-Z]*" (string flag))))
+                   ;; ...then find all files with that flag.
+                   (dolist (filename (funcall ls curdir nil regexp 'nosort))
+                     (let* ((prefix (car (split-string filename ":2,")))
+                            (article (nnmaildir--flist-art flist prefix)))
+                       (when article
+                         (push (nnmaildir--art-num article) article-list)))))))
+             ;; Also check Gnus-specific mark directory, if it exists.
+             (when (file-directory-p markdir)
+               (dolist (prefix (funcall ls markdir nil "\\`[^.]" 'nosort))
+                 (let ((article (nnmaildir--flist-art flist prefix)))
+                   (when article
+                     (push (nnmaildir--art-num article) article-list))))))
+            (setq ranges (gnus-add-to-range ranges (sort article-list '<)))))
+        (if (eq mark 'read) (setq read ranges)
+          (if ranges (setq marks (cons (cons mark ranges) marks)))))
       (gnus-info-set-read info (gnus-range-add read missing))
       (gnus-info-set-marks info marks 'extend)
       (setf (nnmaildir--grp-mmth group) new-mmth)
@@ -1525,39 +1642,63 @@ by nnmaildir-request-article.")
       didnt)))
 
 (defun nnmaildir-request-set-mark (gname actions &optional server)
-  (let ((group (nnmaildir--prepare server gname))
-        (coding-system-for-write nnheader-file-coding-system)
-        (buffer-file-coding-system nil)
-        (file-coding-system-alist nil)
-        del-mark del-action add-action set-action marksdir nlist
-        ranges begin end article all-marks todo-marks mdir mfile
-        pgname ls permarkfile deactivate-mark)
+  (let* ((group (nnmaildir--prepare server gname))
+         (curdir (nnmaildir--cur
+                  (nnmaildir--srvgrp-dir
+                   (nnmaildir--srv-dir nnmaildir--cur-server)
+                   gname)))
+         (coding-system-for-write nnheader-file-coding-system)
+         (buffer-file-coding-system nil)
+         (file-coding-system-alist nil)
+         del-mark del-action add-action set-action marksdir nlist
+         ranges begin end article all-marks todo-marks mdir mfile
+         pgname ls permarkfile deactivate-mark)
     (setq del-mark
           (lambda (mark)
-            (setq mfile (nnmaildir--subdir marksdir (symbol-name mark))
-                  mfile (concat mfile (nnmaildir--art-prefix article)))
-            (nnmaildir--unlink mfile))
+            (let ((prefix (nnmaildir--art-prefix article))
+                  (suffix (nnmaildir--art-suffix article))
+                  (flag (nnmaildir--mark-to-flag mark)))
+              (when flag
+                ;; If this mark corresponds to a flag, remove the flag from
+                ;; the file name.
+                (nnmaildir--article-set-flags
+                 article (nnmaildir--remove-flag flag suffix) curdir))
+              ;; We still want to delete the hardlink in the marks dir if
+              ;; present, regardless of whether this mark has a maildir flag or
+              ;; not, to avoid getting out of sync.
+              (setq mfile (nnmaildir--subdir marksdir (symbol-name mark))
+                    mfile (concat mfile prefix))
+              (nnmaildir--unlink mfile)))
           del-action (lambda (article) (mapcar del-mark todo-marks))
           add-action
           (lambda (article)
             (mapcar
              (lambda (mark)
-               (setq mdir (nnmaildir--subdir marksdir (symbol-name mark))
-                     permarkfile (concat mdir ":")
-                     mfile (concat mdir (nnmaildir--art-prefix article)))
-               (nnmaildir--condcase err (add-name-to-file permarkfile mfile)
-                 (cond
-                  ((nnmaildir--eexist-p err))
-                  ((nnmaildir--enoent-p err)
-                   (nnmaildir--mkdir mdir)
-                   (nnmaildir--mkfile permarkfile)
-                   (add-name-to-file permarkfile mfile))
-                  ((nnmaildir--emlink-p err)
-                   (let ((permarkfilenew (concat permarkfile "{new}")))
-                     (nnmaildir--mkfile permarkfilenew)
-                     (rename-file permarkfilenew permarkfile 'replace)
-                     (add-name-to-file permarkfile mfile)))
-                  (t (signal (car err) (cdr err))))))
+               (let ((prefix (nnmaildir--art-prefix article))
+                     (suffix (nnmaildir--art-suffix article))
+                     (flag (nnmaildir--mark-to-flag mark)))
+                 (if flag
+                     ;; If there is a corresponding maildir flag, just rename
+                     ;; the file.
+                     (nnmaildir--article-set-flags
+                      article (nnmaildir--add-flag flag suffix) curdir)
+                   ;; Otherwise, use nnmaildir-specific marks dir.
+                   (setq mdir (nnmaildir--subdir marksdir (symbol-name mark))
+                         permarkfile (concat mdir ":")
+                         mfile (concat mdir prefix))
+                   (nnmaildir--condcase err (add-name-to-file permarkfile mfile)
+                     (cond
+                      ((nnmaildir--eexist-p err))
+                      ((nnmaildir--enoent-p err)
+                       (nnmaildir--mkdir mdir)
+                       (nnmaildir--mkfile permarkfile)
+                       (add-name-to-file permarkfile mfile))
+                      ((nnmaildir--emlink-p err)
+                       (let ((permarkfilenew (concat permarkfile "{new}")))
+                         (nnmaildir--mkfile permarkfilenew)
+                         (rename-file permarkfilenew permarkfile 'replace)
+                         (add-name-to-file permarkfile mfile)))
+                      (t (signal (car err) (cdr err))))))))
              todo-marks))
           set-action (lambda (article)
                        (funcall add-action article)
@@ -1581,7 +1722,12 @@ by nnmaildir-request-article.")
             pgname (nnmaildir--pgname nnmaildir--cur-server gname)
             ls (nnmaildir--group-ls nnmaildir--cur-server pgname)
             all-marks (funcall ls marksdir nil "\\`[^.]" 'nosort)
-            all-marks (mapcar 'intern all-marks))
+            all-marks (gnus-delete-duplicates
+                       ;; get mark names from mark dirs and from flag
+                       ;; mappings
+                       (append
+                        (mapcar 'cdr nnmaildir-flag-mark-mapping)
+                        (mapcar 'intern all-marks))))
       (dolist (action actions)
         (setq ranges (car action)
               todo-marks (caddr action))
diff --git a/lisp/gnus/qp.el b/lisp/gnus/qp.el
index 87252684a48..c4487c68b5c 100644
--- a/lisp/gnus/qp.el
+++ b/lisp/gnus/qp.el
@@ -53,10 +53,7 @@ them into characters should be done separately."
       ;; or both of which are lowercase letters in "abcdef", is
       ;; formally illegal. A robust implementation might choose to
       ;; recognize them as the corresponding uppercase letters.''
-      (let ((case-fold-search t)
-            (decode-hex #'(lambda (n1 n2)
-                            (+ (* (if (<= n1 ?9) (- n1 ?0) (+ (- n1 ?A) 10)) 16)
-                               (if (<= n2 ?9) (- n2 ?0) (+ (- n2 ?A) 10))))))
+      (let ((case-fold-search t))
         (narrow-to-region from to)
         ;; Do this in case we're called from Gnus, say, in a buffer
         ;; which already contains non-ASCII characters which would
@@ -74,8 +71,15 @@ them into characters should be done separately."
                  (let* ((n (/ (- (match-end 0) (point)) 3))
                         (str (make-string n 0)))
                    (dotimes (i n)
-                     (aset str i (funcall decode-hex (char-after (1+ (point)))
-                                          (char-after (+ 2 (point)))))
+                     (let ((n1 (char-after (1+ (point))))
+                           (n2 (char-after (+ 2 (point)))))
+                       (aset str i
+                             (+ (* 16 (- n1 (if (<= n1 ?9) ?0
+                                              (if (<= n1 ?F) (- ?A 10)
+                                                (- ?a 10)))))
+                                (- n2 (if (<= n2 ?9) ?0
+                                        (if (<= n2 ?F) (- ?A 10)
+                                          (- ?a 10)))))))
                      (forward-char 3))
                    (delete-region (match-beginning 0) (match-end 0))
                    (insert str)))
diff --git a/lisp/help.el b/lisp/help.el
index 9740f8996c1..da11389d87c 100644
--- a/lisp/help.el
+++ b/lisp/help.el
@@ -585,6 +585,8 @@ temporarily enables it to allow getting help on disabled items and buttons."
              (setq saved-yank-menu (copy-sequence yank-menu))
              (menu-bar-update-yank-menu "(any string)" nil))
            (setq key (read-key-sequence "Describe key (or click or menu item): "))
+           ;; Clear the echo area message (Bug#7014).
+           (message nil)
            ;; If KEY is a down-event, read and discard the
            ;; corresponding up-event.  Note that there are also
            ;; down-events on scroll bars and mode lines: the actual
@@ -962,7 +964,11 @@ is currently activated with completion."
     result))
 
 ;;; Automatic resizing of temporary buffers.
-(defcustom temp-buffer-max-height (lambda (buffer) (/ (- (frame-height) 2) 2))
+(defcustom temp-buffer-max-height
+  (lambda (buffer)
+    (if (eq (selected-window) (frame-root-window))
+        (/ (x-display-pixel-height) (frame-char-height) 2)
+      (/ (- (frame-height) 2) 2)))
   "Maximum height of a window displaying a temporary buffer.
 This is effective only when Temp Buffer Resize mode is enabled.
 The value is the maximum height (in lines) which
@@ -973,7 +979,16 @@ buffer, and should return a positive integer.  At the time the
 function is called, the window to be resized is selected."
   :type '(choice integer function)
   :group 'help
-  :version "20.4")
+  :version "24.2")
+
+(defcustom temp-buffer-resize-frames nil
+  "Non-nil means `temp-buffer-resize-mode' can resize frames.
+A frame can be resized if and only if its root window is a live
+window.  The height of the root window is subject to the values of
+`temp-buffer-max-height' and `window-min-height'."
+  :type 'boolean
+  :version "24.2"
+  :group 'help)
 
 (define-minor-mode temp-buffer-resize-mode
   "Toggle auto-resizing temporary buffer windows (Temp Buffer Resize Mode).
@@ -1008,9 +1023,21 @@ view."
                     (with-selected-window window
                       (funcall temp-buffer-max-height (window-buffer)))
                   temp-buffer-max-height)))
-    (when (and (pos-visible-in-window-p (point-min) window)
-               (window-combined-p window))
-      (fit-window-to-buffer window height))))
+    (cond
+     ((and (pos-visible-in-window-p (point-min) window)
+           (window-combined-p window))
+      (fit-window-to-buffer window height))
+     ((and temp-buffer-resize-frames
+           (eq window (frame-root-window window))
+           (memq (car (window-parameter window 'quit-restore))
+                 ;; If 'same is too strong, we might additionally check
+                 ;; whether the second element is 'frame.
+                 '(same frame)))
+      (let ((frame (window-frame window)))
+        (fit-frame-to-buffer
+         frame (+ (frame-height frame)
+                  (- (window-total-size window))
+                  height)))))))
 
 ;;; Help windows.
 (defcustom help-window-select 'other
diff --git a/lisp/isearch.el b/lisp/isearch.el
index e6e0a01566a..04f5a7acc2c 100644
--- a/lisp/isearch.el
+++ b/lisp/isearch.el
@@ -1405,6 +1405,7 @@ Use `isearch-exit' to quit without signaling."
   (interactive)
   (setq isearch-word (unless (eq isearch-word 'isearch-symbol-regexp)
                        'isearch-symbol-regexp))
+  (if isearch-word (setq isearch-regexp nil))
   (setq isearch-success t isearch-adjusted t)
   (isearch-update))
 
@@ -1579,14 +1580,10 @@ way to run word replacements from Isearch is `M-s w ... M-%'."
         ;; set `search-upper-case' to nil to not call
         ;; `isearch-no-upper-case-p' in `perform-replace'
         (search-upper-case nil)
-        (replace-search-function
-         (if (and isearch-lax-whitespace (not regexp-flag))
-             #'search-forward-lax-whitespace
-           replace-search-function))
-        (replace-re-search-function
-         (if (and isearch-regexp-lax-whitespace regexp-flag)
-             #'re-search-forward-lax-whitespace
-           replace-re-search-function))
+        (replace-lax-whitespace
+         isearch-lax-whitespace)
+        (replace-regexp-lax-whitespace
+         isearch-regexp-lax-whitespace)
         ;; Set `isearch-recursive-edit' to nil to prevent calling
         ;; `exit-recursive-edit' in `isearch-done' that terminates
         ;; the execution of this command when it is non-nil.
@@ -2956,10 +2953,14 @@ Attempt to do the search exactly the way the pending Isearch would."
       (let ((case-fold-search isearch-lazy-highlight-case-fold-search)
             (isearch-regexp isearch-lazy-highlight-regexp)
             (isearch-word isearch-lazy-highlight-word)
+            (isearch-lax-whitespace
+             isearch-lazy-highlight-lax-whitespace)
+            (isearch-regexp-lax-whitespace
+             isearch-lazy-highlight-regexp-lax-whitespace)
+            (isearch-forward isearch-lazy-highlight-forward)
             (search-invisible nil)      ; don't match invisible text
             (retry t)
             (success nil)
-            (isearch-forward isearch-lazy-highlight-forward)
             (bound (if isearch-lazy-highlight-forward
                        (min (or isearch-lazy-highlight-end-limit (point-max))
                             (if isearch-lazy-highlight-wrapped
diff --git a/lisp/loadup.el b/lisp/loadup.el
index a460fcab339..d389427bafd 100644
--- a/lisp/loadup.el
+++ b/lisp/loadup.el
@@ -102,6 +102,19 @@
 (setq load-source-file-function 'load-with-code-conversion)
 (load "files")
 
+;; Load-time macro-expansion can only take effect after setting
+;; load-source-file-function because of where it is called in lread.c.
+(load "emacs-lisp/macroexp")
+(if (byte-code-function-p (symbol-function 'macroexpand-all))
+    nil
+  ;; Since loaddefs is not yet loaded, macroexp's uses of pcase will simply
+  ;; fail until pcase is explicitly loaded.  This also means that we have to
+  ;; disable eager macro-expansion while loading pcase.
+  (let ((macroexp--pending-eager-loads '(skip)))
+    (load "emacs-lisp/pcase"))
+  ;; Re-load macroexp so as to eagerly macro-expand its uses of pcase.
+  (load "emacs-lisp/macroexp"))
+
 (load "cus-face")
 (load "faces")  ; after here, `defface' may be used.
 
@@ -266,21 +279,6 @@
 ;For other systems, you must edit ../src/Makefile.in.
 (load "site-load" t)
 
-;; ¡¡¡ Big Ugly Hack !!!
-;; src/bootstrap-emacs is mostly used to compile .el files, so it needs
-;; macroexp, bytecomp, cconv, and byte-opt to be fast.  Generally this is done
-;; by compiling those files first, but this only makes a difference if those
-;; files are not preloaded.  As it so happens, macroexp.el tends to be
-;; accidentally preloaded in src/bootstrap-emacs because cl.el and cl-macs.el
-;; require it.  So let's unload it here, if needed, to make sure the
-;; byte-compiled version is used.
-(if (or (not (fboundp 'macroexpand-all))
-        (byte-code-function-p (symbol-function 'macroexpand-all)))
-    nil
-  (fmakunbound 'macroexpand-all)
-  (setq features (delq 'macroexp features))
-  (autoload 'macroexpand-all "macroexp"))
-
 ;; Determine which last version number to use
 ;; based on the executables that now exist.
 (if (and (or (equal (nth 3 command-line-args) "dump")
diff --git a/lisp/mail/smtpmail.el b/lisp/mail/smtpmail.el
index 804fe7a8798..69a405436a7 100644
--- a/lisp/mail/smtpmail.el
+++ b/lisp/mail/smtpmail.el
@@ -200,10 +200,10 @@ The list is in preference order.")
         ;; local binding in the mail buffer will take effect.
         (smtpmail-mail-address
          (or (and mail-specify-envelope-from (mail-envelope-from))
-             (smtpmail-user-mail-address)
-             (let ((from (mail-fetch-field "from")))
+             (let ((from (mail-fetch-field "from")))
                (and from
-                    (cadr (mail-extract-address-components from))))))
+                    (cadr (mail-extract-address-components from))))
+             (smtpmail-user-mail-address)))
         (smtpmail-code-conv-from
          (if enable-multibyte-characters
              (let ((sendmail-coding-system smtpmail-code-conv-from))
@@ -653,12 +653,10 @@ Returns an error if the server cannot be contacted."
          (or smtpmail-mail-address
              (and mail-specify-envelope-from
                   (mail-envelope-from))
-             (smtpmail-user-mail-address)
-             ;; Fall back on the From: header as the envelope From
-             ;; address.
              (let ((from (mail-fetch-field "from")))
                (and from
-                    (cadr (mail-extract-address-components from))))))
+                    (cadr (mail-extract-address-components from))))
+             (smtpmail-user-mail-address)))
         response-code
         process-buffer
         result
diff --git a/lisp/net/browse-url.el b/lisp/net/browse-url.el
index f7aa5f8ed52..8daf339d376 100644
--- a/lisp/net/browse-url.el
+++ b/lisp/net/browse-url.el
@@ -744,7 +744,7 @@ narrowed."
     (and buffer (set-buffer buffer))
     (let ((file-name
            ;; Ignore real name if restricted
-           (and (= (- (point-max) (point-min)) (buffer-size))
+           (and (not (buffer-narrowed-p))
                 (or buffer-file-name
                     (and (boundp 'dired-directory) dired-directory)))))
       (or file-name
diff --git a/lisp/play/blackbox.el b/lisp/play/blackbox.el
index db2e18188e5..16189600156 100644
--- a/lisp/play/blackbox.el
+++ b/lisp/play/blackbox.el
@@ -97,7 +97,9 @@
   (let ((map (make-keymap)))
     (suppress-keymap map t)
     (blackbox-redefine-key map 'backward-char 'bb-left)
+    (blackbox-redefine-key map 'left-char 'bb-left)
     (blackbox-redefine-key map 'forward-char 'bb-right)
+    (blackbox-redefine-key map 'right-char 'bb-right)
     (blackbox-redefine-key map 'previous-line 'bb-up)
     (blackbox-redefine-key map 'next-line 'bb-down)
     (blackbox-redefine-key map 'move-end-of-line 'bb-eol)
diff --git a/lisp/progmodes/cc-cmds.el b/lisp/progmodes/cc-cmds.el
index 7cd0a0b0ae2..eec6873dc19 100644
--- a/lisp/progmodes/cc-cmds.el
+++ b/lisp/progmodes/cc-cmds.el
@@ -493,13 +493,16 @@ inside a literal or a macro, nothing special happens."
       (insert-char ?\n 1)
       ;; In AWK (etc.) or in a macro, make sure this CR hasn't changed
       ;; the syntax.  (There might already be an escaped NL there.)
-      (when (or (c-at-vsemi-p (1- (point)))
-                (let ((pt (point)))
-                  (save-excursion
-                    (backward-char)
-                    (and (c-beginning-of-macro)
-                         (progn (c-end-of-macro)
-                                (< (point) pt))))))
+      (when (or
+             (save-excursion
+               (c-skip-ws-backward (c-point 'bopl))
+               (c-at-vsemi-p))
+             (let ((pt (point)))
+               (save-excursion
+                 (backward-char)
+                 (and (c-beginning-of-macro)
+                      (progn (c-end-of-macro)
+                             (< (point) pt))))))
         (backward-char)
         (insert-char ?\\ 1)
         (forward-char))
diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index 142ec4cdd66..2aa04cb2b0b 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -3091,6 +3091,8 @@ comment at the start of cc-engine.el for more info."
         c-state-cache-good-pos 1
         c-state-nonlit-pos-cache nil
         c-state-nonlit-pos-cache-limit 1
+        c-state-semi-nonlit-pos-cache nil
+        c-state-semi-nonlit-pos-cache-limit 1
         c-state-brace-pair-desert nil
         c-state-point-min 1
         c-state-point-min-lit-type nil
@@ -3350,6 +3352,8 @@ comment at the start of cc-engine.el for more info."
            c-state-cache-good-pos
            c-state-nonlit-pos-cache
            c-state-nonlit-pos-cache-limit
+           c-state-semi-nonlit-pos-cache
+           c-state-semi-nonlit-pos-cache-limit
            c-state-brace-pair-desert
            c-state-point-min
            c-state-point-min-lit-type
@@ -9579,12 +9583,12 @@ comment at the start of cc-engine.el for more info."
                              (setq tmpsymbol nil)
                              (while (and (> (point) placeholder)
                                          (zerop (c-backward-token-2 1 t))
-                                         (/= (char-after) ?=))
+                                         (not (looking-at "=\\([^=]\\|$\\)")))
                                (and c-opt-inexpr-brace-list-key
                                     (not tmpsymbol)
                                     (looking-at c-opt-inexpr-brace-list-key)
                                     (setq tmpsymbol 'topmost-intro-cont)))
-                             (eq (char-after) ?=))
+                             (looking-at "=\\([^=]\\|$\\)"))
                            (looking-at c-brace-list-key))
                        (save-excursion
                          (while (and (< (point) indent-point)
diff --git a/lisp/progmodes/flymake.el b/lisp/progmodes/flymake.el
index ad285274928..10d5fdf9c64 100644
--- a/lisp/progmodes/flymake.el
+++ b/lisp/progmodes/flymake.el
@@ -977,6 +977,9 @@ from compile.el")
 ;;   :type '(repeat (string number number number))
 ;;)
 
+(defvar flymake-warning-re "^[wW]arning"
+  "Regexp matching against err-text to detect a warning.")
+
 (defun flymake-parse-line (line)
   "Parse LINE to see if it is an error or warning.
 Return its components if so, nil otherwise."
@@ -997,7 +1000,7 @@ Return its components if so, nil otherwise."
                                   (match-string (nth 4 (car patterns)) line)
                                 (flymake-patch-err-text (substring line (match-end 0)))))
           (or err-text (setq err-text "<no error text>"))
-          (if (and err-text (string-match "^[wW]arning" err-text))
+          (if (and err-text (string-match flymake-warning-re err-text))
               (setq err-type "w")
             )
           (flymake-log 3 "parse line: file-idx=%s line-idx=%s file=%s line=%s text=%s" file-idx line-idx
diff --git a/lisp/progmodes/python.el b/lisp/progmodes/python.el
index 601850ed0fb..ffc6c1ac885 100644
--- a/lisp/progmodes/python.el
+++ b/lisp/progmodes/python.el
@@ -1824,7 +1824,11 @@ When MSG is non-nil messages the first line of STRING."
         (lines (split-string string "\n" t)))
     (and msg (message "Sent: %s..." (nth 0 lines)))
     (if (> (length lines) 1)
-        (let* ((temp-file-name (make-temp-file "py"))
+        (let* ((temporary-file-directory
+                (if (file-remote-p default-directory)
+                    (concat (file-remote-p default-directory) "/tmp")
+                  temporary-file-directory))
+               (temp-file-name (make-temp-file "py"))
                (file-name (or (buffer-file-name) temp-file-name)))
           (with-temp-file temp-file-name
             (insert string)
@@ -1931,8 +1935,14 @@ FILE-NAME."
   (interactive "fFile to send: ")
   (let* ((process (or process (python-shell-get-or-create-process)))
          (temp-file-name (when temp-file-name
-                           (expand-file-name temp-file-name)))
-         (file-name (or (expand-file-name file-name) temp-file-name)))
+                           (expand-file-name
+                            (or (file-remote-p temp-file-name 'localname)
+                                temp-file-name))))
+         (file-name (or (when file-name
+                          (expand-file-name
+                           (or (file-remote-p file-name 'localname)
+                               file-name)))
+                        temp-file-name)))
     (when (not file-name)
       (error "If FILE-NAME is nil then TEMP-FILE-NAME must be non-nil"))
     (python-shell-send-string
diff --git a/lisp/progmodes/ruby-mode.el b/lisp/progmodes/ruby-mode.el
index 457c7fee36c..77ec8084ea2 100644
--- a/lisp/progmodes/ruby-mode.el
+++ b/lisp/progmodes/ruby-mode.el
@@ -64,8 +64,8 @@
   "Regexp to match keywords that nest without blocks.")
 
 (defconst ruby-indent-beg-re
-  (concat "\\(\\s *" (regexp-opt '("class" "module" "def") t) "\\)\\|"
-          (regexp-opt '("if" "unless" "case" "while" "until" "for" "begin")))
+  (concat "^\\s *" (regexp-opt '("class" "module" "def" "if" "unless" "case"
+                                 "while" "until" "for" "begin")) "\\_>")
   "Regexp to match where the indentation gets deeper.")
 
 (defconst ruby-modifier-beg-keywords
@@ -98,6 +98,10 @@
 
 (defconst ruby-block-end-re "\\_<end\\_>")
 
+(defconst ruby-defun-beg-re
+  '"\\(def\\|class\\|module\\)"
+  "Regexp to match the beginning of a defun, in the general sense.")
+
 (eval-and-compile
   (defconst ruby-here-doc-beg-re
   "\\(<\\)<\\(-\\)?\\(\\([a-zA-Z0-9_]+\\)\\|[\"]\\([^\"]+\\)[\"]\\|[']\\([^']+\\)[']\\)"
@@ -138,18 +142,11 @@ This should only be called after matching against `ruby-here-doc-beg-re'."
 
 (defvar ruby-mode-map
   (let ((map (make-sparse-keymap)))
-    (define-key map "{" 'ruby-electric-brace)
-    (define-key map "}" 'ruby-electric-brace)
-    (define-key map (kbd "M-C-a") 'ruby-beginning-of-defun)
-    (define-key map (kbd "M-C-e") 'ruby-end-of-defun)
     (define-key map (kbd "M-C-b") 'ruby-backward-sexp)
     (define-key map (kbd "M-C-f") 'ruby-forward-sexp)
     (define-key map (kbd "M-C-p") 'ruby-beginning-of-block)
     (define-key map (kbd "M-C-n") 'ruby-end-of-block)
-    (define-key map (kbd "M-C-h") 'ruby-mark-defun)
     (define-key map (kbd "M-C-q") 'ruby-indent-exp)
-    (define-key map (kbd "C-M-h") 'backward-kill-word)
-    (define-key map (kbd "C-j")   'reindent-then-newline-and-indent)
     (define-key map (kbd "C-c {") 'ruby-toggle-block)
     map)
   "Keymap used in Ruby mode.")
@@ -840,20 +837,13 @@ and `\\' when preceded by `?'."
           (+ indent ruby-indent-level)
         indent))))
 
-(defun ruby-electric-brace (arg)
-  "Insert a brace and re-indent the current line."
-  (interactive "P")
-  (self-insert-command (prefix-numeric-value arg))
-  (ruby-indent-line t))
-
-;; TODO: Why isn't one ruby-*-of-defun written in terms of the other?
 (defun ruby-beginning-of-defun (&optional arg)
   "Move backward to the beginning of the current top-level defun.
 With ARG, move backward multiple defuns.  Negative ARG means
 move forward."
   (interactive "p")
-  (and (re-search-backward (concat "^\\(" ruby-block-beg-re "\\)\\b")
-                           nil 'move (or arg 1))
+  (and (re-search-backward (concat "^\\s *" ruby-defun-beg-re "\\_>")
+                           nil t (or arg 1))
        (beginning-of-line)))
 
 (defun ruby-end-of-defun (&optional arg)
@@ -861,19 +851,18 @@ move forward."
 With ARG, move forward multiple defuns.  Negative ARG means
 move backward."
   (interactive "p")
-  (and (re-search-forward (concat "^\\(" ruby-block-end-re "\\)\\($\\|\\b[^_]\\)")
-                          nil 'move (or arg 1))
-       (beginning-of-line))
-  (forward-line 1))
+  (ruby-forward-sexp)
+  (when (looking-back (concat "^\\s *" ruby-block-end-re))
+    (forward-line 1)))
 
 (defun ruby-beginning-of-indent ()
-  "TODO: document"
-  ;; I don't understand this function.
-  ;; It seems like it should move to the line where indentation should deepen,
-  ;; but ruby-indent-beg-re only accounts for whitespace before class, module and def,
-  ;; so this will only match other block beginners at the beginning of the line.
-  (and (re-search-backward (concat "^\\(" ruby-indent-beg-re "\\)\\_>") nil 'move)
-       (beginning-of-line)))
+  "Backtrack to a line which can be used as a reference for
+calculating indentation on the lines after it."
+  (while (and (re-search-backward ruby-indent-beg-re nil 'move)
+              (if (ruby-in-ppss-context-p 'anything)
+                  t
+                ;; We can stop, then.
+                (beginning-of-line)))))
 
 (defun ruby-move-to-block (n)
   "Move to the beginning (N < 0) or the end (N > 0) of the current block
@@ -1024,15 +1013,6 @@ With ARG, do it many times.  Negative ARG means move forward."
         ((error)))
       i)))
 
-(defun ruby-mark-defun ()
-  "Put mark at end of this Ruby function, point at beginning."
-  (interactive)
-  (push-mark (point))
-  (ruby-end-of-defun)
-  (push-mark (point) nil t)
-  (ruby-beginning-of-defun)
-  (re-search-backward "^\n" (- (point) 1) t))
-
 (defun ruby-indent-exp (&optional ignored)
   "Indent each line in the balanced expression following the point."
   (interactive "*P")
@@ -1073,7 +1053,7 @@ See `add-log-current-defun-function'."
         (let (mname mlist (indent 0))
           ;; get current method (or class/module)
           (if (re-search-backward
-               (concat "^[ \t]*\\(def\\|class\\|module\\)[ \t]+"
+               (concat "^[ \t]*" ruby-defun-beg-re "[ \t]+"
                        "\\("
                        ;; \\. and :: for class method
                         "\\([A-Za-z_]" ruby-symbol-re "*\\|\\.\\|::" "\\)"
@@ -1127,46 +1107,65 @@ See `add-log-current-defun-function'."
               (if mlist (concat mlist mname) mname)
             mlist)))))
 
-(defun ruby-brace-to-do-end ()
-  (when (looking-at "{")
-    (let ((orig (point)) (end (progn (ruby-forward-sexp) (point))))
-      (when (eq (char-before) ?\})
-        (delete-char -1)
-        (if (eq (char-syntax (char-before)) ?w)
-            (insert " "))
-        (insert "end")
-        (if (eq (char-syntax (char-after)) ?w)
-            (insert " "))
-        (goto-char orig)
-        (delete-char 1)
-        (if (eq (char-syntax (char-before)) ?w)
-            (insert " "))
-        (insert "do")
-        (when (looking-at "\\sw\\||")
-          (insert " ")
-          (backward-char))
-        t))))
-
-(defun ruby-do-end-to-brace ()
-  (when (and (or (bolp)
-                 (not (memq (char-syntax (char-before)) '(?w ?_))))
-             (looking-at "\\<do\\(\\s \\|$\\)"))
-    (let ((orig (point)) (end (progn (ruby-forward-sexp) (point))))
-      (backward-char 3)
-      (when (looking-at ruby-block-end-re)
-        (delete-char 3)
-        (insert "}")
-        (goto-char orig)
-        (delete-char 2)
-        (insert "{")
-        (if (looking-at "\\s +|")
-            (delete-char (- (match-end 0) (match-beginning 0) 1)))
-        t))))
+(defun ruby-brace-to-do-end (orig end)
+  (let (beg-marker end-marker)
+    (goto-char end)
+    (when (eq (char-before) ?\})
+      (delete-char -1)
+      (skip-chars-backward " \t")
+      (when (not (bolp))
+        (insert "\n"))
+      (insert "end")
+      (setq end-marker (point-marker))
+      (when (and (not (eobp)) (eq (char-syntax (char-after)) ?w))
+        (insert " "))
+      (goto-char orig)
+      (delete-char 1)
+      (when (eq (char-syntax (char-before)) ?w)
+        (insert " "))
+      (insert "do")
+      (setq beg-marker (point-marker))
+      (when (looking-at "\\(\\s \\)*|")
+        (unless (match-beginning 1)
+          (insert " "))
+        (goto-char (1+ (match-end 0)))
+        (search-forward "|"))
+      (unless (looking-at "\\s *$")
+        (insert "\n"))
+      (indent-region beg-marker end-marker)
+      (goto-char beg-marker)
+      t)))
+
+(defun ruby-do-end-to-brace (orig end)
+  (goto-char (- end 3))
+  (when (looking-at ruby-block-end-re)
+    (delete-char 3)
+    (insert "}")
+    (goto-char orig)
+    (delete-char 2)
+    (insert "{")
+    (if (looking-at "\\s +|")
+        (delete-char (- (match-end 0) (match-beginning 0) 1)))
+    t))
 
 (defun ruby-toggle-block ()
+  "Toggle block type from do-end to braces or back.
+The block must begin on the current line or above it and end after the point.
+If the result is do-end block, it will always be multiline."
   (interactive)
-  (or (ruby-brace-to-do-end)
-      (ruby-do-end-to-brace)))
+  (let ((start (point)) beg end)
+    (end-of-line)
+    (unless
+        (if (and (re-search-backward "\\({\\)\\|\\_<do\\(\\s \\|$\\||\\)")
+                 (progn
+                   (setq beg (point))
+                   (save-match-data (ruby-forward-sexp))
+                   (setq end (point))
+                   (> end start)))
+            (if (match-beginning 1)
+                (ruby-brace-to-do-end beg end)
+              (ruby-do-end-to-brace beg end)))
+      (goto-char start))))
 
 (declare-function ruby-syntax-propertize-heredoc "ruby-mode" (limit))
 (declare-function ruby-syntax-enclosing-percent-literal "ruby-mode" (limit))
@@ -1193,8 +1192,6 @@ It will be properly highlighted even when the call omits parens."))
         (ruby-syntax-enclosing-percent-literal end)
         (funcall
          (syntax-propertize-rules
-          ;; #{ }, #$hoge, #@foo are not comments.
-          ("\\(#\\)[{$@]" (1 "."))
           ;; $' $" $` .... are variables.
           ;; ?' ?" ?` are ascii codes.
           ("\\([?$]\\)[#\"'`]"
@@ -1326,8 +1323,7 @@ This should only be called after matching against `ruby-here-doc-end-re'."
                   (concat "-?\\([\"']\\|\\)" contents "\\1"))))))
 
   (defconst ruby-font-lock-syntactic-keywords
-    `( ;; #{ }, #$hoge, #@foo are not comments
-    ("\\(#\\)[{$@]" 1 (1 . nil))
+    `(
     ;; the last $', $", $` in the respective string is not variable
     ;; the last ?', ?", ?` in the respective string is not ascii code
     ("\\(^\\|[\[ \t\n<+\(,=]\\)\\(['\"`]\\)\\(\\\\.\\|\\2\\|[^'\"`\n\\\\]\\)*?\\\\?[?$]\\(\\2\\)"
@@ -1549,6 +1545,9 @@ See `font-lock-syntax-table'.")
    ;; variables
    '("\\(^\\|[^_:.@$]\\|\\.\\.\\)\\b\\(nil\\|self\\|true\\|false\\)\\>"
      2 font-lock-variable-name-face)
+   ;; symbols
+   '("\\(^\\|[^:]\\)\\(:\\([-+~]@?\\|[/%&|^`]\\|\\*\\*?\\|<\\(<\\|=>?\\)?\\|>[>=]?\\|===?\\|=~\\|![~=]?\\|\\[\\]=?\\|@?\\(\\w\\|_\\)+\\([!?=]\\|\\b_*\\)\\|#{[^}\n\\\\]*\\(\\\\.[^}\n\\\\]*\\)*}\\)\\)"
+     2 font-lock-reference-face)
    ;; variables
    '("\\(\\$\\([^a-zA-Z0-9 \n]\\|[0-9]\\)\\)\\W"
      1 font-lock-variable-name-face)
@@ -1557,12 +1556,9 @@ See `font-lock-syntax-table'.")
    ;; constants
    '("\\(^\\|[^_]\\)\\b\\([A-Z]+\\(\\w\\|_\\)*\\)"
      2 font-lock-type-face)
-   ;; symbols
-   '("\\(^\\|[^:]\\)\\(:\\([-+~]@?\\|[/%&|^`]\\|\\*\\*?\\|<\\(<\\|=>?\\)?\\|>[>=]?\\|===?\\|=~\\|![~=]?\\|\\[\\]=?\\|\\(\\w\\|_\\)+\\([!?=]\\|\\b_*\\)\\|#{[^}\n\\\\]*\\(\\\\.[^}\n\\\\]*\\)*}\\)\\)"
-     2 font-lock-reference-face)
    '("\\(^\\s *\\|[\[\{\(,]\\s *\\|\\sw\\s +\\)\\(\\(\\sw\\|_\\)+\\):[^:]" 2 font-lock-reference-face)
    ;; expression expansion
-   '("#\\({[^}\n\\\\]*\\(\\\\.[^}\n\\\\]*\\)*}\\|\\(\\$\\|@\\|@@\\)\\(\\w\\|_\\)+\\)"
+   '(ruby-match-expression-expansion
      0 font-lock-variable-name-face t)
    ;; warn lower camel case
                                         ;'("\\<[a-z]+[a-z0-9]*[A-Z][A-Za-z0-9]*\\([!?]?\\|\\>\\)"
@@ -1570,6 +1566,11 @@ See `font-lock-syntax-table'.")
    )
   "Additional expressions to highlight in Ruby mode.")
 
+(defun ruby-match-expression-expansion (limit)
+  (when (re-search-forward "[^\\]\\(\\\\\\\\\\)*\\(#\\({[^}\n\\\\]*\\(\\\\.[^}\n\\\\]*\\)*}\\|\\(\\$\\|@\\|@@\\)\\(\\w\\|_\\)+\\)\\)" limit 'move)
+    (or (ruby-in-ppss-context-p 'string)
+        (ruby-match-expression-expansion limit))))
+
 ;;;###autoload
 (define-derived-mode ruby-mode prog-mode "Ruby"
   "Major mode for editing Ruby scripts.
@@ -1586,6 +1587,10 @@ The variable `ruby-indent-level' controls the amount of indentation.
        'ruby-imenu-create-index)
   (set (make-local-variable 'add-log-current-defun-function)
        'ruby-add-log-current-method)
+  (set (make-local-variable 'beginning-of-defun-function)
+       'ruby-beginning-of-defun)
+  (set (make-local-variable 'end-of-defun-function)
+       'ruby-end-of-defun)
 
   (add-hook
    (cond ((boundp 'before-save-hook) 'before-save-hook)
diff --git a/lisp/progmodes/sh-script.el b/lisp/progmodes/sh-script.el
index a422462775d..b4d550bcee0 100644
--- a/lisp/progmodes/sh-script.el
+++ b/lisp/progmodes/sh-script.el
@@ -1062,21 +1062,22 @@ subshells can nest."
               (backward-char 1))
             (when (eq (char-before) ?|)
               (backward-char 1) t)))
-      (when (progn (backward-char 2)
-                   (if (> start (line-end-position))
-                       (put-text-property (point) (1+ start)
-                                          'syntax-multiline t))
-                   ;; FIXME: The `in' may just be a random argument to
-                   ;; a normal command rather than the real `in' keyword.
-                   ;; I.e. we should look back to try and find the
-                   ;; corresponding `case'.
-                   (and (looking-at ";[;&]\\|\\_<in")
-                        ;; ";; esac )" is a case that looks like a case-pattern
-                        ;; but it's really just a close paren after a case
-                        ;; statement.  I.e. if we skipped over `esac' just now,
-                        ;; we're not looking at a case-pattern.
-                        (not (looking-at "..[ \t\n]+esac[^[:word:]_]"))))
-        sh-st-punc))))
+      (and (> (point) (1+ (point-min)))
+           (progn (backward-char 2)
+                  (if (> start (line-end-position))
+                      (put-text-property (point) (1+ start)
+                                         'syntax-multiline t))
+                  ;; FIXME: The `in' may just be a random argument to
+                  ;; a normal command rather than the real `in' keyword.
+                  ;; I.e. we should look back to try and find the
+                  ;; corresponding `case'.
+                  (and (looking-at ";[;&]\\|\\_<in")
+                       ;; ";; esac )" is a case that looks like a case-pattern
+                       ;; but it's really just a close paren after a case
+                       ;; statement.  I.e. if we skipped over `esac' just now,
+                       ;; we're not looking at a case-pattern.
+                       (not (looking-at "..[ \t\n]+esac[^[:word:]_]"))))
+           sh-st-punc))))
 
 (defun sh-font-lock-backslash-quote ()
   (if (eq (save-excursion (nth 3 (syntax-ppss (match-beginning 0)))) ?\')
diff --git a/lisp/progmodes/vhdl-mode.el b/lisp/progmodes/vhdl-mode.el
index 607ccd8b7e7..0ca3439dd60 100644
--- a/lisp/progmodes/vhdl-mode.el
+++ b/lisp/progmodes/vhdl-mode.el
@@ -4138,10 +4138,7 @@ STRING are replaced by `-' and substrings are converted to lower case."
   (set (make-local-variable 'imenu-generic-expression)
        vhdl-imenu-generic-expression)
   (when (and vhdl-index-menu (fboundp 'imenu))
-    (if (or (not (boundp 'font-lock-maximum-size))
-            (> font-lock-maximum-size (buffer-size)))
-        (imenu-add-to-menubar "Index")
-      (message "Scanning buffer for index...buffer too big"))))
+    (imenu-add-to-menubar "Index")))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Source file menu (using `easy-menu.el')
@@ -14385,10 +14382,10 @@ if required."
           (define-key vhdl-speedbar-key-map (int-to-string key)
             `(lambda () (interactive) (vhdl-speedbar-set-depth ,key)))
           (setq key (1+ key)))))
-    (define-key speedbar-key-map "h"
+    (define-key speedbar-mode-map "h"
       (lambda () (interactive)
         (speedbar-change-initial-expansion-list "vhdl directory")))
-    (define-key speedbar-key-map "H"
+    (define-key speedbar-mode-map "H"
       (lambda () (interactive)
         (speedbar-change-initial-expansion-list "vhdl project")))
     ;; menu
@@ -17400,7 +17397,8 @@ to visually support naming conventions.")
   "Display VARIABLE's documentation in *Help* buffer."
   (interactive)
   (unless (featurep 'xemacs)
-    (help-setup-xref (list #'vhdl-doc-variable variable) (interactive-p)))
+    (help-setup-xref (list #'vhdl-doc-variable variable)
+                     (called-interactively-p 'interactive)))
   (with-output-to-temp-buffer
       (if (fboundp 'help-buffer) (help-buffer) "*Help*")
     (princ (documentation-property variable 'variable-documentation))
@@ -17412,7 +17410,8 @@ to visually support naming conventions.")
   "Display VHDL Mode documentation in *Help* buffer."
   (interactive)
   (unless (featurep 'xemacs)
-    (help-setup-xref (list #'vhdl-doc-mode) (interactive-p)))
+    (help-setup-xref (list #'vhdl-doc-mode)
+                     (called-interactively-p 'interactive)))
   (with-output-to-temp-buffer
       (if (fboundp 'help-buffer) (help-buffer) "*Help*")
     (princ mode-name)
diff --git a/lisp/register.el b/lisp/register.el
index 2816c9831de..fb35a26a653 100644
--- a/lisp/register.el
+++ b/lisp/register.el
@@ -76,6 +76,22 @@ A list of the form (WINDOW-CONFIGURATION POSITION)
 A list of the form (FRAME-CONFIGURATION POSITION)
  represents a saved frame configuration plus a saved value of point.")
 
+(defgroup register nil
+  "Register commands."
+  :group 'convenience
+  :version "24.3")
+
+(defcustom register-separator nil
+  "Register containing the text to put between collected texts, or nil if none.
+
+When collecting text with
+`append-to-register' (resp. `prepend-to-register') contents of
+this register is added to the beginning (resp. end) of the marked
+text."
+  :group 'register
+  :type '(choice (const :tag "None" nil)
+                 (character :tag "Use register" :value ?+)))
+
 (defun get-register (register)
   "Return contents of Emacs register named REGISTER, or nil if none."
   (cdr (assq register register-alist)))
@@ -192,13 +208,24 @@ Interactively, NUMBER is the prefix arg (none means nil)."
                         (string-to-number (match-string 0)))
                     0))))
 
-(defun increment-register (number register)
-  "Add NUMBER to the contents of register REGISTER.
-Interactively, NUMBER is the prefix arg."
-  (interactive "p\ncIncrement register: ")
-  (or (numberp (get-register register))
-      (error "Register does not contain a number"))
-  (set-register register (+ number (get-register register))))
+(defun increment-register (prefix register)
+  "Augment contents of REGISTER.
+Interactively, PREFIX is in raw form.
+
+If REGISTER contains a number, add `prefix-numeric-value' of
+PREFIX to it.
+
+If REGISTER is empty or if it contains text, call
+`append-to-register' with `delete-flag' set to PREFIX."
+  (interactive "P\ncIncrement register: ")
+  (let ((register-val (get-register register)))
+    (cond
+     ((numberp register-val)
+      (let ((number (prefix-numeric-value prefix)))
+        (set-register register (+ number register-val))))
+     ((or (not register-val) (stringp register-val))
+      (append-to-register register (region-beginning) (region-end) prefix))
+     (t (error "Register does not contain a number or text")))))
 
 (defun view-register (register)
   "Display what is contained in register named REGISTER.
@@ -349,10 +376,11 @@ Called from program, takes four args: REGISTER, START, END and DELETE-FLAG.
 START and END are buffer positions indicating what to append."
   (interactive "cAppend to register: \nr\nP")
   (let ((reg (get-register register))
-        (text (filter-buffer-substring start end)))
+        (text (filter-buffer-substring start end))
+        (separator (and register-separator (get-register register-separator))))
     (set-register
      register (cond ((not reg) text)
-                    ((stringp reg) (concat reg text))
+                    ((stringp reg) (concat reg separator text))
                     (t (error "Register does not contain text")))))
   (cond (delete-flag
          (delete-region start end))
@@ -366,10 +394,11 @@ Called from program, takes four args: REGISTER, START, END and DELETE-FLAG.
 START and END are buffer positions indicating what to prepend."
   (interactive "cPrepend to register: \nr\nP")
   (let ((reg (get-register register))
-        (text (filter-buffer-substring start end)))
+        (text (filter-buffer-substring start end))
+        (separator (and register-separator (get-register register-separator))))
     (set-register
      register (cond ((not reg) text)
-                    ((stringp reg) (concat text reg))
+                    ((stringp reg) (concat text separator reg))
                     (t (error "Register does not contain text")))))
   (cond (delete-flag
          (delete-region start end))
diff --git a/lisp/replace.el b/lisp/replace.el
index 3373ee8e512..001f7d1a78d 100644
--- a/lisp/replace.el
+++ b/lisp/replace.el
@@ -33,6 +33,22 @@
   :type 'boolean
   :group 'matching)
 
+(defcustom replace-lax-whitespace nil
+  "Non-nil means `query-replace' matches a sequence of whitespace chars.
+When you enter a space or spaces in the strings to be replaced,
+it will match any sequence matched by the regexp `search-whitespace-regexp'."
+  :type 'boolean
+  :group 'matching
+  :version "24.3")
+
+(defcustom replace-regexp-lax-whitespace nil
+  "Non-nil means `query-replace-regexp' matches a sequence of whitespace chars.
+When you enter a space or spaces in the regexps to be replaced,
+it will match any sequence matched by the regexp `search-whitespace-regexp'."
+  :type 'boolean
+  :group 'matching
+  :version "24.3")
+
 (defvar query-replace-history nil
   "Default history list for query-replace commands.
 See `query-replace-from-history-variable' and
@@ -226,6 +242,10 @@ letters.  \(Transferring the case pattern means that if the old text
 matched is all caps, or capitalized, then its replacement is upcased
 or capitalized.)
 
+If `replace-lax-whitespace' is non-nil, a space or spaces in the string
+to be replaced will match a sequence of whitespace chars defined by the
+regexp in `search-whitespace-regexp'.
+
 Third arg DELIMITED (prefix arg if interactive), if non-nil, means replace
 only matches surrounded by word boundaries.
 Fourth and fifth arg START and END specify the region to operate on.
@@ -270,6 +290,10 @@ pattern of the old text to the new text, if `case-replace' and
 all caps, or capitalized, then its replacement is upcased or
 capitalized.)
 
+If `replace-regexp-lax-whitespace' is non-nil, a space or spaces in the regexp
+to be replaced will match a sequence of whitespace chars defined by the
+regexp in `search-whitespace-regexp'.
+
 Third arg DELIMITED (prefix arg if interactive), if non-nil, means replace
 only matches surrounded by word boundaries.
 Fourth and fifth arg START and END specify the region to operate on.
@@ -346,6 +370,10 @@ minibuffer.
 Preserves case in each replacement if `case-replace' and `case-fold-search'
 are non-nil and REGEXP has no uppercase letters.
 
+If `replace-regexp-lax-whitespace' is non-nil, a space or spaces in the regexp
+to be replaced will match a sequence of whitespace chars defined by the
+regexp in `search-whitespace-regexp'.
+
 Third arg DELIMITED (prefix arg if interactive), if non-nil, means replace
 only matches that are surrounded by word boundaries.
 Fourth and fifth arg START and END specify the region to operate on."
@@ -437,6 +465,10 @@ are non-nil and FROM-STRING has no uppercase letters.
 \(Preserving case means that if the string matched is all caps, or capitalized,
 then its replacement is upcased or capitalized.)
 
+If `replace-lax-whitespace' is non-nil, a space or spaces in the string
+to be replaced will match a sequence of whitespace chars defined by the
+regexp in `search-whitespace-regexp'.
+
 In Transient Mark mode, if the mark is active, operate on the contents
 of the region.  Otherwise, operate from point to the end of the buffer.
 
@@ -475,6 +507,10 @@ and TO-STRING is also null.)"
 Preserve case in each match if `case-replace' and `case-fold-search'
 are non-nil and REGEXP has no uppercase letters.
 
+If `replace-regexp-lax-whitespace' is non-nil, a space or spaces in the regexp
+to be replaced will match a sequence of whitespace chars defined by the
+regexp in `search-whitespace-regexp'.
+
 In Transient Mark mode, if the mark is active, operate on the contents
 of the region.  Otherwise, operate from point to the end of the buffer.
 
@@ -1589,14 +1625,28 @@ E to edit the replacement string"
     (define-key map "?" 'help)
     (define-key map "\C-g" 'quit)
     (define-key map "\C-]" 'quit)
-    (define-key map "\e" 'exit-prefix)
+    (define-key map "\C-v" 'scroll-up)
+    (define-key map "\M-v" 'scroll-down)
+    (define-key map [next] 'scroll-up)
+    (define-key map [prior] 'scroll-down)
+    (define-key map [?\C-\M-v] 'scroll-other-window)
+    (define-key map [M-next] 'scroll-other-window)
+    (define-key map [?\C-\M-\S-v] 'scroll-other-window-down)
+    (define-key map [M-prior] 'scroll-other-window-down)
+    ;; Binding ESC would prohibit the M-v binding.  Instead, callers
+    ;; should check for ESC specially.
+    ;; (define-key map "\e" 'exit-prefix)
     (define-key map [escape] 'exit-prefix)
     map)
-  "Keymap that defines the responses to questions in `query-replace'.
+  "Keymap of responses to questions posed by commands like `query-replace'.
 The \"bindings\" in this map are not commands; they are answers.
 The valid answers include `act', `skip', `act-and-show',
-`exit', `act-and-exit', `edit', `edit-replacement', `delete-and-edit',
-`recenter', `automatic', `backup', `exit-prefix', `quit', and `help'.")
+`act-and-exit', `exit', `exit-prefix', `recenter', `scroll-up',
+`scroll-down', `scroll-other-window', `scroll-other-window-down',
+`edit', `edit-replacement', `delete-and-edit', `automatic',
+`backup', `quit', and `help'.
+
+This keymap is used by `y-or-n-p' as well as `query-replace'.")
 
 (defvar multi-query-replace-map
   (let ((map (make-sparse-keymap)))
@@ -1717,12 +1767,12 @@ passed in.  If LITERAL is set, no checking is done, anyway."
   (replace-match newtext fixedcase literal)
   noedit)
 
-(defvar replace-search-function 'search-forward
+(defvar replace-search-function nil
   "Function to use when searching for strings to replace.
 It is used by `query-replace' and `replace-string', and is called
 with three arguments, as if it were `search-forward'.")
 
-(defvar replace-re-search-function 're-search-forward
+(defvar replace-re-search-function nil
   "Function to use when searching for regexps to replace.
 It is used by `query-replace-regexp', `replace-regexp',
 `query-replace-regexp-eval', and `map-query-replace-regexp'.
@@ -1755,9 +1805,18 @@ make, or the user didn't cancel the call."
          (nocasify (not (and case-replace case-fold-search)))
          (literal (or (not regexp-flag) (eq regexp-flag 'literal)))
          (search-function
-          (if regexp-flag
-              replace-re-search-function
-            replace-search-function))
+          (or (if regexp-flag
+                  replace-re-search-function
+                replace-search-function)
+              (let ((isearch-regexp regexp-flag)
+                    (isearch-word delimited-flag)
+                    (isearch-lax-whitespace
+                     replace-lax-whitespace)
+                    (isearch-regexp-lax-whitespace
+                     replace-regexp-lax-whitespace)
+                    (isearch-case-fold-search case-fold-search)
+                    (isearch-forward t))
+                (isearch-search-fun))))
          (search-string from-string)
          (real-match-data nil)       ; The match data for the current match.
          (next-replacement nil)
@@ -1811,12 +1870,6 @@ make, or the user didn't cancel the call."
                                (vector repeat-count repeat-count
                                        replacements replacements)))))
 
-    (if delimited-flag
-        (setq search-function 're-search-forward
-              search-string (concat "\\b"
-                                    (if regexp-flag from-string
-                                      (regexp-quote from-string))
-                                    "\\b")))
     (when query-replace-lazy-highlight
       (setq isearch-lazy-highlight-last-string nil))
 
@@ -1898,7 +1951,7 @@ make, or the user didn't cancel the call."
                     (replace-highlight
                      (nth 0 real-match-data) (nth 1 real-match-data)
                      start end search-string
-                     (or delimited-flag regexp-flag) case-fold-search))
+                     regexp-flag delimited-flag case-fold-search))
                   (setq noedit
                         (replace-match-maybe-edit
                          next-replacement nocasify literal
@@ -1917,7 +1970,7 @@ make, or the user didn't cancel the call."
                   (replace-highlight
                    (match-beginning 0) (match-end 0)
                    start end search-string
-                   (or delimited-flag regexp-flag) case-fold-search)
+                   regexp-flag delimited-flag case-fold-search)
                   ;; Bind message-log-max so we don't fill up the message log
                   ;; with a bunch of identical messages.
                   (let ((message-log-max nil)
@@ -2099,15 +2152,11 @@ make, or the user didn't cancel the call."
                  (if (= replace-count 1) "" "s")))
     (or (and keep-going stack) multi-buffer)))
 
-(defvar isearch-error)
-(defvar isearch-forward)
-(defvar isearch-case-fold-search)
-(defvar isearch-string)
-
 (defvar replace-overlay nil)
 
 (defun replace-highlight (match-beg match-end range-beg range-end
-                          string regexp case-fold)
+                          search-string regexp-flag delimited-flag
+                          case-fold-search)
   (if query-replace-highlight
       (if replace-overlay
           (move-overlay replace-overlay match-beg match-end (current-buffer))
@@ -2115,13 +2164,14 @@ make, or the user didn't cancel the call."
         (overlay-put replace-overlay 'priority 1001) ;higher than lazy overlays
         (overlay-put replace-overlay 'face 'query-replace)))
   (if query-replace-lazy-highlight
-      (let ((isearch-string string)
-            (isearch-regexp regexp)
-            ;; Set isearch-word to nil because word-replace is regexp-based,
-            ;; so `isearch-search-fun' should not use `word-search-forward'.
-            (isearch-word nil)
-            (search-whitespace-regexp nil)
-            (isearch-case-fold-search case-fold)
+      (let ((isearch-string search-string)
+            (isearch-regexp regexp-flag)
+            (isearch-word delimited-flag)
+            (isearch-lax-whitespace
+             replace-lax-whitespace)
+            (isearch-regexp-lax-whitespace
+             replace-regexp-lax-whitespace)
+            (isearch-case-fold-search case-fold-search)
             (isearch-forward t)
             (isearch-error nil))
         (isearch-lazy-highlight-new-loop range-beg range-end))))
diff --git a/lisp/ses.el b/lisp/ses.el
index 8add16a6996..7cdac74e310 100644
--- a/lisp/ses.el
+++ b/lisp/ses.el
@@ -1270,11 +1270,9 @@ when the width of cell (ROW,COL) has changed."
 ;; The data area
 ;;----------------------------------------------------------------------------
 
-(defun ses-narrowed-p () (/= (- (point-max) (point-min)) (buffer-size)))
-
 (defun ses-widen ()
   "Turn off narrowing, to be reenabled at end of command loop."
-  (if (ses-narrowed-p)
+  (if (buffer-narrowed-p)
       (setq ses--deferred-narrow t))
   (widen))
 
diff --git a/lisp/simple.el b/lisp/simple.el
index b7a24f4f970..d87ae3c5c15 100644
--- a/lisp/simple.el
+++ b/lisp/simple.el
@@ -974,7 +974,9 @@ rather than the region.
 
 If called from Lisp, return the number of words between positions
 START and END."
-  (interactive "r\nP")
+  (interactive (if current-prefix-arg
+                   (list nil nil current-prefix-arg)
+                 (list (region-beginning) (region-end) nil)))
   (cond ((not (called-interactively-p 'any))
          (count-words start end))
         (arg
@@ -1008,9 +1010,7 @@ END, without printing any message."
 
 (defun count-words--buffer-message ()
   (count-words--message
-   (if (= (point-max) (1+ (buffer-size)))
-       "Buffer"
-     "Narrowed part of buffer")
+   (if (buffer-narrowed-p) "Narrowed part of buffer" "Buffer")
    (point-min) (point-max)))
 
 (defun count-words--message (str start end)
diff --git a/lisp/speedbar.el b/lisp/speedbar.el
index 16993ce1891..90cdea63e85 100644
--- a/lisp/speedbar.el
+++ b/lisp/speedbar.el
@@ -763,7 +763,7 @@ DIRECTORY-EXPRESSION to `speedbar-ignored-directory-expressions'."
   "Non-nil means to automatically update the display.
 When this is nil then speedbar will not follow the attached frame's directory.
 If you want to change this while speedbar is active, either use
-\\[customize] or call \\<speedbar-key-map> `\\[speedbar-toggle-updates]'."
+\\[customize] or call \\<speedbar-mode-map> `\\[speedbar-toggle-updates]'."
   :group 'speedbar
   :initialize 'custom-initialize-default
   :set (lambda (sym val)
@@ -1083,7 +1083,7 @@ Return nil if it doesn't exist."
 
 (define-derived-mode speedbar-mode fundamental-mode "Speedbar"
   "Major mode for managing a display of directories and tags.
-\\<speedbar-key-map>
+\\<speedbar-mode-map>
 The first line represents the default directory of the speedbar frame.
 Each directory segment is a button which jumps speedbar's default
 directory to that directory.  Buttons are activated by clicking `\\[speedbar-click]'.
@@ -1120,7 +1120,7 @@ category of tags.  Click the {+} to expand the category.  Jump-able
 tags start with >.  Click the name of the tag to go to that position
 in the selected file.
 
-\\{speedbar-key-map}"
+\\{speedbar-mode-map}"
   (save-excursion
     (setq font-lock-keywords nil) ;; no font-locking please
     (setq truncate-lines t)
diff --git a/lisp/subr.el b/lisp/subr.el
index 74afd59f8d5..be785ff8fba 100644
--- a/lisp/subr.el
+++ b/lisp/subr.el
@@ -1548,7 +1548,7 @@ if it is empty or a duplicate."
                (or keep-all
                    (not (equal (car history) newelt))))
       (if history-delete-duplicates
-          (delete newelt history))
+          (setq history (delete newelt history)))
       (setq history (cons newelt history))
       (when (integerp maxelt)
         (if (= 0 maxelt)
@@ -2237,7 +2237,8 @@ keyboard-quit events while waiting for a valid input."
     (error "Called `read-char-choice' without valid char choices"))
   (let (char done show-help (helpbuf " *Char Help*"))
     (let ((cursor-in-echo-area t)
-          (executing-kbd-macro executing-kbd-macro))
+          (executing-kbd-macro executing-kbd-macro)
+          (esc-flag nil))
       (save-window-excursion          ; in case we call help-form-show
         (while (not done)
           (unless (get-text-property 0 'face prompt)
@@ -2261,8 +2262,12 @@ keyboard-quit events while waiting for a valid input."
             ;; there are no more events in the macro.  Attempt to
             ;; get an event interactively.
             (setq executing-kbd-macro nil))
-           ((and (not inhibit-keyboard-quit) (eq char ?\C-g))
-            (keyboard-quit))))))
+           ((not inhibit-keyboard-quit)
+            (cond
+             ((and (null esc-flag) (eq char ?\e))
+              (setq esc-flag t))
+             ((memq char '(?\C-g ?\e))
+              (keyboard-quit))))))))
     ;; Display the question with the answer.  But without cursor-in-echo-area.
     (message "%s%s" prompt (char-to-string char))
     char))
@@ -2314,11 +2319,19 @@ floating point support."
 PROMPT is the string to display to ask the question.  It should
 end in a space; `y-or-n-p' adds \"(y or n) \" to it.
 
-No confirmation of the answer is requested; a single character is enough.
-Also accepts Space to mean yes, or Delete to mean no.  \(Actually, it uses
-the bindings in `query-replace-map'; see the documentation of that variable
-for more information.  In this case, the useful bindings are `act', `skip',
-`recenter', and `quit'.\)
+No confirmation of the answer is requested; a single character is
+enough.  SPC also means yes, and DEL means no.
+
+To be precise, this function translates user input into responses
+by consulting the bindings in `query-replace-map'; see the
+documentation of that variable for more information.  In this
+case, the useful bindings are `act', `skip', `recenter',
+`scroll-up', `scroll-down', and `quit'.
+An `act' response means yes, and a `skip' response means no.
+A `quit' response means to invoke `keyboard-quit'.
+If the user enters `recenter', `scroll-up', or `scroll-down'
+responses, perform the requested window recentering or scrolling
+and ask again.
 
 Under a windowing system a dialog box will be used if `last-nonmenu-event'
 is nil and `use-dialog-box' is non-nil."
@@ -2350,21 +2363,33 @@ is nil and `use-dialog-box' is non-nil."
                                "" " ")
                            "(y or n) "))
       (while
-          (let* ((key
+          (let* ((scroll-actions '(recenter scroll-up scroll-down
+                                   scroll-other-window scroll-other-window-down))
+                 (key
                   (let ((cursor-in-echo-area t))
                     (when minibuffer-auto-raise
                       (raise-frame (window-frame (minibuffer-window))))
-                    (read-key (propertize (if (eq answer 'recenter)
+                    (read-key (propertize (if (memq answer scroll-actions)
                                               prompt
                                             (concat "Please answer y or n.  "
                                                     prompt))
                                           'face 'minibuffer-prompt)))))
             (setq answer (lookup-key query-replace-map (vector key) t))
             (cond
-             ((memq answer '(skip act)) nil)
-             ((eq answer 'recenter) (recenter) t)
-             ((memq answer '(exit-prefix quit)) (signal 'quit nil) t)
-             (t t)))
+             ((memq answer '(skip act)) nil)
+             ((eq answer 'recenter)
+              (recenter) t)
+             ((eq answer 'scroll-up)
+              (ignore-errors (scroll-up-command)) t)
+             ((eq answer 'scroll-down)
+              (ignore-errors (scroll-down-command)) t)
+             ((eq answer 'scroll-other-window)
+              (ignore-errors (scroll-other-window)) t)
+             ((eq answer 'scroll-other-window-down)
+              (ignore-errors (scroll-other-window-down)) t)
+             ((or (memq answer '(exit-prefix quit)) (eq key ?\e))
+              (signal 'quit nil) t)
+             (t t)))
         (ding)
         (discard-input))))
     (let ((ret (eq answer 'act)))
@@ -2647,6 +2672,10 @@ directory if it does not exist."
 
 ;;;; Misc. useful functions.
 
+(defsubst buffer-narrowed-p ()
+  "Return non-nil if the current buffer is narrowed."
+  (/= (- (point-max) (point-min)) (buffer-size)))
+
 (defun find-tag-default ()
   "Determine default tag to search for, based on text at point.
 If there is no plausible default, return nil."
@@ -3728,7 +3757,7 @@ from `standard-syntax-table' otherwise."
     table))
 
 (defun syntax-after (pos)
-  "Return the raw syntax of the char after POS.
+  "Return the raw syntax descriptor for the char after POS.
 If POS is outside the buffer's accessible portion, return nil."
   (unless (or (< pos (point-min)) (>= pos (point-max)))
     (let ((st (if parse-sexp-lookup-properties
@@ -3737,7 +3766,12 @@ If POS is outside the buffer's accessible portion, return nil."
         (aref (or st (syntax-table)) (char-after pos))))))
 
 (defun syntax-class (syntax)
-  "Return the syntax class part of the syntax descriptor SYNTAX.
+  "Return the code for the syntax class described by SYNTAX.
+
+SYNTAX should be a raw syntax descriptor; the return value is a
+integer which encodes the corresponding syntax class.  See Info
+node `(elisp)Syntax Table Internals' for a list of codes.
+
 If SYNTAX is nil, return nil."
   (and syntax (logand (car syntax) 65535)))
 
diff --git a/lisp/textmodes/picture.el b/lisp/textmodes/picture.el
index 24a4ac1b033..e663c1b45f4 100644
--- a/lisp/textmodes/picture.el
+++ b/lisp/textmodes/picture.el
@@ -612,13 +612,15 @@ Leaves the region surrounding the rectangle."
     (define-key map [remap self-insert-command] 'picture-self-insert)
     (define-key map [remap self-insert-command] 'picture-self-insert)
     (define-key map [remap completion-separator-self-insert-command]
-      'picture-self-insert)
+                          'picture-self-insert)
     (define-key map [remap completion-separator-self-insert-autofilling]
-      'picture-self-insert)
+                          'picture-self-insert)
     (define-key map [remap forward-char] 'picture-forward-column)
+    (define-key map [remap right-char] 'picture-forward-column)
     (define-key map [remap backward-char] 'picture-backward-column)
+    (define-key map [remap left-char] 'picture-backward-column)
     (define-key map [remap delete-char] 'picture-clear-column)
-    ;; There are two possibilities for what is normally on DEL.
+      ;; There are two possibilities for what is normally on DEL.
     (define-key map [remap backward-delete-char-untabify]
       'picture-backward-clear-column)
     (define-key map [remap delete-backward-char] 'picture-backward-clear-column)
diff --git a/lisp/userlock.el b/lisp/userlock.el
index 705d9588249..4c003e423aa 100644
--- a/lisp/userlock.el
+++ b/lisp/userlock.el
@@ -108,37 +108,27 @@ You can rewrite this to use any criterion you like to choose which one to do.
 The buffer in question is current when this function is called."
   (discard-input)
   (save-window-excursion
-    (let (answer)
+    (let ((prompt
+           (format "%s changed on disk; \
+really edit the buffer? (y, n, r or C-h) "
+                   (file-name-nondirectory fn)))
+          (choices '(?y ?n ?r ?? ?\C-h))
+          answer)
       (while (null answer)
-        (message "%s changed on disk; really edit the buffer? (y, n, r or C-h) "
-                 (file-name-nondirectory fn))
-        (let ((tem (downcase (let ((cursor-in-echo-area t))
-                               (read-char-exclusive)))))
-          (setq answer
-                (if (= tem help-char)
-                    'help
-                  (cdr (assoc tem '((?n . yield)
-                                    (?\C-g . yield)
-                                    (?y . proceed)
-                                    (?r . revert)
-                                    (?? . help))))))
-          (cond ((null answer)
-                 (beep)
-                 (message "Please type y, n or r; or ? for help")
-                 (sit-for 3))
-                ((eq answer 'help)
-                 (ask-user-about-supersession-help)
-                 (setq answer nil))
-                ((eq answer 'revert)
-                 (revert-buffer nil (not (buffer-modified-p)))
-                                        ; ask confirmation if buffer modified
-                 (signal 'file-supersession
-                         (list "File reverted" fn)))
-                ((eq answer 'yield)
-                 (signal 'file-supersession
-                         (list "File changed on disk" fn))))))
+        (setq answer (read-char-choice prompt choices))
+        (cond ((memq answer '(?? ?\C-h))
+               (ask-user-about-supersession-help)
+               (setq answer nil))
+              ((eq answer ?r)
+               ;; Ask for confirmation if buffer modified
+               (revert-buffer nil (not (buffer-modified-p)))
+               (signal 'file-supersession
+                       (list "File reverted" fn)))
+              ((eq answer ?n)
+               (signal 'file-supersession
+                       (list "File changed on disk" fn)))))
       (message
-        "File on disk now will become a backup file if you save these changes.")
+       "File on disk now will become a backup file if you save these changes.")
       (setq buffer-backed-up nil))))
 
 (defun ask-user-about-supersession-help ()
diff --git a/lisp/window.el b/lisp/window.el
index f73c85e991b..dd1f55450c3 100644
--- a/lisp/window.el
+++ b/lisp/window.el
@@ -5521,6 +5521,62 @@ the selected one."
              (window--display-buffer
               buffer window 'reuse display-buffer-mark-dedicated)))))
 
+(defun display-buffer-in-previous-window (buffer alist)
+  "Display BUFFER in a window previously showing it.
+If ALIST has a non-nil `inhibit-same-window' entry, the selected
+window is not eligible for reuse.
+
+If ALIST contains a `reusable-frames' entry, its value determines
+which frames to search for a reusable window:
+  nil -- the selected frame (actually the last non-minibuffer frame)
+  A frame   -- just that frame
+  `visible' -- all visible frames
+  0   -- all frames on the current terminal
+  t   -- all frames.
+
+If ALIST contains no `reusable-frames' entry, search just the
+selected frame if `display-buffer-reuse-frames' and
+`pop-up-frames' are both nil; search all frames on the current
+terminal if either of those variables is non-nil.
+
+If ALIST has a `previous-window' entry, the window specified by
+that entry will override any other window found by the methods
+above, even if that window never showed BUFFER before."
+  (let* ((alist-entry (assq 'reusable-frames alist))
+         (inhibit-same-window
+          (cdr (assq 'inhibit-same-window alist)))
+         (frames (cond
+                  (alist-entry (cdr alist-entry))
+                  ((if (eq pop-up-frames 'graphic-only)
+                       (display-graphic-p)
+                     pop-up-frames)
+                   0)
+                  (display-buffer-reuse-frames 0)
+                  (t (last-nonminibuffer-frame))))
+         entry best-window second-best-window window)
+    ;; Scan windows whether they have shown the buffer recently.
+    (catch 'best
+      (dolist (window (window-list-1 (frame-first-window) 'nomini frames))
+        (when (and (assq buffer (window-prev-buffers window))
+                   (not (window-dedicated-p window)))
+          (if (eq window (selected-window))
+              (unless inhibit-same-window
+                (setq second-best-window window))
+            (setq best-window window)
+            (throw 'best t)))))
+    ;; When ALIST has a `previous-window' entry, that entry may override
+    ;; anything we found so far.
+    (when (and (setq window (cdr (assq 'previous-window alist)))
+               (window-live-p window)
+               (not (window-dedicated-p window)))
+      (if (eq window (selected-window))
+          (unless inhibit-same-window
+            (setq second-best-window window))
+        (setq best-window window)))
+    ;; Return best or second best window found.
+    (when (setq window (or best-window second-best-window))
+      (window--display-buffer buffer window 'reuse))))
+
 (defun display-buffer-use-some-window (buffer alist)
   "Display BUFFER in an existing window.
 Search for a usable window, set that window to the buffer, and
@@ -5642,26 +5698,28 @@ buffer with the name BUFFER-OR-NAME and return that buffer."
 
 (defun switch-to-buffer (buffer-or-name &optional norecord force-same-window)
   "Switch to buffer BUFFER-OR-NAME in the selected window.
-If called interactively, prompt for the buffer name using the
+If the selected window cannot display the specified
+buffer (e.g. if it is a minibuffer window or strongly dedicated
+to another buffer), call `pop-to-buffer' to select the buffer in
+another window.
+
+If called interactively, read the buffer name using the
 minibuffer.  The variable `confirm-nonexistent-file-or-buffer'
 determines whether to request confirmation before creating a new
 buffer.
 
-BUFFER-OR-NAME may be a buffer, a string (a buffer name), or
-nil.  If BUFFER-OR-NAME is a string that does not identify an
-existing buffer, create a buffer with that name.  If
-BUFFER-OR-NAME is nil, switch to the buffer returned by
-`other-buffer'.
+BUFFER-OR-NAME may be a buffer, a string (a buffer name), or nil.
+If BUFFER-OR-NAME is a string that does not identify an existing
+buffer, create a buffer with that name.  If BUFFER-OR-NAME is
+nil, switch to the buffer returned by `other-buffer'.
 
-Optional argument NORECORD non-nil means do not put the buffer
-specified by BUFFER-OR-NAME at the front of the buffer list and
-do not make the window displaying it the most recently selected
-one.
+If optional argument NORECORD is non-nil, do not put the buffer
+at the front of the buffer list, and do not make the window
+displaying it the most recently selected one.
 
-If FORCE-SAME-WINDOW is non-nil, BUFFER-OR-NAME must be displayed
-in the selected window; signal an error if that is
-impossible (e.g. if the selected window is minibuffer-only).  If
-nil, BUFFER-OR-NAME may be displayed in another window.
+If optional argument FORCE-SAME-WINDOW is non-nil, the buffer
+must be displayed in the selected window; if that is impossible,
+signal an error rather than calling `pop-to-buffer'.
 
 Return the buffer switched to."
   (interactive
@@ -5918,6 +5976,88 @@ WINDOW was scrolled."
           (error (setq delta nil)))
         delta))))
 
+(defcustom fit-frame-to-buffer-bottom-margin 4
+  "Bottom margin for `fit-frame-to-buffer'.
+This is the number of lines `fit-frame-to-buffer' leaves free at the
+bottom of the display in order to not obscure the system task bar."
+  :type 'integer
+  :version "24.2"
+  :group 'windows)
+
+(defun fit-frame-to-buffer (&optional frame max-height min-height)
+  "Adjust height of FRAME to display its buffer's contents exactly.
+FRAME can be any live frame and defaults to the selected one.
+
+Optional argument MAX-HEIGHT specifies the maximum height of
+FRAME and defaults to the height of the display below the current
+top line of FRAME minus FIT-FRAME-TO-BUFFER-BOTTOM-MARGIN.
+Optional argument MIN-HEIGHT specifies the minimum height of
+FRAME."
+  (interactive)
+  (setq frame (window-normalize-frame frame))
+  (let* ((root (frame-root-window frame))
+         (frame-min-height
+          (+ (- (frame-height frame) (window-total-size root))
+             window-min-height))
+         (frame-top (frame-parameter frame 'top))
+         (top (if (consp frame-top)
+                  (funcall (car frame-top) (cadr frame-top))
+                frame-top))
+         (frame-max-height
+          (- (/ (- (x-display-pixel-height frame) top)
+                (frame-char-height frame))
+             fit-frame-to-buffer-bottom-margin))
+         (compensate 0)
+         delta)
+    (when (and (window-live-p root) (not (window-size-fixed-p root)))
+      (with-selected-window root
+        (cond
+         ((not max-height)
+          (setq max-height frame-max-height))
+         ((numberp max-height)
+          (setq max-height (min max-height frame-max-height)))
+         (t
+          (error "%s is an invalid maximum height" max-height)))
+        (cond
+         ((not min-height)
+          (setq min-height frame-min-height))
+         ((numberp min-height)
+          (setq min-height (min min-height frame-min-height)))
+         (t
+          (error "%s is an invalid minimum height" min-height)))
+        ;; When tool-bar-mode is enabled and we have just created a new
+        ;; frame, reserve lines for toolbar resizing.  This is needed
+        ;; because for reasons unknown to me Emacs (1) reserves one line
+        ;; for the toolbar when making the initial frame and toolbars
+        ;; are enabled, and (2) later adds the remaining lines needed.
+        ;; Our code runs IN BETWEEN (1) and (2).  YMMV when you're on a
+        ;; system that behaves differently.
+        (let ((quit-restore (window-parameter root 'quit-restore))
+              (lines (tool-bar-lines-needed frame)))
+          (when (and quit-restore (eq (car quit-restore) 'frame)
+                     (not (zerop lines)))
+            (setq compensate (1- lines))))
+        (message "%s" compensate)
+        (setq delta
+              ;; Always count a final newline - we don't do any
+              ;; post-processing, so let's play safe.
+              (+ (count-screen-lines nil nil t)
+                 (- (window-body-size))
+                 compensate)))
+      ;; Move away from final newline.
+      (when (and (eobp) (bolp) (not (bobp)))
+        (set-window-point root (line-beginning-position 0)))
+      (set-window-start root (point-min))
+      (set-window-vscroll root 0)
+      (condition-case nil
+          (set-frame-height
+           frame
+           (min (max (+ (frame-height frame) delta)
+                     min-height)
+                max-height))
+        (error (setq delta nil))))
+    delta))
+
 (defun window-safely-shrinkable-p (&optional window)
   "Return t if WINDOW can be shrunk without shrinking other windows.
 WINDOW defaults to the selected window."
@@ -6161,7 +6301,7 @@ This is different from `scroll-down-command' that scrolls a full screen."
 (put 'scroll-down-line 'scroll-command t)
 
 
-(defun scroll-other-window-down (lines)
+(defun scroll-other-window-down (&optional lines)
   "Scroll the \"other window\" down.
 For more details, see the documentation for `scroll-other-window'."
   (interactive "P")