43 files changed, 2001 insertions, 1143 deletions

diff --git a/lisp/autorevert.el b/lisp/autorevert.el
index 79291624523..a15386aa1af 100644
--- a/lisp/autorevert.el
+++ b/lisp/autorevert.el
@@ -319,10 +319,12 @@ the list of old buffers.")
 (defvar auto-revert-tail-pos 0
   "Position of last known end of file.")
 
+(defun auto-revert-find-file-function ()
+  (setq-local auto-revert-tail-pos
+              (nth 7 (file-attributes buffer-file-name))))
+
 (add-hook 'find-file-hook
-          (lambda ()
-            (setq-local auto-revert-tail-pos
-                        (nth 7 (file-attributes buffer-file-name)))))
+          #'auto-revert-find-file-function)
 
 (defvar auto-revert-notify-watch-descriptor-hash-list
   (make-hash-table :test 'equal)
@@ -341,6 +343,11 @@ This has been reported by a file notification event.")
 
 ;; Functions:
 
+(defun auto-revert-remove-current-buffer ()
+  "Remove dead buffer from `auto-revert-buffer-list'."
+  (setq auto-revert-buffer-list
+        (delq (current-buffer) auto-revert-buffer-list)))
+
 ;;;###autoload
 (define-minor-mode auto-revert-mode
   "Toggle reverting buffer when the file changes (Auto-Revert Mode).
@@ -364,13 +371,10 @@ without being changed in the part that is already in the buffer."
         (push (current-buffer) auto-revert-buffer-list)
         (add-hook
          'kill-buffer-hook
-         (lambda ()
-           (setq auto-revert-buffer-list
-                 (delq (current-buffer) auto-revert-buffer-list)))
+         #'auto-revert-remove-current-buffer
          nil t))
     (when auto-revert-use-notify (auto-revert-notify-rm-watch))
-    (setq auto-revert-buffer-list
-          (delq (current-buffer) auto-revert-buffer-list)))
+    (auto-revert-remove-current-buffer))
   (auto-revert-set-timer)
   (when auto-revert-mode
     (auto-revert-buffers)
@@ -786,24 +790,24 @@ the timer when no buffers need to be checked."
                   (not (and auto-revert-stop-on-user-input
                             (input-pending-p))))
         (let ((buf (car bufs)))
-          (if (buffer-live-p buf)
-              (with-current-buffer buf
-                ;; Test if someone has turned off Auto-Revert Mode in a
-                ;; non-standard way, for example by changing major mode.
-                (if (and (not auto-revert-mode)
-                         (not auto-revert-tail-mode)
-                         (memq buf auto-revert-buffer-list))
-                    (setq auto-revert-buffer-list
-                          (delq buf auto-revert-buffer-list)))
-                (when (auto-revert-active-p)
-                  ;; Enable file notification.
-                  (when (and auto-revert-use-notify
-                             (not auto-revert-notify-watch-descriptor))
-                    (auto-revert-notify-add-watch))
-                  (auto-revert-handler)))
-            ;; Remove dead buffer from `auto-revert-buffer-list'.
-            (setq auto-revert-buffer-list
-                  (delq buf auto-revert-buffer-list))))
+          (with-current-buffer buf
+            (if (buffer-live-p buf)
+                (progn
+                  ;; Test if someone has turned off Auto-Revert Mode
+                  ;; in a non-standard way, for example by changing
+                  ;; major mode.
+                  (if (and (not auto-revert-mode)
+                           (not auto-revert-tail-mode)
+                           (memq buf auto-revert-buffer-list))
+                      (auto-revert-remove-current-buffer))
+                  (when (auto-revert-active-p)
+                    ;; Enable file notification.
+                    (when (and auto-revert-use-notify
+                               (not auto-revert-notify-watch-descriptor))
+                      (auto-revert-notify-add-watch))
+                    (auto-revert-handler)))
+              ;; Remove dead buffer from `auto-revert-buffer-list'.
+              (auto-revert-remove-current-buffer))))
         (setq bufs (cdr bufs)))
       (setq auto-revert-remaining-buffers bufs)
       ;; Check if we should cancel the timer.
diff --git a/lisp/calc/calc-units.el b/lisp/calc/calc-units.el
index 0e3715eb4cf..a8074eaeb20 100644
--- a/lisp/calc/calc-units.el
+++ b/lisp/calc/calc-units.el
@@ -825,21 +825,18 @@ If COMP or STD is non-nil, put that in the units table instead."
        (forward-char -1))
      (insert ";;; Custom units stored by Calc on " (current-time-string) "\n")
      (if math-additional-units
-         (progn
+         (let (expr)
            (insert "(setq math-additional-units '(\n")
-           (let ((list math-additional-units))
-             (while list
-               (insert "  (" (symbol-name (car (car list))) " "
-                       (if (nth 1 (car list))
-                           (if (stringp (nth 1 (car list)))
-                               (prin1-to-string (nth 1 (car list)))
-                             (prin1-to-string (math-format-flat-expr
-                                               (nth 1 (car list)) 0)))
-                         "nil")
-                       " "
-                       (prin1-to-string (nth 2 (car list)))
-                       ")\n")
-               (setq list (cdr list))))
+           (dolist (u math-additional-units)
+             (insert "  (" (symbol-name (car u)) " "
+                     (if (setq expr (nth 1 u))
+                         (if (stringp expr)
+                             (prin1-to-string expr)
+                           (prin1-to-string (math-format-flat-expr expr 0)))
+                       "nil")
+                     " "
+                     (prin1-to-string (nth 2 u))
+                     ")\n"))
            (insert "))\n"))
        (insert ";;; (no custom units defined)\n"))
      (insert ";;; End of custom units\n")
@@ -916,15 +913,13 @@ If COMP or STD is non-nil, put that in the units table instead."
 (defun math-find-base-units-rec (expr pow)
   (let ((u (math-check-unit-name expr)))
     (cond (u
-           (let ((ulist (math-find-base-units u)))
-             (while ulist
-               (let ((p (* (cdr (car ulist)) pow))
-                     (old (assq (car (car ulist)) math-fbu-base)))
-                 (if old
-                     (setcdr old (+ (cdr old) p))
-                   (setq math-fbu-base
-                         (cons (cons (car (car ulist)) p) math-fbu-base))))
-               (setq ulist (cdr ulist)))))
+           (dolist (x (math-find-base-units u))
+             (let ((p (* (cdr x) pow))
+                   (old (assq (car x) math-fbu-base)))
+               (if old
+                   (setcdr old (+ (cdr old) p))
+                 (setq math-fbu-base
+                       (cons (cons (car x) p) math-fbu-base))))))
           ((math-scalarp expr))
           ((and (eq (car expr) '^)
                 (integerp (nth 2 expr)))
@@ -1377,20 +1372,15 @@ If COMP or STD is non-nil, put that in the units table instead."
                (if (eq pow1 1)
                    (math-to-standard-units (list '/ n d) nil)
                  (list '^ (math-to-standard-units (list '/ n d) nil) pow1))
-             (let (ud1)
-               (setq un (nth 4 un)
-                     ud (nth 4 ud))
-               (while un
-                 (setq ud1 ud)
-                 (while ud1
-                   (and (eq (car (car un)) (car (car ud1)))
-                        (setq math-try-cancel-units
-                              (+ math-try-cancel-units
-                                 (- (* (cdr (car un)) pow1)
-                                    (* (cdr (car ud)) pow2)))))
-                   (setq ud1 (cdr ud1)))
-                 (setq un (cdr un)))
-               nil))))))
+             (setq un (nth 4 un)
+                   ud (nth 4 ud))
+             (dolist (x un)
+               (dolist (y ud)
+                 (when (eq (car x) (car y))
+                   (setq math-try-cancel-units
+                         (+ math-try-cancel-units
+                            (- (* (cdr x) pow1)
+                               (* (cdr (car ud)) pow2))))))))))))
 
 (math-defsimplify ^
   (and math-simplifying-units
@@ -1578,9 +1568,8 @@ If COMP or STD is non-nil, put that in the units table instead."
             (insert "Calculator Units Table:\n\n")
             (insert "(All definitions are exact unless marked with an asterisk (*).)\n\n")
             (insert "Unit    Type  Definition                  Description\n\n")
-            (while uptr
-              (setq u (car uptr)
-                    name (nth 2 u))
+            (dolist (u uptr)
+              (setq name (nth 2 u))
               (when (eq (car u) 'm)
                 (setq std t))
               (setq shadowed (and std (assq (car u) math-additional-units)))
@@ -1618,8 +1607,7 @@ If COMP or STD is non-nil, put that in the units table instead."
                   (insert " (redefined above)")
                 (unless (nth 1 u)
                   (insert " (base unit)")))
-              (insert "\n")
-              (setq uptr (cdr uptr)))
+              (insert "\n"))
             (insert "\n\nUnit Prefix Table:\n\n")
             (setq uptr math-unit-prefixes)
             (while uptr
diff --git a/lisp/descr-text.el b/lisp/descr-text.el
index 6a6a8ea4479..6f36bbed680 100644
--- a/lisp/descr-text.el
+++ b/lisp/descr-text.el
@@ -413,12 +413,11 @@ relevant to POS."
            (multibyte-p enable-multibyte-characters)
            (overlays (mapcar (lambda (o) (overlay-properties o))
                              (overlays-at pos)))
-           (char-description (if (not multibyte-p)
+           (char-description (if (< char 128)
                                  (single-key-description char)
-                               (if (< char 128)
-                                   (single-key-description char)
-                                 (string-to-multibyte
-                                  (char-to-string char)))))
+                               (string (if (not multibyte-p)
+                                           (decode-char 'eight-bit char)
+                                         char))))
            (text-props-desc
             (let ((tmp-buf (generate-new-buffer " *text-props*")))
               (unwind-protect
@@ -635,7 +634,9 @@ relevant to POS."
               ("buffer code"
                ,(if multibyte-p
                     (encoded-string-description
-                     (string-as-unibyte (char-to-string char)) nil)
+                     (encode-coding-string (char-to-string char)
+                                           'emacs-internal)
+                     nil)
                   (format "#x%02X" char)))
               ("file code"
                ,@(if multibyte-p
@@ -704,7 +705,6 @@ relevant to POS."
                        (called-interactively-p 'interactive))
       (with-help-window (help-buffer)
         (with-current-buffer standard-output
-          (set-buffer-multibyte multibyte-p)
           (let ((formatter (format "%%%ds:" max-width)))
             (dolist (elt item-list)
               (when (cadr elt)
diff --git a/lisp/dired-aux.el b/lisp/dired-aux.el
index ec07f9bf735..12a97f8457e 100644
--- a/lisp/dired-aux.el
+++ b/lisp/dired-aux.el
@@ -51,6 +51,33 @@ into this list; they also should call `dired-log' to log the errors.")
 
 (defconst dired-star-subst-regexp "\\(^\\|[ \t]\\)\\*\\([ \t]\\|$\\)")
 (defconst dired-quark-subst-regexp "\\(^\\|[ \t]\\)\\?\\([ \t]\\|$\\)")
+(make-obsolete-variable 'dired-star-subst-regexp nil "26.1")
+(make-obsolete-variable 'dired-quark-subst-regexp nil "26.1")
+
+(defun dired-isolated-string-re (string)
+  "Return a regexp to match STRING isolated.
+Isolated means that STRING is surrounded by spaces or at the beginning/end
+of a string followed/prefixed with an space.
+The regexp capture the preceding blank, STRING and the following blank as
+the groups 1, 2 and 3 respectively."
+  (format "\\(\\`\\|[ \t]\\)\\(%s\\)\\([ \t]\\|\\'\\)" string))
+
+(defun dired--star-or-qmark-p (string match &optional keep)
+  "Return non-nil if STRING contains isolated MATCH or `\\=`?\\=`'.
+MATCH should be the strings \"?\", `\\=`?\\=`', \"*\" or nil.  The latter
+means STRING contains either \"?\" or `\\=`?\\=`' or \"*\".
+If optional arg KEEP is non-nil, then preserve the match data.  Otherwise,
+this function changes it and saves MATCH as the second match group.
+
+Isolated means that MATCH is surrounded by spaces or at the beginning/end
+of STRING followed/prefixed with an space.  A match to `\\=`?\\=`',
+isolated or not, is also valid."
+  (let ((regexps (list (dired-isolated-string-re (if match (regexp-quote match) "[*?]")))))
+    (when (or (null match) (equal match "?"))
+      (setq regexps (append (list "\\(\\)\\(`\\?`\\)\\(\\)") regexps)))
+    (cl-some (lambda (x)
+               (funcall (if keep #'string-match-p #'string-match) x string))
+             regexps)))
 
 ;;;###autoload
 (defun dired-diff (file &optional switches)
@@ -308,7 +335,7 @@ List has a form of (file-name full-file-name (attribute-list))."
          failures)
     (setq failures
           (dired-bunch-files 10000
-                             (function dired-check-process)
+                             #'dired-check-process
                              (append
                               (list operation program)
                               (unless (or (string-equal new-attribute "")
@@ -512,7 +539,7 @@ with a prefix argument."
     ;; If the file has numeric backup versions,
     ;; put on dired-file-version-alist an element of the form
     ;; (FILENAME . VERSION-NUMBER-LIST)
-    (dired-map-dired-file-lines (function dired-collect-file-versions))
+    (dired-map-dired-file-lines #'dired-collect-file-versions)
     ;; Sort each VERSION-NUMBER-LIST,
     ;; and remove the versions not to be deleted.
     (let ((fval dired-file-version-alist))
@@ -528,7 +555,7 @@ with a prefix argument."
         (setq fval (cdr fval))))
     ;; Look at each file.  If it is a numeric backup file,
     ;; find it in a VERSION-NUMBER-LIST and maybe flag it for deletion.
-    (dired-map-dired-file-lines (function dired-trample-file-versions))
+    (dired-map-dired-file-lines #'dired-trample-file-versions)
     (message "Cleaning numerical backups...done")))
 
 ;;; Subroutines of dired-clean-directory.
@@ -658,13 +685,13 @@ If there is a `*' in COMMAND, surrounded by whitespace, this runs
 COMMAND just once with the entire file list substituted there.
 
 If there is no `*', but there is a `?' in COMMAND, surrounded by
-whitespace, this runs COMMAND on each file individually with the
-file name substituted for `?'.
+whitespace, or a `\\=`?\\=`' this runs COMMAND on each file
+individually with the file name substituted for `?' or `\\=`?\\=`'.
 
 Otherwise, this runs COMMAND on each file individually with the
 file name added at the end of COMMAND (separated by a space).
 
-`*' and `?' when not surrounded by whitespace have no special
+`*' and `?' when not surrounded by whitespace nor `\\=`' have no special
 significance for `dired-do-shell-command', and are passed through
 normally to the shell, but you must confirm first.
 
@@ -704,32 +731,40 @@ can be produced by `dired-get-marked-files', for example."
       (dired-read-shell-command "! on %s: " current-prefix-arg files)
       current-prefix-arg
       files)))
-  (let* ((on-each (not (string-match-p dired-star-subst-regexp command)))
-         (no-subst (not (string-match-p dired-quark-subst-regexp command)))
-         (star (string-match-p "\\*" command))
-         (qmark (string-match-p "\\?" command)))
-    ;; Get confirmation for wildcards that may have been meant
-    ;; to control substitution of a file name or the file name list.
-    (if (cond ((not (or on-each no-subst))
-               (error "You can not combine `*' and `?' substitution marks"))
-              ((and star on-each)
-               (y-or-n-p (format-message
-                          "Confirm--do you mean to use `*' as a wildcard? ")))
-              ((and qmark no-subst)
-               (y-or-n-p (format-message
-                          "Confirm--do you mean to use `?' as a wildcard? ")))
-              (t))
-        (if on-each
-            (dired-bunch-files
-             (- 10000 (length command))
-             (function (lambda (&rest files)
-                         (dired-run-shell-command
-                          (dired-shell-stuff-it command files t arg))))
-             nil
-             file-list)
-          ;; execute the shell command
-          (dired-run-shell-command
-           (dired-shell-stuff-it command file-list nil arg))))))
+  (cl-flet ((need-confirm-p
+             (cmd str)
+             (let ((res cmd)
+                   (regexp (regexp-quote str)))
+               ;; Drop all ? and * surrounded by spaces and `?`.
+               (while (and (string-match regexp res)
+                           (dired--star-or-qmark-p res str))
+                 (setq res (replace-match "" t t res 0)))
+               (string-match regexp res))))
+  (let* ((on-each (not (dired--star-or-qmark-p command "*" 'keep)))
+         (no-subst (not (dired--star-or-qmark-p command "?" 'keep)))
+         (star (string-match "\\*" command))
+         (qmark (string-match "\\?" command))
+         ;; Get confirmation for wildcards that may have been meant
+         ;; to control substitution of a file name or the file name list.
+         (ok (cond ((not (or on-each no-subst))
+                    (error "You can not combine `*' and `?' substitution marks"))
+                   ((need-confirm-p command "*")
+                    (y-or-n-p (format-message
+                               "Confirm--do you mean to use `*' as a wildcard? ")))
+                   ((need-confirm-p command "?")
+                    (y-or-n-p (format-message
+                               "Confirm--do you mean to use `?' as a wildcard? ")))
+                   (t))))
+    (when ok
+      (if on-each
+          (dired-bunch-files (- 10000 (length command))
+                             (lambda (&rest files)
+                               (dired-run-shell-command
+                                (dired-shell-stuff-it command files t arg)))
+                             nil file-list)
+        ;; execute the shell command
+        (dired-run-shell-command
+         (dired-shell-stuff-it command file-list nil arg)))))))
 
 ;; Might use {,} for bash or csh:
 (defvar dired-mark-prefix ""
@@ -769,12 +804,10 @@ can be produced by `dired-get-marked-files', for example."
                       ";"
                     "&"))
          (stuff-it
-          (if (or (string-match-p dired-star-subst-regexp command)
-                  (string-match-p dired-quark-subst-regexp command))
+          (if (dired--star-or-qmark-p command nil 'keep)
               (lambda (x)
                 (let ((retval (concat cmd-prefix command)))
-                  (while (string-match
-                          "\\(^\\|[ \t]\\)\\([*?]\\)\\([ \t]\\|$\\)" retval)
+                  (while (dired--star-or-qmark-p retval nil)
                     (setq retval (replace-match x t t retval 2)))
                   retval))
             (lambda (x) (concat cmd-prefix command dired-mark-separator x)))))
@@ -1122,7 +1155,7 @@ Return nil if no change in files."
       (let ((files (dired-get-marked-files t arg nil t))
             (string (if (eq op-symbol 'compress) "Compress or uncompress"
                       (capitalize (symbol-name op-symbol)))))
-        (dired-mark-pop-up nil op-symbol files (function y-or-n-p)
+        (dired-mark-pop-up nil op-symbol files #'y-or-n-p
                            (concat string " "
                                    (dired-mark-prompt arg files) "? ")))))
 
@@ -1190,7 +1223,7 @@ return t; if SYM is q or ESC, return nil."
 (defun dired-do-compress (&optional arg)
   "Compress or uncompress marked (or next ARG) files."
   (interactive "P")
-  (dired-map-over-marks-check (function dired-compress) arg 'compress t))
+  (dired-map-over-marks-check #'dired-compress arg 'compress t))
 
 ;; Commands for Emacs Lisp files - load and byte compile
 
@@ -1218,7 +1251,7 @@ return t; if SYM is q or ESC, return nil."
 (defun dired-do-byte-compile (&optional arg)
   "Byte compile marked (or next ARG) Emacs Lisp files."
   (interactive "P")
-  (dired-map-over-marks-check (function dired-byte-compile) arg 'byte-compile t))
+  (dired-map-over-marks-check #'dired-byte-compile arg 'byte-compile t))
 
 (defun dired-load ()
   ;; Return nil for success, offending file name else.
@@ -1235,7 +1268,7 @@ return t; if SYM is q or ESC, return nil."
 (defun dired-do-load (&optional arg)
   "Load the marked (or next ARG) Emacs Lisp files."
   (interactive "P")
-  (dired-map-over-marks-check (function dired-load) arg 'load t))
+  (dired-map-over-marks-check #'dired-load arg 'load t))
 
 ;;;###autoload
 (defun dired-do-redisplay (&optional arg test-for-subdir)
@@ -1308,7 +1341,7 @@ See Info node `(emacs)Subdir switches' for more details."
 (defun dired-add-file (filename &optional marker-char)
   (dired-fun-in-all-buffers
    (file-name-directory filename) (file-name-nondirectory filename)
-   (function dired-add-entry) filename marker-char))
+   #'dired-add-entry filename marker-char))
 
 (defvar dired-omit-mode)
 (declare-function dired-omit-regexp "dired-x" ())
@@ -1445,7 +1478,7 @@ files matching `dired-omit-regexp'."
 (defun dired-remove-file (file)
   (dired-fun-in-all-buffers
    (file-name-directory file) (file-name-nondirectory file)
-   (function dired-remove-entry) file))
+   #'dired-remove-entry file))
 
 (defun dired-remove-entry (file)
   (save-excursion
@@ -1459,7 +1492,7 @@ files matching `dired-omit-regexp'."
   "Create or update the line for FILE in all Dired buffers it would belong in."
   (dired-fun-in-all-buffers (file-name-directory file)
                             (file-name-nondirectory file)
-                            (function dired-relist-entry) file))
+                            #'dired-relist-entry file))
 
 (defun dired-relist-entry (file)
   ;; Relist the line for FILE, or just add it if it did not exist.
@@ -1553,7 +1586,7 @@ Special value `always' suppresses confirmation."
   (setq from-dir (file-name-as-directory from-dir)
         to-dir (file-name-as-directory to-dir))
   (dired-fun-in-all-buffers from-dir nil
-                            (function dired-rename-subdir-1) from-dir to-dir)
+                            #'dired-rename-subdir-1 from-dir to-dir)
   ;; Update visited file name of all affected buffers
   (let ((expanded-from-dir (expand-file-name from-dir))
         (blist (buffer-list)))
@@ -1788,7 +1821,7 @@ Optional arg HOW-TO determines how to treat the target.
    For any other return value, TARGET is treated as a directory."
   (or op1 (setq op1 operation))
   (let* ((fn-list (dired-get-marked-files nil arg))
-         (rfn-list (mapcar (function dired-make-relative) fn-list))
+         (rfn-list (mapcar #'dired-make-relative fn-list))
          (dired-one-file        ; fluid variable inside dired-create-files
           (and (consp fn-list) (null (cdr fn-list)) (car fn-list)))
          (target-dir (dired-dwim-target-directory))
@@ -1838,10 +1871,9 @@ Optional arg HOW-TO determines how to treat the target.
        (if into-dir                     ; target is a directory
            ;; This function uses fluid variable target when called
            ;; inside dired-create-files:
-           (function
-            (lambda (from)
-              (expand-file-name (file-name-nondirectory from) target)))
-         (function (lambda (_from) target)))
+           (lambda (from)
+             (expand-file-name (file-name-nondirectory from) target))
+         (lambda (_from) target))
        marker-char))))
 
 ;; Read arguments for a marked-files command that wants a file name,
@@ -1857,7 +1889,7 @@ Optional arg HOW-TO determines how to treat the target.
                                          &optional default)
   (dired-mark-pop-up
    nil op-symbol files
-   (function read-file-name)
+   #'read-file-name
    (format prompt (dired-mark-prompt arg files)) dir default))
 
 (defun dired-dwim-target-directory ()
@@ -1985,7 +2017,7 @@ This command copies symbolic links by creating new ones, similar
 to the \"-d\" option for the \"cp\" shell command."
   (interactive "P")
   (let ((dired-recursive-copies dired-recursive-copies))
-    (dired-do-create-files 'copy (function dired-copy-file)
+    (dired-do-create-files 'copy #'dired-copy-file
                            "Copy"
                            arg dired-keep-marker-copy
                            nil dired-copy-how-to-fn)))
@@ -2002,7 +2034,7 @@ suggested for the target directory depends on the value of
 
 For relative symlinks, use \\[dired-do-relsymlink]."
   (interactive "P")
-  (dired-do-create-files 'symlink (function make-symbolic-link)
+  (dired-do-create-files 'symlink #'make-symbolic-link
                            "Symlink" arg dired-keep-marker-symlink))
 
 ;;;###autoload
@@ -2015,7 +2047,7 @@ with the same names that the files currently have.  The default
 suggested for the target directory depends on the value of
 `dired-dwim-target', which see."
   (interactive "P")
-  (dired-do-create-files 'hardlink (function dired-hardlink)
+  (dired-do-create-files 'hardlink #'dired-hardlink
                            "Hardlink" arg dired-keep-marker-hardlink))
 
 (defun dired-hardlink (file newname &optional ok-if-already-exists)
@@ -2034,7 +2066,7 @@ This command also renames any buffers that are visiting the files.
 The default suggested for the target directory depends on the value
 of `dired-dwim-target', which see."
   (interactive "P")
-  (dired-do-create-files 'move (function dired-rename-file)
+  (dired-do-create-files 'move #'dired-rename-file
                          "Move" arg dired-keep-marker-rename "Rename"))
 ;;;###end dired-cp.el
 
@@ -2062,37 +2094,35 @@ Type SPC or `y' to %s one match, DEL or `n' to skip to next,
          (regexp-name-constructor
           ;; Function to construct new filename using REGEXP and NEWNAME:
           (if whole-name                ; easy (but rare) case
-              (function
-               (lambda (from)
-                 (let ((to (dired-string-replace-match regexp from newname))
-                       ;; must bind help-form directly around call to
-                       ;; dired-query
-                       (help-form rename-regexp-help-form))
-                   (if to
-                       (and (dired-query 'rename-regexp-query
-                                         operation-prompt
-                                         from
-                                         to)
-                            to)
-                     (dired-log "%s: %s did not match regexp %s\n"
-                                operation from regexp)))))
-            ;; not whole-name, replace non-directory part only
-            (function
-             (lambda (from)
-               (let* ((new (dired-string-replace-match
-                            regexp (file-name-nondirectory from) newname))
-                      (to (and new      ; nil means there was no match
-                               (expand-file-name new
-                                                 (file-name-directory from))))
+              (lambda (from)
+                (let ((to (dired-string-replace-match regexp from newname))
+                      ;; must bind help-form directly around call to
+                      ;; dired-query
                       (help-form rename-regexp-help-form))
-                 (if to
-                     (and (dired-query 'rename-regexp-query
-                                       operation-prompt
-                                       (dired-make-relative from)
-                                       (dired-make-relative to))
-                          to)
-                   (dired-log "%s: %s did not match regexp %s\n"
-                              operation (file-name-nondirectory from) regexp)))))))
+                  (if to
+                      (and (dired-query 'rename-regexp-query
+                                        operation-prompt
+                                        from
+                                        to)
+                           to)
+                    (dired-log "%s: %s did not match regexp %s\n"
+                               operation from regexp))))
+            ;; not whole-name, replace non-directory part only
+            (lambda (from)
+              (let* ((new (dired-string-replace-match
+                           regexp (file-name-nondirectory from) newname))
+                     (to (and new       ; nil means there was no match
+                              (expand-file-name new
+                                                (file-name-directory from))))
+                     (help-form rename-regexp-help-form))
+                (if to
+                    (and (dired-query 'rename-regexp-query
+                                      operation-prompt
+                                      (dired-make-relative from)
+                                      (dired-make-relative to))
+                         to)
+                  (dired-log "%s: %s did not match regexp %s\n"
+                             operation (file-name-nondirectory from) regexp))))))
          rename-regexp-query)
     (dired-create-files
      file-creator operation fn-list regexp-name-constructor marker-char)))
@@ -2130,7 +2160,7 @@ With a zero prefix arg, renaming by regexp affects the absolute file name.
 Normally, only the non-directory part of the file name is used and changed."
   (interactive (dired-mark-read-regexp "Rename"))
   (dired-do-create-files-regexp
-   (function dired-rename-file)
+   #'dired-rename-file
    "Rename" arg regexp newname whole-name dired-keep-marker-rename))
 
 ;;;###autoload
@@ -2140,7 +2170,7 @@ See function `dired-do-rename-regexp' for more info."
   (interactive (dired-mark-read-regexp "Copy"))
   (let ((dired-recursive-copies nil))   ; No recursive copies.
     (dired-do-create-files-regexp
-     (function dired-copy-file)
+     #'dired-copy-file
      (if dired-copy-preserve-time "Copy [-p]" "Copy")
      arg regexp newname whole-name dired-keep-marker-copy)))
 
@@ -2150,7 +2180,7 @@ See function `dired-do-rename-regexp' for more info."
 See function `dired-do-rename-regexp' for more info."
   (interactive (dired-mark-read-regexp "HardLink"))
   (dired-do-create-files-regexp
-   (function add-name-to-file)
+   #'add-name-to-file
    "HardLink" arg regexp newname whole-name dired-keep-marker-hardlink))
 
 ;;;###autoload
@@ -2159,7 +2189,7 @@ See function `dired-do-rename-regexp' for more info."
 See function `dired-do-rename-regexp' for more info."
   (interactive (dired-mark-read-regexp "SymLink"))
   (dired-do-create-files-regexp
-   (function make-symbolic-link)
+   #'make-symbolic-link
    "SymLink" arg regexp newname whole-name dired-keep-marker-symlink))
 
 (defvar rename-non-directory-query)
@@ -2174,39 +2204,38 @@ See function `dired-do-rename-regexp' for more info."
      file-creator
      operation
      (dired-get-marked-files nil arg)
-     (function
-      (lambda (from)
-        (let ((to (concat (file-name-directory from)
-                          (funcall basename-constructor
-                                   (file-name-nondirectory from)))))
-          (and (let ((help-form (format-message "\
+     (lambda (from)
+       (let ((to (concat (file-name-directory from)
+                         (funcall basename-constructor
+                                  (file-name-nondirectory from)))))
+         (and (let ((help-form (format-message "\
 Type SPC or `y' to %s one file, DEL or `n' to skip to next,
 `!' to %s all remaining matches with no more questions."
-                                                (downcase operation)
-                                                (downcase operation))))
-                 (dired-query 'rename-non-directory-query
-                              (concat operation " `%s' to `%s'")
-                              (dired-make-relative from)
-                              (dired-make-relative to)))
-               to))))
+                                               (downcase operation)
+                                               (downcase operation))))
+                (dired-query 'rename-non-directory-query
+                             (concat operation " `%s' to `%s'")
+                             (dired-make-relative from)
+                             (dired-make-relative to)))
+              to)))
      dired-keep-marker-rename)))
 
 (defun dired-rename-non-directory (basename-constructor operation arg)
   (dired-create-files-non-directory
-   (function dired-rename-file)
+   #'dired-rename-file
    basename-constructor operation arg))
 
 ;;;###autoload
 (defun dired-upcase (&optional arg)
   "Rename all marked (or next ARG) files to upper case."
   (interactive "P")
-  (dired-rename-non-directory (function upcase) "Rename upcase" arg))
+  (dired-rename-non-directory #'upcase "Rename upcase" arg))
 
 ;;;###autoload
 (defun dired-downcase (&optional arg)
   "Rename all marked (or next ARG) files to lower case."
   (interactive "P")
-  (dired-rename-non-directory (function downcase) "Rename downcase" arg))
+  (dired-rename-non-directory #'downcase "Rename downcase" arg))
 
 ;;;###end dired-re.el
 
@@ -2316,12 +2345,11 @@ This function takes some pains to conform to `ls -lR' output."
     (when real-switches
       (let (case-fold-search)
         (mapcar
-         (function
-          (lambda (x)
-            (or (eq (null (string-match-p x real-switches))
-                    (null (string-match-p x dired-actual-switches)))
-                (error
-                 "Can't have dirs with and without -%s switches together" x))))
+         (lambda (x)
+           (or (eq (null (string-match-p x real-switches))
+                   (null (string-match-p x dired-actual-switches)))
+               (error
+                "Can't have dirs with and without -%s switches together" x)))
          ;; all switches that make a difference to dired-get-filename:
          '("F" "b"))))))
 
@@ -2334,9 +2362,9 @@ This function takes some pains to conform to `ls -lR' output."
   ;; Keep the alist sorted on buffer position.
   (setq dired-subdir-alist
         (sort dired-subdir-alist
-              (function (lambda (elt1 elt2)
-                          (> (dired-get-subdir-min elt1)
-                             (dired-get-subdir-min elt2)))))))
+              (lambda (elt1 elt2)
+                (> (dired-get-subdir-min elt1)
+                   (dired-get-subdir-min elt2))))))
 
 (defun dired-kill-tree (dirname &optional remember-marks kill-root)
   "Kill all proper subdirs of DIRNAME, excluding DIRNAME itself.
diff --git a/lisp/dired.el b/lisp/dired.el
index 909735a3b54..0c1f3e4af64 100644
--- a/lisp/dired.el
+++ b/lisp/dired.el
@@ -335,9 +335,8 @@ The directory name must be absolute, but need not be fully expanded.")
 (defvar dired-re-dir (concat dired-re-maybe-mark dired-re-inode-size "d[^:]"))
 (defvar dired-re-sym (concat dired-re-maybe-mark dired-re-inode-size "l[^:]"))
 (defvar dired-re-exe;; match ls permission string of an executable file
-  (mapconcat (function
-              (lambda (x)
-                (concat dired-re-maybe-mark dired-re-inode-size x)))
+  (mapconcat (lambda (x)
+                (concat dired-re-maybe-mark dired-re-inode-size x))
              '("-[-r][-w][xs][-r][-w].[-r][-w]."
                "-[-r][-w].[-r][-w][xs][-r][-w]."
                "-[-r][-w].[-r][-w].[-r][-w][xst]")
@@ -607,9 +606,9 @@ marked file, return (t FILENAME) instead of (FILENAME)."
                  (progn ;; no save-excursion, want to move point.
                    (dired-repeat-over-lines
                     ,arg
-                    (function (lambda ()
-                                (if ,show-progress (sit-for 0))
-                                (setq results (cons ,body results)))))
+                    (lambda ()
+                      (if ,show-progress (sit-for 0))
+                      (setq results (cons ,body results))))
                    (if (< ,arg 0)
                        (nreverse results)
                      results))
@@ -1995,8 +1994,8 @@ Keybindings:
   ;; Ignore dired-hide-details-* value of invisible text property by default.
   (when (eq buffer-invisibility-spec t)
     (setq buffer-invisibility-spec (list t)))
-  (setq-local revert-buffer-function (function dired-revert))
-  (setq-local buffer-stale-function (function dired-buffer-stale-p))
+  (setq-local revert-buffer-function #'dired-revert)
+  (setq-local buffer-stale-function #'dired-buffer-stale-p)
   (setq-local page-delimiter "\n\n")
   (setq-local dired-directory (or dirname default-directory))
   ;; list-buffers uses this to display the dir being edited in this buffer.
@@ -2469,7 +2468,7 @@ You can then feed the file name(s) to other commands with \\[yank]."
   (interactive "P")
   (let ((string
          (or (dired-get-subdir)
-             (mapconcat (function identity)
+             (mapconcat #'identity
                         (if arg
                             (cond ((zerop (prefix-numeric-value arg))
                                    (dired-get-marked-files))
@@ -2971,12 +2970,12 @@ non-empty directories is allowed."
   ;; lines still to be changed, so the (point) values in L stay valid.
   ;; Also, for subdirs in natural order, a subdir's files are deleted
   ;; before the subdir itself - the other way around would not work.
-  (let* ((files (mapcar (function car) l))
+  (let* ((files (mapcar #'car l))
          (count (length l))
          (succ 0)
          (trashing (and trash delete-by-moving-to-trash)))
     ;; canonicalize file list for pop up
-    (setq files (nreverse (mapcar (function dired-make-relative) files)))
+    (setq files (nreverse (mapcar #'dired-make-relative files)))
     (if (dired-mark-pop-up
          " *Deletions*" 'delete files dired-deletion-confirmer
          (format "%s %s "
@@ -2999,7 +2998,7 @@ non-empty directories is allowed."
                       (progress-reporter-update progress-reporter succ)
                       (dired-fun-in-all-buffers
                        (file-name-directory fn) (file-name-nondirectory fn)
-                       (function dired-delete-entry) fn))
+                       #'dired-delete-entry fn))
                   (error ;; catch errors from failed deletions
                    (dired-log "%s\n" err)
                    (setq failures (cons (car (car l)) failures)))))
@@ -3293,7 +3292,7 @@ this subdir."
     (let ((inhibit-read-only t))
       (dired-repeat-over-lines
        (prefix-numeric-value arg)
-       (function (lambda () (delete-char 1) (insert dired-marker-char))))))))
+       (lambda () (delete-char 1) (insert dired-marker-char)))))))
 
 (defun dired-unmark (arg &optional interactive)
   "Unmark the file at point in the Dired buffer.
@@ -3928,7 +3927,7 @@ Ask means pop up a menu for the user to select one of copy, move or link."
    (cdr
      (nreverse
        (mapcar
-         (function (lambda (f) (desktop-file-name (car f) dirname)))
+        (lambda (f) (desktop-file-name (car f) dirname))
          dired-subdir-alist)))))
 
 (defun dired-restore-desktop-buffer (_file-name
diff --git a/lisp/electric.el b/lisp/electric.el
index 4078ef8193e..1564df5949c 100644
--- a/lisp/electric.el
+++ b/lisp/electric.el
@@ -443,11 +443,24 @@ quote, left double quote, and right double quote, respectively."
   :version "25.1"
   :type 'boolean :safe 'booleanp :group 'electricity)
 
+(defcustom electric-quote-context-sensitive nil
+  "Non-nil means to replace \\=' with an electric quote depending on context.
+If `electric-quote-context-sensitive' is non-nil, Emacs replaces
+\\=' and \\='\\=' with an opening quote after a line break,
+whitespace, opening parenthesis, or quote and leaves \\=` alone."
+  :version "26.1"
+  :type 'boolean :safe #'booleanp :group 'electricity)
+
+(defvar electric-quote-code-faces ()
+  "List of faces to treat as inline code in `text-mode'.")
+
 (defun electric-quote-post-self-insert-function ()
   "Function that `electric-quote-mode' adds to `post-self-insert-hook'.
 This requotes when a quoting key is typed."
   (when (and electric-quote-mode
-             (memq last-command-event '(?\' ?\`)))
+             (or (eq last-command-event ?\')
+                 (and (not electric-quote-context-sensitive)
+                      (eq last-command-event ?\`))))
     (let ((start
            (if (and comment-start comment-use-syntax)
                (when (or electric-quote-comment electric-quote-string)
@@ -462,30 +475,45 @@ This requotes when a quoting key is typed."
                                          (syntax-ppss (1- (point)))))))))
              (and electric-quote-paragraph
                   (derived-mode-p 'text-mode)
+                  ;; FIXME: There should be a ‘cl-disjoint’ function.
+                  (null (cl-intersection (face-at-point nil 'multiple)
+                                         electric-quote-code-faces
+                                         :test #'eq))
+                  ;; FIXME: Why is the next form there?  It’s never
+                  ;; nil.
                   (or (eq last-command-event ?\`)
                       (save-excursion (backward-paragraph) (point)))))))
       (pcase electric-quote-chars
         (`(,q< ,q> ,q<< ,q>>)
          (when start
            (save-excursion
-             (if (eq last-command-event ?\`)
-                 (cond ((search-backward (string q< ?`) (- (point) 2) t)
-                        (replace-match (string q<<))
-                        (when (and electric-pair-mode
-                                   (eq (cdr-safe
-                                        (assq q< electric-pair-text-pairs))
-                                       (char-after)))
-                          (delete-char 1))
-                        (setq last-command-event q<<))
-                       ((search-backward "`" (1- (point)) t)
-                        (replace-match (string q<))
-                        (setq last-command-event q<)))
-               (cond ((search-backward (string q> ?') (- (point) 2) t)
-                      (replace-match (string q>>))
-                      (setq last-command-event q>>))
-                     ((search-backward "'" (1- (point)) t)
-                      (replace-match (string q>))
-                      (setq last-command-event q>)))))))))))
+             (let ((backtick ?\`))
+               (if (or (eq last-command-event ?\`)
+                       (and electric-quote-context-sensitive
+                            (save-excursion
+                              (backward-char)
+                              (or (bobp) (bolp)
+                                  (memq (char-before) (list q< q<<))
+                                  (memq (char-syntax (char-before))
+                                        '(?\s ?\())))
+                            (setq backtick ?\')))
+                   (cond ((search-backward (string q< backtick) (- (point) 2) t)
+                          (replace-match (string q<<))
+                          (when (and electric-pair-mode
+                                     (eq (cdr-safe
+                                          (assq q< electric-pair-text-pairs))
+                                         (char-after)))
+                            (delete-char 1))
+                          (setq last-command-event q<<))
+                         ((search-backward (string backtick) (1- (point)) t)
+                          (replace-match (string q<))
+                          (setq last-command-event q<)))
+                 (cond ((search-backward (string q> ?') (- (point) 2) t)
+                        (replace-match (string q>>))
+                        (setq last-command-event q>>))
+                       ((search-backward "'" (1- (point)) t)
+                        (replace-match (string q>))
+                        (setq last-command-event q>))))))))))))
 
 (put 'electric-quote-post-self-insert-function 'priority 10)
 
diff --git a/lisp/emacs-lisp/cl-extra.el b/lisp/emacs-lisp/cl-extra.el
index 3852ceb6c31..99df209d1a2 100644
--- a/lisp/emacs-lisp/cl-extra.el
+++ b/lisp/emacs-lisp/cl-extra.el
@@ -437,22 +437,38 @@ as an integer unless JUNK-ALLOWED is non-nil."
 
 ;; Random numbers.
 
+(defun cl--random-time ()
+  (let* ((time (copy-sequence (current-time-string))) (i (length time)) (v 0))
+    (while (>= (cl-decf i) 0) (setq v (+ (* v 3) (aref time i))))
+    v))
+
+;;;###autoload (autoload 'cl-random-state-p "cl-extra")
+(cl-defstruct (cl--random-state
+               (:copier nil)
+               (:predicate cl-random-state-p)
+               (:constructor nil)
+               (:constructor cl--make-random-state (vec)))
+  (i -1) (j 30) vec)
+
+(defvar cl--random-state (cl--make-random-state (cl--random-time)))
+
 ;;;###autoload
 (defun cl-random (lim &optional state)
   "Return a random nonnegative number less than LIM, an integer or float.
 Optional second arg STATE is a random-state object."
   (or state (setq state cl--random-state))
   ;; Inspired by "ran3" from Numerical Recipes.  Additive congruential method.
-  (let ((vec (aref state 3)))
+  (let ((vec (cl--random-state-vec state)))
     (if (integerp vec)
         (let ((i 0) (j (- 1357335 (abs (% vec 1357333)))) (k 1))
-          (aset state 3 (setq vec (make-vector 55 nil)))
+          (setf (cl--random-state-vec state)
+                (setq vec (make-vector 55 nil)))
           (aset vec 0 j)
           (while (> (setq i (% (+ i 21) 55)) 0)
             (aset vec i (setq j (prog1 k (setq k (- j k))))))
           (while (< (setq i (1+ i)) 200) (cl-random 2 state))))
-    (let* ((i (aset state 1 (% (1+ (aref state 1)) 55)))
-           (j (aset state 2 (% (1+ (aref state 2)) 55)))
+    (let* ((i (cl-callf (lambda (x) (% (1+ x) 55)) (cl--random-state-i state)))
+           (j (cl-callf (lambda (x) (% (1+ x) 55)) (cl--random-state-j state)))
            (n (logand 8388607 (aset vec i (- (aref vec i) (aref vec j))))))
       (if (integerp lim)
           (if (<= lim 512) (% n lim)
@@ -466,17 +482,10 @@ Optional second arg STATE is a random-state object."
 (defun cl-make-random-state (&optional state)
   "Return a copy of random-state STATE, or of the internal state if omitted.
 If STATE is t, return a new state object seeded from the time of day."
-  (cond ((null state) (cl-make-random-state cl--random-state))
-        ((vectorp state) (copy-tree state t))
-        ((integerp state) (vector 'cl--random-state-tag -1 30 state))
-        (t (cl-make-random-state (cl--random-time)))))
-
-;;;###autoload
-(defun cl-random-state-p (object)
-  "Return t if OBJECT is a random-state object."
-  (and (vectorp object) (= (length object) 4)
-       (eq (aref object 0) 'cl--random-state-tag)))
-
+  (unless state (setq state cl--random-state))
+  (if (cl-random-state-p state)
+      (copy-tree state t)
+    (cl--make-random-state (if (integerp state) state (cl--random-time)))))
 
 ;; Implementation limits.
 
diff --git a/lisp/emacs-lisp/cl-print.el b/lisp/emacs-lisp/cl-print.el
index 89a71d1b6c5..e9ca0412848 100644
--- a/lisp/emacs-lisp/cl-print.el
+++ b/lisp/emacs-lisp/cl-print.el
@@ -90,7 +90,7 @@ call other entry points instead, such as `cl-prin1'."
 - `disassemble' to print the disassembly of the code.
 - nil to skip printing any details about the code.")
 
-(defvar cl-print-compiled-button nil
+(defvar cl-print-compiled-button t
   "Control how to print byte-compiled functions into buffers.
 When the stream is a buffer, make the bytecode part of the output
 into a button whose action shows the function's disassembly.")
@@ -105,10 +105,11 @@ into a button whose action shows the function's disassembly.")
     (if args
         (prin1 args stream)
       (princ "()" stream)))
-  (let ((doc (documentation object 'raw)))
-    (when doc
-      (princ " " stream)
-      (prin1 doc stream)))
+  (pcase (help-split-fundoc (documentation object 'raw) object)
+    ;; Drop args which `help-function-arglist' already printed.
+    (`(,_usage . ,(and doc (guard (stringp doc))))
+     (princ " " stream)
+     (prin1 doc stream)))
   (let ((inter (interactive-form object)))
     (when inter
       (princ " " stream)
diff --git a/lisp/emacs-lisp/debug.el b/lisp/emacs-lisp/debug.el
index 83456fc31a2..2b8782590c4 100644
--- a/lisp/emacs-lisp/debug.el
+++ b/lisp/emacs-lisp/debug.el
@@ -49,6 +49,12 @@ the middle is discarded, and just the beginning and end are displayed."
   :group 'debugger
   :version "21.1")
 
+(defcustom debugger-print-function #'cl-prin1
+  "Function used to print values in the debugger backtraces."
+  :type 'function
+  :options '(cl-prin1 prin1)
+  :version "26.1")
+
 (defcustom debugger-bury-or-kill 'bury
   "What to do with the debugger buffer when exiting `debug'.
 The value affects the behavior of operations on any window
@@ -264,6 +270,40 @@ first will be printed into the backtrace buffer."
       (setq debug-on-next-call debugger-step-after-exit)
       debugger-value)))
 
+
+(defun debugger-insert-backtrace (frames do-xrefs)
+  "Format and insert the backtrace FRAMES at point.
+Make functions into cross-reference buttons if DO-XREFS is non-nil."
+  (let ((standard-output (current-buffer))
+        (eval-buffers eval-buffer-list))
+    (require 'help-mode)     ; Define `help-function-def' button type.
+    (pcase-dolist (`(,evald ,fun ,args ,flags) frames)
+      (insert (if (plist-get flags :debug-on-exit)
+                  "* " "  "))
+      (let ((fun-file (and do-xrefs (symbol-file fun 'defun)))
+            (fun-pt (point)))
+        (cond
+         ((and evald (not debugger-stack-frame-as-list))
+          (funcall debugger-print-function fun)
+          (if args (funcall debugger-print-function args) (princ "()")))
+         (t
+          (funcall debugger-print-function (cons fun args))
+          (cl-incf fun-pt)))
+        (when fun-file
+          (make-text-button fun-pt (+ fun-pt (length (symbol-name fun)))
+                            :type 'help-function-def
+                            'help-args (list fun fun-file))))
+      ;; After any frame that uses eval-buffer, insert a line that
+      ;; states the buffer position it's reading at.
+      (when (and eval-buffers (memq fun '(eval-buffer eval-region)))
+        (insert (format "  ; Reading at buffer position %d"
+                        ;; This will get the wrong result if there are
+                        ;; two nested eval-region calls for the same
+                        ;; buffer.  That's not a very useful case.
+                        (with-current-buffer (pop eval-buffers)
+                          (point)))))
+      (insert "\n"))))
+
 (defun debugger-setup-buffer (args)
   "Initialize the `*Backtrace*' buffer for entry to the debugger.
 That buffer should be current already."
@@ -271,27 +311,20 @@ That buffer should be current already."
   (erase-buffer)
   (set-buffer-multibyte t)              ;Why was it nil ?  -stef
   (setq buffer-undo-list t)
-  (let ((standard-output (current-buffer))
-        (print-escape-newlines t)
-        (print-level 8)
-        (print-length 50))
-    ;; FIXME the debugger could pass a custom callback to mapbacktrace
-    ;; instead of manipulating printed results.
-    (mapbacktrace #'backtrace--print-frame 'debug))
-  (goto-char (point-min))
-  (delete-region (point)
-                 (progn
-                   (forward-line (if (eq (car args) 'debug)
-                                     ;; Remove debug--implement-debug-on-entry
-                                     ;; and the advice's `apply' frame.
-                                     3
-                                   1))
-                   (point)))
   (insert "Debugger entered")
-  ;; lambda is for debug-on-call when a function call is next.
-  ;; debug is for debug-on-entry function called.
-  (let ((pos (point)))
+  (let ((frames (nthcdr
+                 ;; Remove debug--implement-debug-on-entry and the
+                 ;; advice's `apply' frame.
+                 (if (eq (car args) 'debug) 3 1)
+                 (backtrace-frames 'debug)))
+        (print-escape-newlines t)
+        (print-escape-control-characters t)
+        (print-level 8)
+        (print-length 50)
+        (pos (point)))
     (pcase (car args)
+      ;; lambda is for debug-on-call when a function call is next.
+      ;; debug is for debug-on-entry function called.
       ((or `lambda `debug)
        (insert "--entering a function:\n")
        (setq pos (1- (point))))
@@ -300,11 +333,9 @@ That buffer should be current already."
        (insert "--returning value: ")
        (setq pos (point))
        (setq debugger-value (nth 1 args))
-       (prin1 debugger-value (current-buffer))
-       (insert ?\n)
-       (delete-char 1)
-       (insert ? )
-       (beginning-of-line))
+       (funcall debugger-print-function debugger-value (current-buffer))
+       (setf (cl-getf (nth 3 (car frames)) :debug-on-exit) nil)
+       (insert ?\n))
       ;; Watchpoint triggered.
       ((and `watchpoint (let `(,symbol ,newval . ,details) (cdr args)))
        (insert
@@ -327,7 +358,7 @@ That buffer should be current already."
       (`error
        (insert "--Lisp error: ")
        (setq pos (point))
-       (prin1 (nth 1 args) (current-buffer))
+       (funcall debugger-print-function (nth 1 args) (current-buffer))
        (insert ?\n))
       ;; debug-on-call, when the next thing is an eval.
       (`t
@@ -337,98 +368,15 @@ That buffer should be current already."
       (_
        (insert ": ")
        (setq pos (point))
-       (prin1 (if (eq (car args) 'nil)
-                  (cdr args) args)
-              (current-buffer))
+       (funcall debugger-print-function
+                (if (eq (car args) 'nil)
+                    (cdr args) args)
+                (current-buffer))
        (insert ?\n)))
+    (debugger-insert-backtrace frames t)
     ;; Place point on "stack frame 0" (bug#15101).
-    (goto-char pos))
-  ;; After any frame that uses eval-buffer,
-  ;; insert a line that states the buffer position it's reading at.
-  (save-excursion
-    (let ((tem eval-buffer-list))
-      (while (and tem
-                  (re-search-forward "^  eval-\\(buffer\\|region\\)(" nil t))
-        (end-of-line)
-        (insert (format "  ; Reading at buffer position %d"
-                        ;; This will get the wrong result
-                        ;; if there are two nested eval-region calls
-                        ;; for the same buffer.  That's not a very useful case.
-                        (with-current-buffer (car tem)
-                          (point))))
-        (pop tem))))
-  (debugger-make-xrefs))
-
-(defun debugger-make-xrefs (&optional buffer)
-  "Attach cross-references to function names in the `*Backtrace*' buffer."
-  (interactive "b")
-  (with-current-buffer (or buffer (current-buffer))
-    (save-excursion
-      (setq buffer (current-buffer))
-      (let ((inhibit-read-only t)
-            (old-end (point-min)) (new-end (point-min)))
-        ;; If we saved an old backtrace, find the common part
-        ;; between the new and the old.
-        ;; Compare line by line, starting from the end,
-        ;; because that's the part that is likely to be unchanged.
-        (if debugger-previous-backtrace
-            (let (old-start new-start (all-match t))
-              (goto-char (point-max))
-              (with-temp-buffer
-                (insert debugger-previous-backtrace)
-                (while (and all-match (not (bobp)))
-                  (setq old-end (point))
-                  (forward-line -1)
-                  (setq old-start (point))
-                  (with-current-buffer buffer
-                    (setq new-end (point))
-                    (forward-line -1)
-                    (setq new-start (point)))
-                  (if (not (zerop
-                            (let ((case-fold-search nil))
-                              (compare-buffer-substrings
-                               (current-buffer) old-start old-end
-                               buffer new-start new-end))))
-                      (setq all-match nil))))
-              ;; Now new-end is the position of the start of the
-              ;; unchanged part in the current buffer, and old-end is
-              ;; the position of that same text in the saved old
-              ;; backtrace.  But we must subtract (point-min) since strings are
-              ;; indexed in origin 0.
-
-              ;; Replace the unchanged part of the backtrace
-              ;; with the text from debugger-previous-backtrace,
-              ;; since that already has the proper xrefs.
-              ;; With this optimization, we only need to scan
-              ;; the changed part of the backtrace.
-              (delete-region new-end (point-max))
-              (goto-char (point-max))
-              (insert (substring debugger-previous-backtrace
-                                 (- old-end (point-min))))
-              ;; Make the unchanged part of the backtrace inaccessible
-              ;; so it won't be scanned.
-              (narrow-to-region (point-min) new-end)))
-
-        ;; Scan the new part of the backtrace, inserting xrefs.
-        (goto-char (point-min))
-        (while (progn
-                 (goto-char (+ (point) 2))
-                 (skip-syntax-forward "^w_")
-                 (not (eobp)))
-          (let* ((beg (point))
-                 (end (progn (skip-syntax-forward "w_") (point)))
-                 (sym (intern-soft (buffer-substring-no-properties
-                                    beg end)))
-                 (file (and sym (symbol-file sym 'defun))))
-            (when file
-              (goto-char beg)
-              ;; help-xref-button needs to operate on something matched
-              ;; by a regexp, so set that up for it.
-              (re-search-forward "\\(\\sw\\|\\s_\\)+")
-              (help-xref-button 0 'help-function-def sym file)))
-          (forward-line 1))
-        (widen))
-      (setq debugger-previous-backtrace (buffer-string)))))
+    (goto-char pos)))
+
 
 (defun debugger-step-through ()
   "Proceed, stepping through subexpressions of this expression.
@@ -866,9 +814,13 @@ To specify a nil argument interactively, exit with an empty minibuffer."
                               'type 'help-function
                               'help-args (list fun))
             (terpri))
-          (terpri)
-          (princ "Note: if you have redefined a function, then it may no longer\n")
-          (princ "be set to debug on entry, even if it is in the list."))))))
+          ;; Now that debug--function-list uses advice-member-p, its
+          ;; output should be reliable (except for bugs and the exceptional
+          ;; case where some other advice ends up overriding ours).
+          ;;(terpri)
+          ;;(princ "Note: if you have redefined a function, then it may no longer\n")
+          ;;(princ "be set to debug on entry, even if it is in the list.")
+          )))))
 
 (defun debug--implement-debug-watch (symbol newval op where)
   "Conditionally call the debugger.
diff --git a/lisp/emacs-lisp/eieio-core.el b/lisp/emacs-lisp/eieio-core.el
index dfe1c06bfaf..9d618e1dc81 100644
--- a/lisp/emacs-lisp/eieio-core.el
+++ b/lisp/emacs-lisp/eieio-core.el
@@ -84,7 +84,7 @@ Currently under control of this var:
 (progn
   ;; Arrange for field access not to bother checking if the access is indeed
   ;; made to an eieio--class object.
-  (cl-declaim (optimize (safety 0)))
+  (eval-when-compile (cl-declaim (optimize (safety 0))))
 
 (cl-defstruct (eieio--class
                (:constructor nil)
@@ -103,8 +103,12 @@ Currently under control of this var:
   options ;; storage location of tagged class option
           ; Stored outright without modifications or stripping
   )
-  ;; Set it back to the default value.
-  (cl-declaim (optimize (safety 1))))
+  ;; Set it back to the default value.  NOTE: Using the default
+  ;; `safety' value does NOT give the default
+  ;; `byte-compile-delete-errors' value.  Therefore limit this (and
+  ;; the above `cl-declaim') to compile time so that we don't affect
+  ;; code which only loads this library.
+  (eval-when-compile (cl-declaim (optimize (safety 1)))))
 
 
 (eval-and-compile
diff --git a/lisp/emacs-lisp/ert.el b/lisp/emacs-lisp/ert.el
index 2c49a634e35..eb2b2e3e11b 100644
--- a/lisp/emacs-lisp/ert.el
+++ b/lisp/emacs-lisp/ert.el
@@ -670,48 +670,12 @@ and is displayed in front of the value of MESSAGE-FORM."
 (cl-defstruct (ert-test-aborted-with-non-local-exit
                (:include ert-test-result)))
 
-
-(defun ert--record-backtrace ()
-  "Record the current backtrace (as a list) and return it."
-  ;; Since the backtrace is stored in the result object, result
-  ;; objects must only be printed with appropriate limits
-  ;; (`print-level' and `print-length') in place.  For interactive
-  ;; use, the cost of ensuring this possibly outweighs the advantage
-  ;; of storing the backtrace for
-  ;; `ert-results-pop-to-backtrace-for-test-at-point' given that we
-  ;; already have `ert-results-rerun-test-debugging-errors-at-point'.
-  ;; For batch use, however, printing the backtrace may be useful.
-  (cl-loop
-   ;; 6 is the number of frames our own debugger adds (when
-   ;; compiled; more when interpreted).  FIXME: Need to describe a
-   ;; procedure for determining this constant.
-   for i from 6
-   for frame = (backtrace-frame i)
-   while frame
-   collect frame))
-
-(defun ert--print-backtrace (backtrace)
+(defun ert--print-backtrace (backtrace do-xrefs)
   "Format the backtrace BACKTRACE to the current buffer."
-  ;; This is essentially a reimplementation of Fbacktrace
-  ;; (src/eval.c), but for a saved backtrace, not the current one.
   (let ((print-escape-newlines t)
         (print-level 8)
         (print-length 50))
-    (dolist (frame backtrace)
-      (pcase-exhaustive frame
-        (`(nil ,special-operator . ,arg-forms)
-         ;; Special operator.
-         (insert
-          (format "  %S\n" (cons special-operator arg-forms))))
-        (`(t ,fn . ,args)
-         ;; Function call.
-         (insert (format "  %S(" fn))
-         (cl-loop for firstp = t then nil
-                  for arg in args do
-                  (unless firstp
-                    (insert " "))
-                  (insert (format "%S" arg)))
-         (insert ")\n"))))))
+    (debugger-insert-backtrace backtrace do-xrefs)))
 
 ;; A container for the state of the execution of a single test and
 ;; environment data needed during its execution.
@@ -750,7 +714,19 @@ run.  ARGS are the arguments to `debugger'."
                       ((quit) 'quit)
                       ((ert-test-skipped) 'skipped)
                       (otherwise 'failed)))
-              (backtrace (ert--record-backtrace))
+              ;; We store the backtrace in the result object for
+              ;; `ert-results-pop-to-backtrace-for-test-at-point'.
+              ;; This means we have to limit `print-level' and
+              ;; `print-length' when printing result objects.  That
+              ;; might not be worth while when we can also use
+              ;; `ert-results-rerun-test-debugging-errors-at-point',
+              ;; (i.e., when running interactively) but having the
+              ;; backtrace ready for printing is important for batch
+              ;; use.
+              ;;
+              ;; Grab the frames starting from `signal', frames below
+              ;; that are all from the debugger.
+              (backtrace (backtrace-frames 'signal))
               (infos (reverse ert--infos)))
          (setf (ert--test-execution-info-result info)
                (cl-ecase type
@@ -1409,8 +1385,9 @@ Returns the stats object."
               (ert-test-result-with-condition
                (message "Test %S backtrace:" (ert-test-name test))
                (with-temp-buffer
-                 (ert--print-backtrace (ert-test-result-with-condition-backtrace
-                                        result))
+                 (ert--print-backtrace
+                  (ert-test-result-with-condition-backtrace result)
+                  nil)
                  (goto-char (point-min))
                  (while (not (eobp))
                    (let ((start (point))
@@ -1491,7 +1468,7 @@ this exits Emacs, with status as per `ert-run-tests-batch-and-exit'."
     (with-temp-buffer
       (while (setq logfile (pop command-line-args-left))
         (erase-buffer)
-        (insert-file-contents logfile)
+        (when (file-readable-p logfile) (insert-file-contents logfile))
         (if (not (re-search-forward "^Running \\([0-9]+\\) tests" nil t))
             (push logfile notests)
           (setq ntests (+ ntests (string-to-number (match-string 1))))
@@ -1828,12 +1805,23 @@ EWOC and STATS are arguments for `ert--results-update-stats-display'."
 
 BEGIN and END specify a region in the current buffer."
   (save-excursion
-    (save-restriction
-      (narrow-to-region begin end)
-      ;; Inhibit optimization in `debugger-make-xrefs' that would
-      ;; sometimes insert unrelated backtrace info into our buffer.
-      (let ((debugger-previous-backtrace nil))
-        (debugger-make-xrefs)))))
+    (goto-char begin)
+    (while (progn
+             (goto-char (+ (point) 2))
+             (skip-syntax-forward "^w_")
+             (< (point) end))
+      (let* ((beg (point))
+             (end (progn (skip-syntax-forward "w_") (point)))
+             (sym (intern-soft (buffer-substring-no-properties
+                                beg end)))
+             (file (and sym (symbol-file sym 'defun))))
+        (when file
+          (goto-char beg)
+          ;; help-xref-button needs to operate on something matched
+          ;; by a regexp, so set that up for it.
+          (re-search-forward "\\(\\sw\\|\\s_\\)+")
+          (help-xref-button 0 'help-function-def sym file)))
+      (forward-line 1))))
 
 (defun ert--string-first-line (s)
   "Return the first line of S, or S if it contains no newlines.
@@ -2420,8 +2408,7 @@ To be used in the ERT results buffer."
            ;; Use unibyte because `debugger-setup-buffer' also does so.
            (set-buffer-multibyte nil)
            (setq truncate-lines t)
-           (ert--print-backtrace backtrace)
-           (debugger-make-xrefs)
+           (ert--print-backtrace backtrace t)
            (goto-char (point-min))
            (insert (substitute-command-keys "Backtrace for test `"))
            (ert-insert-test-name-button (ert-test-name test))
diff --git a/lisp/emacs-lisp/lisp-mnt.el b/lisp/emacs-lisp/lisp-mnt.el
index fc3caf3359a..a1c5b6977f8 100644
--- a/lisp/emacs-lisp/lisp-mnt.el
+++ b/lisp/emacs-lisp/lisp-mnt.el
@@ -326,12 +326,13 @@ Return argument is of the form (\"HOLDER\" \"YEAR1\" ... \"YEARN\")"
           (start (point))
           (end (line-end-position)))
       ;; Cope with multi-line copyright `lines'.  Assume the second
-      ;; line is indented (with the same commenting style).
+      ;; line is indented at least as much as the original, with the
+      ;; same commenting style.
       (save-excursion
         (beginning-of-line 2)
-        (let ((str (concat (match-string-no-properties 1) "[ \t]+")))
+        (let ((str (match-string-no-properties 1)))
           (beginning-of-line)
-          (while (looking-at str)
+          (while (and (looking-at str) (not (looking-at lm-copyright-prefix)))
             (setq end (line-end-position))
             (beginning-of-line 2))))
       ;; Make a single line and parse that.
diff --git a/lisp/epg.el b/lisp/epg.el
index 587271b0003..1e24b8d1169 100644
--- a/lisp/epg.el
+++ b/lisp/epg.el
@@ -1047,7 +1047,7 @@ callback data (if any)."
 (defun epg--status-TRUST_MARGINAL (context _string)
   (let ((signature (car (epg-context-result-for context 'verify))))
     (if (and signature
-             (eq (epg-signature-status signature) 'marginal))
+             (eq (epg-signature-status signature) 'good))
         (setf (epg-signature-validity signature) 'marginal))))
 
 (defun epg--status-TRUST_FULLY (context _string)
diff --git a/lisp/eshell/esh-cmd.el b/lisp/eshell/esh-cmd.el
index 86e7b83c281..24342208771 100644
--- a/lisp/eshell/esh-cmd.el
+++ b/lisp/eshell/esh-cmd.el
@@ -1148,6 +1148,8 @@ be finished later after the completion of an asynchronous subprocess."
 
 ;; command invocation
 
+(declare-function help-fns-function-description-header "help-fns")
+
 (defun eshell/which (command &rest names)
   "Identify the COMMAND, and where it is located."
   (dolist (name (cons command names))
@@ -1164,25 +1166,17 @@ be finished later after the completion of an asynchronous subprocess."
                 (concat name " is an alias, defined as \""
                         (cadr alias) "\"")))
       (unless program
-        (setq program (eshell-search-path name))
-        (let* ((esym (eshell-find-alias-function name))
-               (sym (or esym (intern-soft name))))
-          (if (and (or esym (and sym (fboundp sym)))
-                   (or eshell-prefer-lisp-functions (not direct)))
-              (let ((desc (let ((inhibit-redisplay t))
-                            (save-window-excursion
-                              (prog1
-                                  (describe-function sym)
-                                (message nil))))))
-                (setq desc (if desc (substring desc 0
-                                               (1- (or (string-match "\n" desc)
-                                                       (length desc))))
-                             ;; This should not happen.
-                             (format "%s is defined, \
-but no documentation was found" name)))
-                (if (buffer-live-p (get-buffer "*Help*"))
-                    (kill-buffer "*Help*"))
-                (setq program (or desc name))))))
+        (setq program
+              (let* ((esym (eshell-find-alias-function name))
+                     (sym (or esym (intern-soft name))))
+                (if (and (or esym (and sym (fboundp sym)))
+                         (or eshell-prefer-lisp-functions (not direct)))
+                    (or (with-output-to-string
+                          (require 'help-fns)
+                          (princ (format "%s is " sym))
+                          (help-fns-function-description-header sym))
+                        name)
+                  (eshell-search-path name)))))
       (if (not program)
           (eshell-error (format "which: no %s in (%s)\n"
                                 name (getenv "PATH")))
diff --git a/lisp/frame.el b/lisp/frame.el
index b7a55169281..b54df6fa160 100644
--- a/lisp/frame.el
+++ b/lisp/frame.el
@@ -1110,6 +1110,38 @@ differing font heights."
 If FRAME is omitted, describe the currently selected frame."
   (cdr (assq 'width (frame-parameters frame))))
 
+(defalias 'frame-border-width 'frame-internal-border-width)
+(defalias 'frame-pixel-width 'frame-native-width)
+(defalias 'frame-pixel-height 'frame-native-height)
+
+(defun frame-inner-width (&optional frame)
+  "Return inner width of FRAME in pixels.
+FRAME defaults to the selected frame."
+  (setq frame (window-normalize-frame frame))
+  (- (frame-native-width frame)
+     (* 2 (frame-internal-border-width frame))))
+
+(defun frame-inner-height (&optional frame)
+  "Return inner height of FRAME in pixels.
+FRAME defaults to the selected frame."
+  (setq frame (window-normalize-frame frame))
+  (- (frame-native-height frame)
+     (* 2 (frame-internal-border-width frame))))
+
+(defun frame-outer-width (&optional frame)
+  "Return outer width of FRAME in pixels.
+FRAME defaults to the selected frame."
+  (setq frame (window-normalize-frame frame))
+  (let ((edges (frame-edges frame 'outer-edges)))
+    (- (nth 2 edges) (nth 0 edges))))
+
+(defun frame-outer-height (&optional frame)
+  "Return outer height of FRAME in pixels.
+FRAME defaults to the selected frame."
+  (setq frame (window-normalize-frame frame))
+  (let ((edges (frame-edges frame 'outer-edges)))
+    (- (nth 3 edges) (nth 1 edges))))
+
 (declare-function x-list-fonts "xfaces.c"
                   (pattern &optional face frame maximum width))
 
diff --git a/lisp/help-fns.el b/lisp/help-fns.el
index 2c635ffa500..32324ae3bcb 100644
--- a/lisp/help-fns.el
+++ b/lisp/help-fns.el
@@ -560,8 +560,9 @@ FILE is the file where FUNCTION was probably defined."
             (setq short rel))))
     short))
 
-;;;###autoload
-(defun describe-function-1 (function)
+(defun help-fns--analyse-function (function)
+  "Return information about FUNCTION.
+Returns a list of the form (REAL-FUNCTION DEF ALIASED REAL-DEF)."
   (let* ((advised (and (symbolp function)
                        (featurep 'nadvice)
                        (advice--p (advice--symbol-function function))))
@@ -594,22 +595,24 @@ FILE is the file where FUNCTION was probably defined."
                          (setq f (symbol-function f)))
                        f))
                     ((subrp def) (intern (subr-name def)))
-                    (t def)))
-         (sig-key (if (subrp def)
-                      (indirect-function real-def)
-                    real-def))
-         (file-name (find-lisp-object-file-name function (if aliased 'defun
-                                                           def)))
-         (pt1 (with-current-buffer (help-buffer) (point)))
-         (beg (if (and (or (byte-code-function-p def)
-                           (keymapp def)
-                           (memq (car-safe def) '(macro lambda closure)))
-                       (stringp file-name)
-                       (help-fns--autoloaded-p function file-name))
-                  (if (commandp def)
-                      "an interactive autoloaded "
-                    "an autoloaded ")
-                (if (commandp def) "an interactive " "a "))))
+                    (t def))))
+    (list real-function def aliased real-def)))
+
+(defun help-fns-function-description-header (function)
+  "Print a line describing FUNCTION to `standard-output'."
+  (pcase-let* ((`(,_real-function ,def ,aliased ,real-def)
+                (help-fns--analyse-function function))
+               (file-name (find-lisp-object-file-name function (if aliased 'defun
+                                                                 def)))
+               (beg (if (and (or (byte-code-function-p def)
+                                 (keymapp def)
+                                 (memq (car-safe def) '(macro lambda closure)))
+                             (stringp file-name)
+                             (help-fns--autoloaded-p function file-name))
+                        (if (commandp def)
+                            "an interactive autoloaded "
+                          "an autoloaded ")
+                      (if (commandp def) "an interactive " "a "))))
 
     ;; Print what kind of function-like object FUNCTION is.
     (princ (cond ((or (stringp def) (vectorp def))
@@ -676,34 +679,42 @@ FILE is the file where FUNCTION was probably defined."
             (re-search-backward (substitute-command-keys "`\\([^`']+\\)'")
                                 nil t)
             (help-xref-button 1 'help-function-def function file-name))))
-      (princ ".")
-      (with-current-buffer (help-buffer)
-        (fill-region-as-paragraph (save-excursion (goto-char pt1) (forward-line 0) (point))
-                                  (point)))
-      (terpri)(terpri)
-
-      (let ((doc-raw (documentation function t))
-            (key-bindings-buffer (current-buffer)))
-
-        ;; If the function is autoloaded, and its docstring has
-        ;; key substitution constructs, load the library.
-        (and (autoloadp real-def) doc-raw
-             help-enable-auto-load
-             (string-match "\\([^\\]=\\|[^=]\\|\\`\\)\\\\[[{<]" doc-raw)
-             (autoload-do-load real-def))
-
-        (help-fns--key-bindings function)
-        (with-current-buffer standard-output
-          (let ((doc (help-fns--signature function doc-raw sig-key
-                                          real-function key-bindings-buffer)))
-            (run-hook-with-args 'help-fns-describe-function-functions function)
-            (insert "\n"
-                    (or doc "Not documented."))
-            ;; Avoid asking the user annoying questions if she decides
-            ;; to save the help buffer, when her locale's codeset
-            ;; isn't UTF-8.
-            (unless (memq text-quoting-style '(straight grave))
-              (set-buffer-file-coding-system 'utf-8))))))))
+      (princ "."))))
+
+;;;###autoload
+(defun describe-function-1 (function)
+  (let ((pt1 (with-current-buffer (help-buffer) (point))))
+    (help-fns-function-description-header function)
+    (with-current-buffer (help-buffer)
+      (fill-region-as-paragraph (save-excursion (goto-char pt1) (forward-line 0) (point))
+                                (point))))
+  (terpri)(terpri)
+
+  (pcase-let ((`(,real-function ,def ,_aliased ,real-def)
+               (help-fns--analyse-function function))
+              (doc-raw (documentation function t))
+              (key-bindings-buffer (current-buffer)))
+
+    ;; If the function is autoloaded, and its docstring has
+    ;; key substitution constructs, load the library.
+    (and (autoloadp real-def) doc-raw
+         help-enable-auto-load
+         (string-match "\\([^\\]=\\|[^=]\\|\\`\\)\\\\[[{<]" doc-raw)
+         (autoload-do-load real-def))
+
+    (help-fns--key-bindings function)
+    (with-current-buffer standard-output
+      (let ((doc (help-fns--signature
+                  function doc-raw
+                  (if (subrp def) (indirect-function real-def) real-def)
+                  real-function key-bindings-buffer)))
+        (run-hook-with-args 'help-fns-describe-function-functions function)
+        (insert "\n" (or doc "Not documented.")))
+      ;; Avoid asking the user annoying questions if she decides
+      ;; to save the help buffer, when her locale's codeset
+      ;; isn't UTF-8.
+      (unless (memq text-quoting-style '(straight grave))
+        (set-buffer-file-coding-system 'utf-8)))))
 
 ;; Add defaults to `help-fns-describe-function-functions'.
 (add-hook 'help-fns-describe-function-functions #'help-fns--obsolete)
diff --git a/lisp/help.el b/lisp/help.el
index 361ab2a01ee..0fb1c2dab77 100644
--- a/lisp/help.el
+++ b/lisp/help.el
@@ -593,6 +593,39 @@ If INSERT (the prefix arg) is non-nil, insert the message in the buffer."
             string
           (format "%s (translated from %s)" string otherstring))))))
 
+(defun help--analyze-key (key untranslated)
+  "Get information about KEY its corresponding UNTRANSLATED events.
+Returns a list of the form (BRIEF-DESC DEFN EVENT MOUSE-MSG)."
+  (if (numberp untranslated)
+      (setq untranslated (this-single-command-raw-keys)))
+  (let* ((event (aref key (if (and (symbolp (aref key 0))
+                                   (> (length key) 1)
+                                   (consp (aref key 1)))
+                              1
+                            0)))
+         (modifiers (event-modifiers event))
+         (mouse-msg (if (or (memq 'click modifiers) (memq 'down modifiers)
+                            (memq 'drag modifiers)) " at that spot" ""))
+         (defn (key-binding key t)))
+    ;; Handle the case where we faked an entry in "Select and Paste" menu.
+    (when (and (eq defn nil)
+               (stringp (aref key (1- (length key))))
+               (eq (key-binding (substring key 0 -1)) 'yank-menu))
+      (setq defn 'menu-bar-select-yank))
+    ;; Don't bother user with strings from (e.g.) the select-paste menu.
+    (when (stringp (aref key (1- (length key))))
+      (aset key (1- (length key)) "(any string)"))
+    (when (and untranslated
+               (stringp (aref untranslated (1- (length untranslated)))))
+      (aset untranslated (1- (length untranslated)) "(any string)"))
+    (list
+     ;; Now describe the key, perhaps as changed.
+     (let ((key-desc (help-key-description key untranslated)))
+       (if (or (null defn) (integerp defn) (equal defn 'undefined))
+           (format "%s%s is undefined" key-desc mouse-msg)
+         (format "%s%s runs the command %S" key-desc mouse-msg defn)))
+     defn event mouse-msg)))
+
 (defun describe-key-briefly (&optional key insert untranslated)
   "Print the name of the function KEY invokes.  KEY is a string.
 If INSERT (the prefix arg) is non-nil, insert the message in the buffer.
@@ -603,73 +636,12 @@ the last key hit are used.
 If KEY is a menu item or a tool-bar button that is disabled, this command
 temporarily enables it to allow getting help on disabled items and buttons."
   (interactive
-   (let ((enable-disabled-menus-and-buttons t)
-         (cursor-in-echo-area t)
-         saved-yank-menu)
-     (unwind-protect
-         (let (key)
-           ;; If yank-menu is empty, populate it temporarily, so that
-           ;; "Select and Paste" menu can generate a complete event.
-           (when (null (cdr yank-menu))
-             (setq saved-yank-menu (copy-sequence yank-menu))
-             (menu-bar-update-yank-menu "(any string)" nil))
-           (while
-               (progn
-                 (setq key (read-key-sequence "Describe the following key, mouse click, or menu item: "))
-                 (and (vectorp key)
-                      (consp (aref key 0))
-                      (symbolp (car (aref key 0)))
-                      (string-match "\\(mouse\\|down\\|click\\|drag\\)"
-                                    (symbol-name (car (aref key 0))))
-                      (not (sit-for (/ double-click-time 1000.0) t)))))
-           ;; 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
-           ;; event then is in the second element of the vector.
-           (and (vectorp key)
-                (let ((last-idx (1- (length key))))
-                  (and (eventp (aref key last-idx))
-                       (memq 'down (event-modifiers (aref key last-idx)))))
-                (read-event))
-           (list
-            key
-            (if current-prefix-arg (prefix-numeric-value current-prefix-arg))
-            1))
-       ;; Put yank-menu back as it was, if we changed it.
-       (when saved-yank-menu
-         (setq yank-menu (copy-sequence saved-yank-menu))
-         (fset 'yank-menu (cons 'keymap yank-menu))))))
-  (if (numberp untranslated)
-      (setq untranslated (this-single-command-raw-keys)))
-  (let* ((event (if (and (symbolp (aref key 0))
-                         (> (length key) 1)
-                         (consp (aref key 1)))
-                    (aref key 1)
-                  (aref key 0)))
-         (modifiers (event-modifiers event))
-         (standard-output (if insert (current-buffer) standard-output))
-         (mouse-msg (if (or (memq 'click modifiers) (memq 'down modifiers)
-                            (memq 'drag modifiers)) " at that spot" ""))
-         (defn (key-binding key t))
-         key-desc)
-    ;; Handle the case where we faked an entry in "Select and Paste" menu.
-    (if (and (eq defn nil)
-             (stringp (aref key (1- (length key))))
-             (eq (key-binding (substring key 0 -1)) 'yank-menu))
-        (setq defn 'menu-bar-select-yank))
-    ;; Don't bother user with strings from (e.g.) the select-paste menu.
-    (if (stringp (aref key (1- (length key))))
-        (aset key (1- (length key)) "(any string)"))
-    (if (and (> (length untranslated) 0)
-             (stringp (aref untranslated (1- (length untranslated)))))
-        (aset untranslated (1- (length untranslated)) "(any string)"))
-    ;; Now describe the key, perhaps as changed.
-    (setq key-desc (help-key-description key untranslated))
-    (if (or (null defn) (integerp defn) (equal defn 'undefined))
-        (princ (format "%s%s is undefined" key-desc mouse-msg))
-      (princ (format "%s%s runs the command %S" key-desc mouse-msg defn)))))
+   ;; Ignore mouse movement events because it's too easy to miss the
+   ;; message while moving the mouse.
+   (pcase-let ((`(,key ,_up-event) (help-read-key-sequence 'no-mouse-movement)))
+     `(,key ,current-prefix-arg 1)))
+  (princ (car (help--analyze-key key untranslated))
+         (if insert (current-buffer) standard-output)))
 
 (defun help--key-binding-keymap (key &optional accept-default no-remap position)
   "Return a keymap holding a binding for KEY within current keymaps.
@@ -734,6 +706,59 @@ function `key-binding'."
                (throw 'found x))))
           nil)))))
 
+(defun help-read-key-sequence (&optional no-mouse-movement)
+  "Reads a key sequence from the user.
+Returns a list of the form (KEY UP-EVENT), where KEY is the key
+sequence, and UP-EVENT is the up-event that was discarded by
+reading KEY, or nil.
+If NO-MOUSE-MOVEMENT is non-nil, ignore key sequences starting
+with `mouse-movement' events."
+  (let ((enable-disabled-menus-and-buttons t)
+        (cursor-in-echo-area t)
+        saved-yank-menu)
+    (unwind-protect
+        (let (key)
+          ;; If yank-menu is empty, populate it temporarily, so that
+          ;; "Select and Paste" menu can generate a complete event.
+          (when (null (cdr yank-menu))
+            (setq saved-yank-menu (copy-sequence yank-menu))
+            (menu-bar-update-yank-menu "(any string)" nil))
+          (while
+              (pcase (setq key (read-key-sequence "\
+Describe the following key, mouse click, or menu item: "))
+                ((and (pred vectorp) (let `(,key0 . ,_) (aref key 0))
+                      (guard (symbolp key0)) (let keyname (symbol-name key0)))
+                 (if no-mouse-movement
+                     (string-match "mouse-movement" keyname)
+                   (and (string-match "\\(mouse\\|down\\|click\\|drag\\)"
+                                      keyname)
+                        (not (sit-for (/ double-click-time 1000.0) t)))))))
+          (list
+           key
+           ;; If KEY is a down-event, read and include the
+           ;; corresponding up-event.  Note that there are also
+           ;; down-events on scroll bars and mode lines: the actual
+           ;; event then is in the second element of the vector.
+           (and (vectorp key)
+                (let ((last-idx (1- (length key))))
+                  (and (eventp (aref key last-idx))
+                       (memq 'down (event-modifiers (aref key last-idx)))))
+                (or (and (eventp (aref key 0))
+                         (memq 'down (event-modifiers (aref key 0)))
+                         ;; However, for the C-down-mouse-2 popup
+                         ;; menu, there is no subsequent up-event.  In
+                         ;; this case, the up-event is the next
+                         ;; element in the supplied vector.
+                         (= (length key) 1))
+                    (and (> (length key) 1)
+                         (eventp (aref key 1))
+                         (memq 'down (event-modifiers (aref key 1)))))
+                (read-event))))
+      ;; Put yank-menu back as it was, if we changed it.
+      (when saved-yank-menu
+        (setq yank-menu (copy-sequence saved-yank-menu))
+        (fset 'yank-menu (cons 'keymap yank-menu))))))
+
 (defun describe-key (&optional key untranslated up-event)
   "Display documentation of the function invoked by KEY.
 KEY can be any kind of a key sequence; it can include keyboard events,
@@ -748,83 +773,20 @@ UP-EVENT is the up-event that was discarded by reading KEY, or nil.
 If KEY is a menu item or a tool-bar button that is disabled, this command
 temporarily enables it to allow getting help on disabled items and buttons."
   (interactive
-   (let ((enable-disabled-menus-and-buttons t)
-         (cursor-in-echo-area t)
-         saved-yank-menu)
-     (unwind-protect
-         (let (key)
-           ;; If yank-menu is empty, populate it temporarily, so that
-           ;; "Select and Paste" menu can generate a complete event.
-           (when (null (cdr yank-menu))
-             (setq saved-yank-menu (copy-sequence yank-menu))
-             (menu-bar-update-yank-menu "(any string)" nil))
-           (while
-               (progn
-                 (setq key (read-key-sequence "Describe the following key, mouse click, or menu item: "))
-                 (and (vectorp key)
-                      (consp (aref key 0))
-                      (symbolp (car (aref key 0)))
-                      (string-match "\\(mouse\\|down\\|click\\|drag\\)"
-                                    (symbol-name (car (aref key 0))))
-                      (not (sit-for (/ double-click-time 1000.0) t)))))
-           (list
-            key
-            (prefix-numeric-value current-prefix-arg)
-            ;; If KEY is a down-event, read and include the
-            ;; corresponding up-event.  Note that there are also
-            ;; down-events on scroll bars and mode lines: the actual
-            ;; event then is in the second element of the vector.
-            (and (vectorp key)
-                 (let ((last-idx (1- (length key))))
-                   (and (eventp (aref key last-idx))
-                        (memq 'down (event-modifiers (aref key last-idx)))))
-                 (or (and (eventp (aref key 0))
-                          (memq 'down (event-modifiers (aref key 0)))
-                          ;; However, for the C-down-mouse-2 popup
-                          ;; menu, there is no subsequent up-event.  In
-                          ;; this case, the up-event is the next
-                          ;; element in the supplied vector.
-                          (= (length key) 1))
-                     (and (> (length key) 1)
-                          (eventp (aref key 1))
-                          (memq 'down (event-modifiers (aref key 1)))))
-                 (read-event))))
-       ;; Put yank-menu back as it was, if we changed it.
-       (when saved-yank-menu
-         (setq yank-menu (copy-sequence saved-yank-menu))
-         (fset 'yank-menu (cons 'keymap yank-menu))))))
-  (if (numberp untranslated)
-      (setq untranslated (this-single-command-raw-keys)))
-  (let* ((event (aref key (if (and (symbolp (aref key 0))
-                                   (> (length key) 1)
-                                   (consp (aref key 1)))
-                              1
-                            0)))
-         (modifiers (event-modifiers event))
-         (mouse-msg (if (or (memq 'click modifiers) (memq 'down modifiers)
-                            (memq 'drag modifiers)) " at that spot" ""))
-         (defn (key-binding key t))
-         key-locus key-locus-up key-locus-up-tricky
-         defn-up defn-up-tricky ev-type
-         mouse-1-remapped mouse-1-tricky)
-
-    ;; Handle the case where we faked an entry in "Select and Paste" menu.
-    (when (and (eq defn nil)
-               (stringp (aref key (1- (length key))))
-               (eq (key-binding (substring key 0 -1)) 'yank-menu))
-      (setq defn 'menu-bar-select-yank))
-    (if (or (null defn) (integerp defn) (equal defn 'undefined))
-        (message "%s%s is undefined"
-                 (help-key-description key untranslated) mouse-msg)
+   (pcase-let ((`(,key ,up-event) (help-read-key-sequence)))
+     `(,key ,(prefix-numeric-value current-prefix-arg) ,up-event)))
+  (pcase-let ((`(,brief-desc ,defn ,event ,mouse-msg)
+               (help--analyze-key key untranslated))
+              (defn-up nil) (defn-up-tricky nil)
+              (key-locus-up nil) (key-locus-up-tricky nil)
+              (mouse-1-remapped nil) (mouse-1-tricky nil)
+              (ev-type nil))
+    (if (or (null defn)
+            (integerp defn)
+            (equal defn 'undefined))
+        (message "%s" brief-desc)
       (help-setup-xref (list #'describe-function defn)
                        (called-interactively-p 'interactive))
-      ;; Don't bother user with strings from (e.g.) the select-paste menu.
-      (when (stringp (aref key (1- (length key))))
-        (aset key (1- (length key)) "(any string)"))
-      (when (and untranslated
-                 (stringp (aref untranslated (1- (length untranslated)))))
-        (aset untranslated (1- (length untranslated))
-              "(any string)"))
       ;; Need to do this before erasing *Help* buffer in case event
       ;; is a mouse click in an existing *Help* buffer.
       (when up-event
@@ -849,13 +811,12 @@ temporarily enables it to allow getting help on disabled items and buttons."
             (aset sequence 0 'mouse-1)
             (setq defn-up-tricky (key-binding sequence nil nil (event-start up-event)))
             (setq key-locus-up-tricky (help--binding-locus sequence (event-start up-event))))))
-      (setq key-locus (help--binding-locus key (event-start event)))
       (with-help-window (help-buffer)
-        (princ (help-key-description key untranslated))
-        (princ (format "%s runs the command %S%s, which is "
-                       mouse-msg defn (if key-locus
-                                          (format " (found in %s)" key-locus)
-                                        "")))
+        (princ brief-desc)
+        (let ((key-locus (help--binding-locus key (event-start event))))
+          (when key-locus
+            (princ (format " (found in %s)" key-locus))))
+        (princ ", which is ")
         (describe-function-1 defn)
         (when up-event
           (unless (or (null defn-up)
diff --git a/lisp/ldefs-boot.el b/lisp/ldefs-boot.el
index ae28ba93e61..dababdb4fa6 100644
--- a/lisp/ldefs-boot.el
+++ b/lisp/ldefs-boot.el
@@ -4952,7 +4952,7 @@ call other entry points instead, such as `cl-prin1'.
 
 \(fn OBJECT)" nil nil)
 
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "cl-print" '("cl-print-")))
+(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "cl-print" '("cl-print-" "help-byte-code")))
 
 ;;;***
 
@@ -16544,18 +16544,6 @@ The optional LABEL is used to label the buffer created.
 
 ;;;***
 
-;;;### (autoloads nil "html2text" "net/html2text.el" (0 0 0 0))
-;;; Generated autoloads from net/html2text.el
-
-(autoload 'html2text "html2text" "\
-Convert HTML to plain text in the current buffer.
-
-\(fn)" t nil)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "html2text" '("html2text-")))
-
-;;;***
-
 ;;;### (autoloads nil "htmlfontify" "htmlfontify.el" (0 0 0 0))
 ;;; Generated autoloads from htmlfontify.el
 (push (purecopy '(htmlfontify 0 21)) package--builtin-versions)
@@ -30399,7 +30387,7 @@ then `snmpv2-mode-hook'.
 
 ;;;### (autoloads nil "soap-client" "net/soap-client.el" (0 0 0 0))
 ;;; Generated autoloads from net/soap-client.el
-(push (purecopy '(soap-client 3 1 2)) package--builtin-versions)
+(push (purecopy '(soap-client 3 1 3)) package--builtin-versions)
 
 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "soap-client" '("soap-")))
 
@@ -34165,7 +34153,7 @@ Reenable Ange-FTP, when Tramp is unloaded.
 
 ;;;### (autoloads nil "trampver" "net/trampver.el" (0 0 0 0))
 ;;; Generated autoloads from net/trampver.el
-(push (purecopy '(tramp 2 3 2 -1)) package--builtin-versions)
+(push (purecopy '(tramp 2 3 2)) package--builtin-versions)
 
 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "trampver" '("tramp-")))
 
diff --git a/lisp/minibuffer.el b/lisp/minibuffer.el
index c3480cd6c64..e5b1029c01f 100644
--- a/lisp/minibuffer.el
+++ b/lisp/minibuffer.el
@@ -746,7 +746,7 @@ If the current buffer is not a minibuffer, erase its entire contents."
 
 (defcustom completion-auto-help t
   "Non-nil means automatically provide help for invalid completion input.
-If the value is t the *Completion* buffer is displayed whenever completion
+If the value is t the *Completions* buffer is displayed whenever completion
 is requested but cannot be done.
 If the value is `lazy', the *Completions* buffer is only displayed after
 the second failed attempt to complete."
diff --git a/lisp/mouse.el b/lisp/mouse.el
index 9b6b169e568..e0794435d7a 100644
--- a/lisp/mouse.el
+++ b/lisp/mouse.el
@@ -380,7 +380,7 @@ This command must be bound to a mouse click."
 
 (defun mouse-drag-line (start-event line)
   "Drag a mode line, header line, or vertical line with the mouse.
-START-EVENT is the starting mouse-event of the drag action.  LINE
+START-EVENT is the starting mouse event of the drag action.  LINE
 must be one of the symbols `header', `mode', or `vertical'."
   ;; Give temporary modes such as isearch a chance to turn off.
   (run-hooks 'mouse-leave-buffer-hook)
@@ -405,29 +405,15 @@ must be one of the symbols `header', `mode', or `vertical'."
     ;; window's edge we drag.
     (cond
      ((eq line 'header)
-      (if (window-at-side-p window 'top)
-          ;; We can't drag the header line of a topmost window.
-          (setq draggable nil)
-        ;; Drag bottom edge of window above the header line.
-        (setq window (window-in-direction 'above window t))))
-     ((eq line 'mode)
-      (if (and (window-at-side-p window 'bottom)
-               ;; Allow resizing the minibuffer window if it's on the
-               ;; same frame as and immediately below `window', and it's
-               ;; either active or `resize-mini-windows' is nil.
-               (let ((minibuffer-window (minibuffer-window frame)))
-                 (not (and (eq (window-frame minibuffer-window) frame)
-                           (or (not resize-mini-windows)
-                               (eq minibuffer-window
-                                   (active-minibuffer-window)))))))
-          (setq draggable nil)))
+      ;; Drag bottom edge of window above the header line.
+      (setq window (window-in-direction 'above window t)))
+     ((eq line 'mode))
      ((eq line 'vertical)
       (let ((divider-width (frame-right-divider-width frame)))
         (when (and (or (not (numberp divider-width))
                        (zerop divider-width))
                    (eq (frame-parameter frame 'vertical-scroll-bars) 'left))
           (setq window (window-in-direction 'left window t))))))
-
     (let* ((exitfun nil)
            (move
             (lambda (event) (interactive "e")
@@ -530,20 +516,405 @@ must be one of the symbols `header', `mode', or `vertical'."
              t (lambda () (setq track-mouse old-track-mouse)))))))
 
 (defun mouse-drag-mode-line (start-event)
-  "Change the height of a window by dragging on the mode line."
+  "Change the height of a window by dragging on its mode line.
+START-EVENT is the starting mouse event of the drag action.
+
+If the drag happens in a mode line on the bottom of a frame and
+that frame's `drag-with-mode-line' parameter is non-nil, drag the
+frame instead."
   (interactive "e")
-  (mouse-drag-line start-event 'mode))
+  (let* ((start (event-start start-event))
+         (window (posn-window start))
+         (frame (window-frame window)))
+    (cond
+     ((not (window-live-p window)))
+     ((or (not (window-at-side-p window 'bottom))
+          ;; Allow resizing the minibuffer window if it's on the
+          ;; same frame as and immediately below `window', and it's
+          ;; either active or `resize-mini-windows' is nil.
+          (let ((minibuffer-window (minibuffer-window frame)))
+            (and (eq (window-frame minibuffer-window) frame)
+                 (or (not resize-mini-windows)
+                     (eq minibuffer-window
+                         (active-minibuffer-window))))))
+      (mouse-drag-line start-event 'mode))
+     ((and (frame-parameter frame 'drag-with-mode-line)
+           (window-at-side-p window 'bottom)
+           (let ((minibuffer-window (minibuffer-window frame)))
+             (not (eq (window-frame minibuffer-window) frame))))
+      ;; Drag frame when the window is on the bottom of its frame and
+      ;; there is no minibuffer window below.
+      (mouse-drag-frame start-event 'move)))))
 
 (defun mouse-drag-header-line (start-event)
-  "Change the height of a window by dragging on the header line."
+  "Change the height of a window by dragging on its header line.
+START-EVENT is the starting mouse event of the drag action.
+
+If the drag happens in a header line on the top of a frame and
+that frame's `drag-with-header-line' parameter is non-nil, drag
+the frame instead."
   (interactive "e")
-  (mouse-drag-line start-event 'header))
+  (let* ((start (event-start start-event))
+         (window (posn-window start)))
+    (if (and (window-live-p window)
+             (not (window-at-side-p window 'top)))
+        (mouse-drag-line start-event 'header)
+      (let ((frame (window-frame window)))
+        (when (frame-parameter frame 'drag-with-header-line)
+          (mouse-drag-frame start-event 'move))))))
 
 (defun mouse-drag-vertical-line (start-event)
-  "Change the width of a window by dragging on the vertical line."
+  "Change the width of a window by dragging on a vertical line.
+START-EVENT is the starting mouse event of the drag action."
   (interactive "e")
   (mouse-drag-line start-event 'vertical))
 
+(defun mouse-resize-frame (frame x-diff y-diff &optional x-move y-move)
+  "Helper function for `mouse-drag-frame'."
+  (let* ((frame-x-y (frame-position frame))
+         (frame-x (car frame-x-y))
+         (frame-y (cdr frame-x-y))
+         alist)
+    (if (> x-diff 0)
+        (when x-move
+          (setq x-diff (min x-diff frame-x))
+          (setq x-move (- frame-x x-diff)))
+      (let* ((min-width (frame-windows-min-size frame t nil t))
+             (min-diff (max 0 (- (frame-inner-width frame) min-width))))
+        (setq x-diff (max x-diff (- min-diff)))
+        (when x-move
+          (setq x-move (+ frame-x (- x-diff))))))
+
+    (if (> y-diff 0)
+        (when y-move
+          (setq y-diff (min y-diff frame-y))
+          (setq y-move (- frame-y y-diff)))
+      (let* ((min-height (frame-windows-min-size frame nil nil t))
+             (min-diff (max 0 (- (frame-inner-height frame) min-height))))
+        (setq y-diff (max y-diff (- min-diff)))
+        (when y-move
+          (setq y-move (+ frame-y (- y-diff))))))
+
+    (unless (zerop x-diff)
+      (when x-move
+        (push `(left . ,x-move) alist))
+      (push `(width . (text-pixels . ,(+ (frame-text-width frame) x-diff)))
+            alist))
+    (unless (zerop y-diff)
+      (when y-move
+        (push `(top . ,y-move) alist))
+      (push `(height . (text-pixels . ,(+ (frame-text-height frame) y-diff)))
+            alist))
+    (when alist
+      (modify-frame-parameters frame alist))))
+
+(defun mouse-drag-frame (start-event part)
+  "Drag a frame or one of its edges with the mouse.
+START-EVENT is the starting mouse event of the drag action.  Its
+position window denotes the frame that will be dragged.
+
+PART specifies the part that has been dragged and must be one of
+the symbols 'left', 'top', 'right', 'bottom', 'top-left',
+'top-right', 'bottom-left', 'bottom-right' to drag an internal
+border or edge.  If PART equals 'move', this means to move the
+frame with the mouse."
+  ;; Give temporary modes such as isearch a chance to turn off.
+  (run-hooks 'mouse-leave-buffer-hook)
+  (let* ((echo-keystrokes 0)
+         (start (event-start start-event))
+         (window (posn-window start))
+         ;; FRAME is the frame to drag.
+         (frame (if (window-live-p window)
+                    (window-frame window)
+                  window))
+         (width (frame-native-width frame))
+         (height (frame-native-height frame))
+         ;; PARENT is the parent frame of FRAME or, if FRAME is a
+         ;; top-level frame, FRAME's workarea.
+         (parent (frame-parent frame))
+         (parent-edges
+          (if parent
+              `(0 0 ,(frame-native-width parent) ,(frame-native-height parent))
+            (let* ((attributes
+                    (car (display-monitor-attributes-list)))
+                   (workarea (assq 'workarea attributes)))
+              (and workarea
+                   `(,(nth 1 workarea) ,(nth 2 workarea)
+                     ,(+ (nth 1 workarea) (nth 3 workarea))
+                     ,(+ (nth 2 workarea) (nth 4 workarea)))))))
+         (parent-left (and parent-edges (nth 0 parent-edges)))
+         (parent-top (and parent-edges (nth 1 parent-edges)))
+         (parent-right (and parent-edges (nth 2 parent-edges)))
+         (parent-bottom (and parent-edges (nth 3 parent-edges)))
+         ;; `pos-x' and `pos-y' record the x- and y-coordinates of the
+         ;; last sampled mouse position.  Note that we sample absolute
+         ;; mouse positions to avoid that moving the mouse from one
+         ;; frame into another gets into our way.  `last-x' and `last-y'
+         ;; records the x- and y-coordinates of the previously sampled
+         ;; position.  The differences between `last-x' and `pos-x' as
+         ;; well as `last-y' and `pos-y' determine the amount the mouse
+         ;; has been dragged between the last two samples.
+         pos-x-y pos-x pos-y
+         (last-x-y (mouse-absolute-pixel-position))
+         (last-x (car last-x-y))
+         (last-y (cdr last-x-y))
+         ;; `snap-x' and `snap-y' record the x- and y-coordinates of the
+         ;; mouse position when FRAME snapped.  As soon as the
+         ;; difference between `pos-x' and `snap-x' (or `pos-y' and
+         ;; `snap-y') exceeds the value of FRAME's `snap-width'
+         ;; parameter, unsnap FRAME (at the respective side).  `snap-x'
+         ;; and `snap-y' nil mean FRAME is curerntly not snapped.
+         snap-x snap-y
+         (exitfun nil)
+         (move
+          (lambda (event)
+            (interactive "e")
+            (when (consp event)
+              (setq pos-x-y (mouse-absolute-pixel-position))
+              (setq pos-x (car pos-x-y))
+              (setq pos-y (cdr pos-x-y))
+              (cond
+               ((eq part 'left)
+                (mouse-resize-frame frame (- last-x pos-x) 0 t))
+               ((eq part 'top)
+                (mouse-resize-frame frame 0 (- last-y pos-y) nil t))
+               ((eq part 'right)
+                (mouse-resize-frame frame (- pos-x last-x) 0))
+               ((eq part 'bottom)
+                (mouse-resize-frame frame 0 (- pos-y last-y)))
+               ((eq part 'top-left)
+                (mouse-resize-frame
+                 frame (- last-x pos-x) (- last-y pos-y) t t))
+               ((eq part 'top-right)
+                (mouse-resize-frame
+                 frame (- pos-x last-x) (- last-y pos-y) nil t))
+               ((eq part 'bottom-left)
+                (mouse-resize-frame
+                 frame (- last-x pos-x) (- pos-y last-y) t))
+               ((eq part 'bottom-right)
+                (mouse-resize-frame
+                 frame (- pos-x last-x) (- pos-y last-y)))
+               ((eq part 'move)
+                (let* ((old-position (frame-position frame))
+                       (old-left (car old-position))
+                       (old-top (cdr old-position))
+                       (left (+ old-left (- pos-x last-x)))
+                       (top (+ old-top (- pos-y last-y)))
+                       right bottom
+                       ;; `snap-width' (maybe also a yet to be provided
+                       ;; `snap-height') could become floats to handle
+                       ;; proportionality wrt PARENT.  We don't do any
+                       ;; checks on this parameter so far.
+                       (snap-width (frame-parameter frame 'snap-width)))
+                  ;; Docking and constraining.
+                  (when (and (numberp snap-width) parent-edges)
+                    (cond
+                     ;; Docking at the left parent edge.
+                     ((< pos-x last-x)
+                      (cond
+                       ((and (> left parent-left)
+                             (<= (- left parent-left) snap-width))
+                        ;; Snap when the mouse moved leftward and
+                        ;; FRAME's left edge would end up within
+                        ;; `snap-width' pixels from PARENT's left edge.
+                        (setq snap-x pos-x)
+                        (setq left parent-left))
+                       ((and (<= left parent-left)
+                             (<= (- parent-left left) snap-width)
+                             snap-x (<= (- snap-x pos-x) snap-width))
+                        ;; Stay snapped when the mouse moved leftward
+                        ;; but not more than `snap-width' pixels from
+                        ;; the time FRAME snapped.
+                        (setq left parent-left))
+                       (t
+                        ;; Unsnap when the mouse moved more than
+                        ;; `snap-width' pixels leftward from the time
+                        ;; FRAME snapped.
+                        (setq snap-x nil))))
+                     ((> pos-x last-x)
+                      (setq right (+ left width))
+                      (cond
+                       ((and (< right parent-right)
+                             (<= (- parent-right right) snap-width))
+                        ;; Snap when the mouse moved rightward and
+                        ;; FRAME's right edge would end up within
+                        ;; `snap-width' pixels from PARENT's right edge.
+                        (setq snap-x pos-x)
+                        (setq left (- parent-right width)))
+                       ((and (>= right parent-right)
+                             (<= (- right parent-right) snap-width)
+                             snap-x (<= (- pos-x snap-x) snap-width))
+                        ;; Stay snapped when the mouse moved rightward
+                        ;; but not more more than `snap-width' pixels
+                        ;; from the time FRAME snapped.
+                        (setq left (- parent-right width)))
+                       (t
+                        ;; Unsnap when the mouse moved rightward more
+                        ;; than `snap-width' pixels from the time FRAME
+                        ;; snapped.
+                        (setq snap-x nil)))))
+
+                    (cond
+                     ((< pos-y last-y)
+                      (cond
+                       ((and (> top parent-top)
+                             (<= (- top parent-top) snap-width))
+                        ;; Snap when the mouse moved upward and FRAME's
+                        ;; top edge would end up within `snap-width'
+                        ;; pixels from PARENT's top edge.
+                        (setq snap-y pos-y)
+                        (setq top parent-top))
+                       ((and (<= top parent-top)
+                             (<= (- parent-top top) snap-width)
+                             snap-y (<= (- snap-y pos-y) snap-width))
+                        ;; Stay snapped when the mouse moved upward but
+                        ;; not more more than `snap-width' pixels from
+                        ;; the time FRAME snapped.
+                        (setq top parent-top))
+                       (t
+                        ;; Unsnap when the mouse moved upward more than
+                        ;; `snap-width' pixels from the time FRAME
+                        ;; snapped.
+                        (setq snap-y nil))))
+                     ((> pos-y last-y)
+                      (setq bottom (+ top height))
+                      (cond
+                       ((and (< bottom parent-bottom)
+                             (<= (- parent-bottom bottom) snap-width))
+                        ;; Snap when the mouse moved downward and
+                        ;; FRAME's bottom edge would end up within
+                        ;; `snap-width' pixels from PARENT's bottom
+                        ;; edge.
+                        (setq snap-y pos-y)
+                        (setq top (- parent-bottom height)))
+                       ((and (>= bottom parent-bottom)
+                             (<= (- bottom parent-bottom) snap-width)
+                             snap-y (<= (- pos-y snap-y) snap-width))
+                        ;; Stay snapped when the mouse moved downward
+                        ;; but not more more than `snap-width' pixels
+                        ;; from the time FRAME snapped.
+                        (setq top (- parent-bottom height)))
+                       (t
+                        ;; Unsnap when the mouse moved downward more
+                        ;; than `snap-width' pixels from the time FRAME
+                        ;; snapped.
+                        (setq snap-y nil))))))
+
+                  ;; If requested, constrain FRAME's draggable areas to
+                  ;; PARENT's edges.  The `top-visible' parameter should
+                  ;; be set when FRAME has a draggable header-line.  If
+                  ;; set to a number, it ascertains that the top of
+                  ;; FRAME is always constrained to the top of PARENT
+                  ;; and that at least as many pixels of FRAME as
+                  ;; specified by that number are visible on each of the
+                  ;; three remaining sides of PARENT.
+                  ;;
+                  ;; The `bottom-visible' parameter should be set when
+                  ;; FRAME has a draggable mode-line.  If set to a
+                  ;; number, it ascertains that the bottom of FRAME is
+                  ;; always constrained to the bottom of PARENT and that
+                  ;; at least as many pixels of FRAME as specified by
+                  ;; that number are visible on each of the three
+                  ;; remaining sides of PARENT.
+                  (let ((par (frame-parameter frame 'top-visible))
+                        bottom-visible)
+                    (unless par
+                      (setq par (frame-parameter frame 'bottom-visible))
+                      (setq bottom-visible t))
+                    (when (and (numberp par) parent-edges)
+                      (setq left
+                            (max (min (- parent-right par) left)
+                                 (+ (- parent-left width) par)))
+                      (setq top
+                            (if bottom-visible
+                                (min (max top (- parent-top (- height par)))
+                                     (- parent-bottom height))
+                              (min (max top parent-top)
+                                   (- parent-bottom par))))))
+
+                  ;; Use `modify-frame-parameters' since `left' and
+                  ;; `top' may want to move FRAME out of its PARENT.
+                  (modify-frame-parameters
+                   frame
+                   `((left . (+ ,left)) (top . (+ ,top)))))))
+              (setq last-x pos-x)
+              (setq last-y pos-y))))
+         (old-track-mouse track-mouse))
+    ;; Start tracking.  The special value 'dragging' signals the
+    ;; display engine to freeze the mouse pointer shape for as long
+    ;; as we drag.
+    (setq track-mouse 'dragging)
+    ;; Loop reading events and sampling the position of the mouse.
+    (setq exitfun
+          (set-transient-map
+           (let ((map (make-sparse-keymap)))
+             (define-key map [switch-frame] #'ignore)
+             (define-key map [select-window] #'ignore)
+             (define-key map [scroll-bar-movement] #'ignore)
+             (define-key map [mouse-movement] move)
+             ;; Swallow drag-mouse-1 events to avoid selecting some other window.
+             (define-key map [drag-mouse-1]
+               (lambda () (interactive) (funcall exitfun)))
+             ;; Some of the events will of course end up looked up
+             ;; with a mode-line, header-line or vertical-line prefix ...
+             (define-key map [mode-line] map)
+             (define-key map [header-line] map)
+             (define-key map [vertical-line] map)
+             ;; ... and some maybe even with a right- or bottom-divider
+             ;; prefix.
+             (define-key map [right-divider] map)
+             (define-key map [bottom-divider] map)
+             map)
+           t (lambda () (setq track-mouse old-track-mouse))))))
+
+(defun mouse-drag-left-edge (start-event)
+  "Drag left edge of a frame with the mouse.
+START-EVENT is the starting mouse event of the drag action."
+  (interactive "e")
+  (mouse-drag-frame start-event 'left))
+
+(defun mouse-drag-top-left-corner (start-event)
+  "Drag top left corner of a frame with the mouse.
+START-EVENT is the starting mouse event of the drag action."
+  (interactive "e")
+  (mouse-drag-frame start-event 'top-left))
+
+(defun mouse-drag-top-edge (start-event)
+  "Drag top edge of a frame with the mouse.
+START-EVENT is the starting mouse event of the drag action."
+  (interactive "e")
+  (mouse-drag-frame start-event 'top))
+
+(defun mouse-drag-top-right-corner (start-event)
+  "Drag top right corner of a frame with the mouse.
+START-EVENT is the starting mouse event of the drag action."
+  (interactive "e")
+  (mouse-drag-frame start-event 'top-right))
+
+(defun mouse-drag-right-edge (start-event)
+  "Drag right edge of a frame with the mouse.
+START-EVENT is the starting mouse event of the drag action."
+  (interactive "e")
+  (mouse-drag-frame start-event 'right))
+
+(defun mouse-drag-bottom-right-corner (start-event)
+  "Drag bottom right corner of a frame with the mouse.
+START-EVENT is the starting mouse event of the drag action."
+  (interactive "e")
+  (mouse-drag-frame start-event 'bottom-right))
+
+(defun mouse-drag-bottom-edge (start-event)
+  "Drag bottom edge of a frame with the mouse.
+START-EVENT is the starting mouse event of the drag action."
+  (interactive "e")
+  (mouse-drag-frame start-event 'bottom))
+
+(defun mouse-drag-bottom-left-corner (start-event)
+  "Drag bottom left corner of a frame with the mouse.
+START-EVENT is the starting mouse event of the drag action."
+  (interactive "e")
+  (mouse-drag-frame start-event 'bottom-left))
+
 (defcustom mouse-select-region-move-to-beginning nil
   "Effect of selecting a region extending backward from double click.
 Nil means keep point at the position clicked (region end);
@@ -2078,6 +2449,22 @@ is copied instead of being cut."
 (global-set-key [bottom-divider down-mouse-1] 'mouse-drag-mode-line)
 (global-set-key [bottom-divider mouse-1] 'ignore)
 (global-set-key [bottom-divider C-mouse-2] 'mouse-split-window-horizontally)
+(global-set-key [left-edge down-mouse-1] 'mouse-drag-left-edge)
+(global-set-key [left-edge mouse-1] 'ignore)
+(global-set-key [top-left-corner down-mouse-1] 'mouse-drag-top-left-corner)
+(global-set-key [top-left-corner mouse-1] 'ignore)
+(global-set-key [top-edge down-mouse-1] 'mouse-drag-top-edge)
+(global-set-key [top-edge mouse-1] 'ignore)
+(global-set-key [top-right-corner down-mouse-1] 'mouse-drag-top-right-corner)
+(global-set-key [top-right-corner mouse-1] 'ignore)
+(global-set-key [right-edge down-mouse-1] 'mouse-drag-right-edge)
+(global-set-key [right-edge mouse-1] 'ignore)
+(global-set-key [bottom-right-corner down-mouse-1] 'mouse-drag-bottom-right-corner)
+(global-set-key [bottom-right-corner mouse-1] 'ignore)
+(global-set-key [bottom-edge down-mouse-1] 'mouse-drag-bottom-edge)
+(global-set-key [bottom-edge mouse-1] 'ignore)
+(global-set-key [bottom-left-corner down-mouse-1] 'mouse-drag-bottom-left-corner)
+(global-set-key [bottom-left-corner mouse-1] 'ignore)
 
 (provide 'mouse)
 
diff --git a/lisp/net/eww.el b/lisp/net/eww.el
index fe316579142..2fc36e180ee 100644
--- a/lisp/net/eww.el
+++ b/lisp/net/eww.el
@@ -312,11 +312,19 @@ word(s) will be searched for via `eww-search-prefix'."
                (expand-file-name file))))
 
 ;;;###autoload
-(defun eww-search-words (&optional beg end)
+(defun eww-search-words ()
   "Search the web for the text between BEG and END.
-See the `eww-search-prefix' variable for the search engine used."
-  (interactive "r")
-  (eww (buffer-substring beg end)))
+If region is active (and not whitespace), search the web for
+the text between BEG and END.  Else, prompt the user for a search
+string.  See the `eww-search-prefix' variable for the search
+engine used."
+  (interactive)
+  (if (use-region-p)
+      (let ((region-string (buffer-substring (region-beginning) (region-end))))
+        (if (not (string-match-p "\\`[ \n\t\r\v\f]*\\'" region-string))
+            (eww region-string)
+          (call-interactively 'eww)))
+    (call-interactively 'eww)))
 
 (defun eww-open-in-new-buffer ()
   "Fetch link at point in a new EWW buffer."
diff --git a/lisp/net/shr.el b/lisp/net/shr.el
index 2a6b3960c46..4d4e8a809e1 100644
--- a/lisp/net/shr.el
+++ b/lisp/net/shr.el
@@ -185,8 +185,8 @@ and other things:
     (define-key map [follow-link] 'mouse-face)
     (define-key map [mouse-2] 'shr-browse-url)
     (define-key map "I" 'shr-insert-image)
-    (define-key map "w" 'shr-copy-url)
-    (define-key map "u" 'shr-copy-url)
+    (define-key map "w" 'shr-maybe-probe-and-copy-url)
+    (define-key map "u" 'shr-maybe-probe-and-copy-url)
     (define-key map "v" 'shr-browse-url)
     (define-key map "O" 'shr-save-contents)
     (define-key map "\r" 'shr-browse-url)
@@ -290,43 +290,59 @@ DOM should be a parse tree as generated by
         (forward-line 1)
         (delete-region (point) (point-max))))))
 
-(defun shr-copy-url (&optional image-url)
+(defun shr-url-at-point (image-url)
+  "Return the URL under point as a string.
+If IMAGE-URL is non-nil, or there is no link under point, but
+there is an image under point then copy the URL of the image
+under point instead."
+  (if image-url
+      (get-text-property (point) 'image-url)
+    (or (get-text-property (point) 'shr-url)
+        (get-text-property (point) 'image-url))))
+
+(defun shr-copy-url (url)
   "Copy the URL under point to the kill ring.
 If IMAGE-URL (the prefix) is non-nil, or there is no link under
 point, but there is an image under point then copy the URL of the
-image under point instead.
-If called twice, then try to fetch the URL and see whether it
-redirects somewhere else."
+image under point instead."
+  (interactive (list (shr-url-at-point current-prefix-arg)))
+  (if (not url)
+      (message "No URL under point")
+    (setq url (url-encode-url url))
+    (kill-new url)
+    (message "Copied %s" url)))
+
+(defun shr-probe-url (url cont)
+  "Pass URL's redirect destination to CONT, if it has one.
+CONT should be a function of one argument, the redirect
+destination URL.  If URL is not redirected, then CONT is never
+called."
   (interactive "P")
-  (let ((url (if image-url
-                 (get-text-property (point) 'image-url)
-               (or (get-text-property (point) 'shr-url)
-                   (get-text-property (point) 'image-url)))))
-    (cond
-     ((not url)
-      (message "No URL under point"))
-     ;; Resolve redirected URLs.
-     ((equal url (car kill-ring))
-      (url-retrieve
-       url
-       (lambda (a)
-         (when (and (consp a)
-                    (eq (car a) :redirect))
-           (with-temp-buffer
-             (insert (cadr a))
-             (goto-char (point-min))
-             ;; Remove common tracking junk from the URL.
-             (when (re-search-forward ".utm_.*" nil t)
-               (replace-match "" t t))
-             (message "Copied %s" (buffer-string))
-             (copy-region-as-kill (point-min) (point-max)))))
-       nil t))
-     ;; Copy the URL to the kill ring.
-     (t
-      (with-temp-buffer
-        (insert (url-encode-url url))
-        (copy-region-as-kill (point-min) (point-max))
-        (message "Copied %s" (buffer-string)))))))
+  (url-retrieve
+   url (lambda (a)
+         (pcase a
+           (`(:redirect ,destination . ,_)
+            ;; Remove common tracking junk from the URL.
+            (funcall cont (replace-regexp-in-string
+                           ".utm_.*" "" destination)))))
+   nil t))
+
+(defun shr-probe-and-copy-url (url)
+  "Copy the URL under point to the kill ring.
+Like `shr-copy-url', but additionally fetch URL and use its
+redirection destination if it has one."
+  (interactive (list (shr-url-at-point current-prefix-arg)))
+  (if url (shr-probe-url url #'shr-copy-url)
+    (shr-copy-url url)))
+
+(defun shr-maybe-probe-and-copy-url (url)
+  "Copy the URL under point to the kill ring.
+If the URL is already at the front of the kill ring act like
+`shr-probe-and-copy-url', otherwise like `shr-copy-url'."
+  (interactive (list (shr-url-at-point current-prefix-arg)))
+  (if (equal url (car kill-ring))
+      (shr-probe-and-copy-url url)
+    (shr-copy-url url)))
 
 (defun shr-next-link ()
   "Skip to the next link."
@@ -512,6 +528,7 @@ size, and full-buffer size."
                                        (* (frame-char-width) 2)
                                      0))))
         (shr-insert text)
+        (shr-fill-lines (point-min) (point-max))
         (buffer-string)))))
 
 (define-inline shr-char-breakable-p (char)
diff --git a/lisp/net/tramp-adb.el b/lisp/net/tramp-adb.el
index 23aa90186a6..346979000f5 100644
--- a/lisp/net/tramp-adb.el
+++ b/lisp/net/tramp-adb.el
@@ -72,7 +72,7 @@ It is used for TCP/IP devices."
 (defconst tramp-adb-ls-toolbox-regexp
   (concat
    "^[[:space:]]*\\([-[:alpha:]]+\\)"   ; \1 permissions
-   "\\(?:[[:space:]][[:digit:]]+\\)?"   ; links (Android 7/ToolBox)
+   "\\(?:[[:space:]]+[[:digit:]]+\\)?"  ; links (Android 7/toybox)
    "[[:space:]]*\\([^[:space:]]+\\)"    ; \2 username
    "[[:space:]]+\\([^[:space:]]+\\)"    ; \3 group
    "[[:space:]]+\\([[:digit:]]+\\)"     ; \4 size
@@ -411,15 +411,17 @@ pass to the OPERATION."
                             (tramp-adb-get-ls-command v)
                             (tramp-shell-quote-argument localname)))
              ;; We insert also filename/. and filename/.., because "ls" doesn't.
-             (narrow-to-region (point) (point))
-             (tramp-adb-send-command
-              v (format "%s -d -a -l %s %s"
-                        (tramp-adb-get-ls-command v)
-                        (tramp-shell-quote-argument
-                         (concat (file-name-as-directory localname) "."))
-                        (tramp-shell-quote-argument
-                         (concat (file-name-as-directory localname) ".."))))
-             (widen))
+             ;; Looks like it does include them in toybox, since Android 6.
+             (unless (re-search-backward "\\.$" nil t)
+               (narrow-to-region (point-max) (point-max))
+               (tramp-adb-send-command
+                v (format "%s -d -a -l %s %s"
+                          (tramp-adb-get-ls-command v)
+                          (tramp-shell-quote-argument
+                           (concat (file-name-as-directory localname) "."))
+                          (tramp-shell-quote-argument
+                           (concat (file-name-as-directory localname) ".."))))
+               (widen)))
            (tramp-adb-sh-fix-ls-output)
            (let ((result (tramp-do-parse-file-attributes-with-ls
                           v (or id-format 'integer))))
@@ -443,11 +445,12 @@ pass to the OPERATION."
   (with-tramp-connection-property vec "ls"
     (tramp-message vec 5 "Finding a suitable `ls' command")
     (cond
-     ;; Can't disable coloring explicitly for toybox ls command
-     ((tramp-adb-send-command-and-check vec "toybox") "ls")
+     ;; Can't disable coloring explicitly for toybox ls command.  We
+     ;; must force "ls" to print just one column.
+     ((tramp-adb-send-command-and-check vec "toybox") "env COLUMNS=1 ls")
      ;; On CyanogenMod based system BusyBox is used and "ls" output
-     ;; coloring is enabled by default.  So we try to disable it
-     ;; when possible.
+     ;; coloring is enabled by default.  So we try to disable it when
+     ;; possible.
      ((tramp-adb-send-command-and-check vec "ls --color=never -al /dev/null")
       "ls --color=never")
      (t "ls"))))
@@ -569,13 +572,17 @@ Emacs dired can't find files."
                 (file-name-as-directory f)
               f))
           (with-current-buffer (tramp-get-buffer v)
-            (append
-             '("." "..")
-             (delq
-              nil
-              (mapcar
-               (lambda (l) (and (not (string-match  "^[[:space:]]*$" l)) l))
-               (split-string (buffer-string) "\n")))))))))))
+            (delete-dups
+             (append
+              ;; In older Android versions, "." and ".." are not
+              ;; included.  In newer versions (toybox, since Android
+              ;; 6) they are.  We fix this by `delete-dups'.
+              '("." "..")
+              (delq
+               nil
+               (mapcar
+                (lambda (l) (and (not (string-match  "^[[:space:]]*$" l)) l))
+                (split-string (buffer-string) "\n"))))))))))))
 
 (defun tramp-adb-handle-file-local-copy (filename)
   "Like `file-local-copy' for Tramp files."
diff --git a/lisp/net/tramp-compat.el b/lisp/net/tramp-compat.el
index c998df814c1..b2df4d6324b 100644
--- a/lisp/net/tramp-compat.el
+++ b/lisp/net/tramp-compat.el
@@ -252,7 +252,8 @@ If NAME is a remote file name, the local part of NAME is unquoted."
 (eval-after-load 'tramp
   '(unless
        (memq tramp-syntax (tramp-compat-funcall (quote tramp-syntax-values)))
-     (tramp-change-syntax (tramp-compat-tramp-syntax))))
+     (tramp-compat-funcall
+      (quote tramp-change-syntax) (tramp-compat-tramp-syntax))))
 
 (provide 'tramp-compat)
 
diff --git a/lisp/net/tramp-sh.el b/lisp/net/tramp-sh.el
index f7b457ebf04..94518d0d359 100644
--- a/lisp/net/tramp-sh.el
+++ b/lisp/net/tramp-sh.el
@@ -3500,21 +3500,10 @@ the result will be a local, non-Tramp, file name."
 (defun tramp-sh-file-name-handler (operation &rest args)
   "Invoke remote-shell Tramp file name handler.
 Fall back to normal file name handler if no Tramp handler exists."
-  (when (and tramp-locked (not tramp-locker))
-    (setq tramp-locked nil)
-    (tramp-error
-     (car-safe tramp-current-connection) 'file-error
-     "Forbidden reentrant call of Tramp"))
-  (let ((tl tramp-locked))
-    (setq tramp-locked t)
-    (unwind-protect
-        (let ((tramp-locker t))
-          (save-match-data
-            (let ((fn (assoc operation tramp-sh-file-name-handler-alist)))
-              (if fn
-                  (apply (cdr fn) args)
-                (tramp-run-real-handler operation args)))))
-      (setq tramp-locked tl))))
+  (let ((fn (assoc operation tramp-sh-file-name-handler-alist)))
+    (if fn
+        (save-match-data (apply (cdr fn) args))
+      (tramp-run-real-handler operation args))))
 
 ;; This must be the last entry, because `identity' always matches.
 ;;;###tramp-autoload
diff --git a/lisp/net/tramp.el b/lisp/net/tramp.el
index 8d81ac64aa2..9c327c410a7 100644
--- a/lisp/net/tramp.el
+++ b/lisp/net/tramp.el
@@ -2053,6 +2053,33 @@ ARGS are the arguments OPERATION has been called with."
   `(let ((debug-on-error tramp-debug-on-error))
      (condition-case-unless-debug ,var ,bodyform ,@handlers)))
 
+;; In Emacs, there is some concurrency due to timers.  If a timer
+;; interrupts Tramp and wishes to use the same connection buffer as
+;; the "main" Emacs, then garbage might occur in the connection
+;; buffer.  Therefore, we need to make sure that a timer does not use
+;; the same connection buffer as the "main" Emacs.  We implement a
+;; cheap global lock, instead of locking each connection buffer
+;; separately.  The global lock is based on two variables,
+;; `tramp-locked' and `tramp-locker'.  `tramp-locked' is set to true
+;; (with setq) to indicate a lock.  But Tramp also calls itself during
+;; processing of a single file operation, so we need to allow
+;; recursive calls.  That's where the `tramp-locker' variable comes in
+;; -- it is let-bound to t during the execution of the current
+;; handler.  So if `tramp-locked' is t and `tramp-locker' is also t,
+;; then we should just proceed because we have been called
+;; recursively.  But if `tramp-locker' is nil, then we are a timer
+;; interrupting the "main" Emacs, and then we signal an error.
+
+(defvar tramp-locked nil
+  "If non-nil, then Tramp is currently busy.
+Together with `tramp-locker', this implements a locking mechanism
+preventing reentrant calls of Tramp.")
+
+(defvar tramp-locker nil
+  "If non-nil, then a caller has locked Tramp.
+Together with `tramp-locked', this implements a locking mechanism
+preventing reentrant calls of Tramp.")
+
 ;; Main function.
 (defun tramp-file-name-handler (operation &rest args)
   "Invoke Tramp file name handler.
@@ -2090,7 +2117,20 @@ Falls back to normal file name handler if no Tramp file name handler exists."
                       (setq result
                             (catch 'non-essential
                               (catch 'suppress
-                                (apply foreign operation args))))
+                                (when (and tramp-locked (not tramp-locker))
+                                  (setq tramp-locked nil)
+                                  (tramp-error
+                                   (car-safe tramp-current-connection)
+                                   'file-error
+                                   "Forbidden reentrant call of Tramp"))
+                                (let ((tl tramp-locked))
+                                  (setq tramp-locked t)
+                                  (unwind-protect
+                                      (let ((tramp-locker t))
+                                        (apply foreign operation args))
+                                    ;; Give timers a chance.
+                                    (unless (setq tramp-locked tl)
+                                      (sit-for 0.001 'nodisp)))))))
                       (cond
                        ((eq result 'non-essential)
                         (tramp-message
@@ -2145,33 +2185,6 @@ Falls back to normal file name handler if no Tramp file name handler exists."
       ;; we don't do anything.
       (tramp-run-real-handler operation args))))
 
-;; In Emacs, there is some concurrency due to timers.  If a timer
-;; interrupts Tramp and wishes to use the same connection buffer as
-;; the "main" Emacs, then garbage might occur in the connection
-;; buffer.  Therefore, we need to make sure that a timer does not use
-;; the same connection buffer as the "main" Emacs.  We implement a
-;; cheap global lock, instead of locking each connection buffer
-;; separately.  The global lock is based on two variables,
-;; `tramp-locked' and `tramp-locker'.  `tramp-locked' is set to true
-;; (with setq) to indicate a lock.  But Tramp also calls itself during
-;; processing of a single file operation, so we need to allow
-;; recursive calls.  That's where the `tramp-locker' variable comes in
-;; -- it is let-bound to t during the execution of the current
-;; handler.  So if `tramp-locked' is t and `tramp-locker' is also t,
-;; then we should just proceed because we have been called
-;; recursively.  But if `tramp-locker' is nil, then we are a timer
-;; interrupting the "main" Emacs, and then we signal an error.
-
-(defvar tramp-locked nil
-  "If non-nil, then Tramp is currently busy.
-Together with `tramp-locker', this implements a locking mechanism
-preventing reentrant calls of Tramp.")
-
-(defvar tramp-locker nil
-  "If non-nil, then a caller has locked Tramp.
-Together with `tramp-locked', this implements a locking mechanism
-preventing reentrant calls of Tramp.")
-
 ;;;###autoload
 (defun tramp-completion-file-name-handler (operation &rest args)
   "Invoke Tramp file name completion handler.
@@ -3631,31 +3644,17 @@ connection buffer."
   "Like `accept-process-output' for Tramp processes.
 This is needed in order to hide `last-coding-system-used', which is set
 for process communication also."
-  ;; FIXME: There are problems, when an asynchronous process runs in
-  ;; parallel, and also timers are active.  See
-  ;; <http://lists.gnu.org/archive/html/tramp-devel/2017-01/msg00010.html>.
-  (when (and timer-event-last
-             (string-prefix-p "*tramp/" (process-name proc))
-             (let (result)
-               (maphash
-                (lambda (key _value)
-                  (and (processp key)
-                       (not (string-prefix-p "*tramp/" (process-name key)))
-                       (process-live-p key)
-                       (setq result t)))
-                tramp-cache-data)
-               result))
-    (sit-for 0.01 'nodisp))
   (with-current-buffer (process-buffer proc)
     (let (buffer-read-only last-coding-system-used)
-      ;; Under Windows XP, accept-process-output doesn't return
+      ;; Under Windows XP, `accept-process-output' doesn't return
       ;; sometimes.  So we add an additional timeout.  JUST-THIS-ONE
-      ;; is set due to Bug#12145.
+      ;; is set due to Bug#12145.  It is an integer, in order to avoid
+      ;; running timers as well.
       (tramp-message
        proc 10 "%s %s %s\n%s"
        proc (process-status proc)
        (with-timeout (timeout)
-         (accept-process-output proc timeout nil t))
+         (accept-process-output proc timeout nil 0))
        (buffer-string)))))
 
 (defun tramp-check-for-regexp (proc regexp)
diff --git a/lisp/net/trampver.el b/lisp/net/trampver.el
index 387a3c8bb36..4be487e1f4f 100644
--- a/lisp/net/trampver.el
+++ b/lisp/net/trampver.el
@@ -7,7 +7,7 @@
 ;; Maintainer: Michael Albinus <michael.albinus@gmx.de>
 ;; Keywords: comm, processes
 ;; Package: tramp
-;; Version: 2.3.2-pre
+;; Version: 2.3.2
 
 ;; This file is part of GNU Emacs.
 
@@ -33,7 +33,7 @@
 ;; should be changed only there.
 
 ;;;###tramp-autoload
-(defconst tramp-version "2.3.2-pre"
+(defconst tramp-version "2.3.2"
   "This version of Tramp.")
 
 ;;;###tramp-autoload
@@ -55,7 +55,7 @@
 ;; Check for Emacs version.
 (let ((x (if (>= emacs-major-version 24)
     "ok"
-  (format "Tramp 2.3.2-pre is not fit for %s"
+  (format "Tramp 2.3.2 is not fit for %s"
           (when (string-match "^.*$" (emacs-version))
             (match-string 0 (emacs-version)))))))
   (unless (string-match "\\`ok\\'" x) (error "%s" x)))
diff --git a/lisp/net/html2text.el b/lisp/obsolete/html2text.el
index 87c71dc504a..27560a70c63 100644
--- a/lisp/net/html2text.el
+++ b/lisp/obsolete/html2text.el
@@ -3,6 +3,7 @@
 ;; Copyright (C) 2002-2017 Free Software Foundation, Inc.
 
 ;; Author: Joakim Hove <hove@phys.ntnu.no>
+;; Obsolete-since: 26.1
 
 ;; This file is part of GNU Emacs.
 
@@ -29,6 +30,8 @@
 ;;
 ;; The main function is `html2text'.
 
+;; This package was obsoleted by shr.el.
+
 ;;; Code:
 
 ;;
diff --git a/lisp/progmodes/cc-cmds.el b/lisp/progmodes/cc-cmds.el
index c05200b3898..de2543951b9 100644
--- a/lisp/progmodes/cc-cmds.el
+++ b/lisp/progmodes/cc-cmds.el
@@ -1915,7 +1915,7 @@ with a brace block."
     (save-restriction
       (let ((start (point))
             (paren-state (c-parse-state))
-            lim pos end-pos encl-decl-block where)
+            lim pos end-pos where)
         ;; Narrow enclosing brace blocks out, as required by the values of
         ;; `c-defun-tactic', `near', and the position of point.
         (when (eq c-defun-tactic 'go-outward)
diff --git a/lisp/progmodes/cc-defs.el b/lisp/progmodes/cc-defs.el
index dd8f8afc6a3..85a4085e490 100644
--- a/lisp/progmodes/cc-defs.el
+++ b/lisp/progmodes/cc-defs.el
@@ -44,19 +44,12 @@
     (load "cc-bytecomp" nil t)))
 
 (eval-and-compile
-  (defvar c--mapcan-status
-    (cond ((and (fboundp 'mapcan)
-                (subrp (symbol-function 'mapcan)))
-           ;; XEmacs
-           'mapcan)
-          ((locate-file "cl-lib.elc" load-path)
-           ;; Emacs >= 24.3
-           'cl-mapcan)
-          (t
-           ;; Emacs <= 24.2
-           nil))))
-
-(cc-external-require (if (eq c--mapcan-status 'cl-mapcan) 'cl-lib 'cl))
+  (defvar c--cl-library
+    (if (locate-library "cl-lib")
+        'cl-lib
+      'cl)))
+
+(cc-external-require c--cl-library)
 ; was (cc-external-require 'cl).  ACM 2005/11/29.
 ; Changed from (eval-when-compile (require 'cl)) back to
 ; cc-external-require, 2015-08-12.
@@ -182,9 +175,12 @@ This variant works around bugs in `eval-when-compile' in various
   ;; The motivation for this macro is to avoid the irritating message
   ;; "function `mapcan' from cl package called at runtime" produced by Emacs.
   (cond
-   ((eq c--mapcan-status 'mapcan)
+   ((and (fboundp 'mapcan)
+         (subrp (symbol-function 'mapcan)))
+    ;; XEmacs and Emacs >= 26.
     `(mapcan ,fun ,liszt))
-   ((eq c--mapcan-status 'cl-mapcan)
+   ((eq c--cl-library 'cl-lib)
+    ;; Emacs >= 24.3, < 26.
     `(cl-mapcan ,fun ,liszt))
    (t
     ;; Emacs <= 24.2.  It would be nice to be able to distinguish between
@@ -193,13 +189,13 @@ This variant works around bugs in `eval-when-compile' in various
 
 (defmacro c--set-difference (liszt1 liszt2 &rest other-args)
   ;; Macro to smooth out the renaming of `set-difference' in Emacs 24.3.
-  (if (eq c--mapcan-status 'cl-mapcan)
+  (if (eq c--cl-library 'cl-lib)
       `(cl-set-difference ,liszt1 ,liszt2 ,@other-args)
     `(set-difference ,liszt1 ,liszt2 ,@other-args)))
 
 (defmacro c--intersection (liszt1 liszt2 &rest other-args)
   ;; Macro to smooth out the renaming of `intersection' in Emacs 24.3.
-  (if (eq c--mapcan-status 'cl-mapcan)
+  (if (eq c--cl-library 'cl-lib)
       `(cl-intersection ,liszt1 ,liszt2 ,@other-args)
     `(intersection ,liszt1 ,liszt2 ,@other-args)))
 
@@ -212,7 +208,7 @@ This variant works around bugs in `eval-when-compile' in various
 
   (defmacro c--delete-duplicates (cl-seq &rest cl-keys)
     ;; Macro to smooth out the renaming of `delete-duplicates' in Emacs 24.3.
-    (if (eq c--mapcan-status 'cl-mapcan)
+    (if (eq c--cl-library 'cl-lib)
         `(cl-delete-duplicates ,cl-seq ,@cl-keys)
       `(delete-duplicates ,cl-seq ,@cl-keys))))
 
@@ -1175,6 +1171,63 @@ been put there by c-put-char-property.  POINT remains unchanged."
                       nil ,from ,to ,value nil -property-))
     ;; GNU Emacs
     `(c-clear-char-property-with-value-function ,from ,to ,property ,value)))
+
+(defun c-clear-char-property-with-value-on-char-function (from to property
+                                                               value char)
+  "Remove all text-properties PROPERTY with value VALUE on
+characters with value CHAR from the region [FROM, TO), as tested
+by `equal'.  These properties are assumed to be over individual
+characters, having been put there by c-put-char-property.  POINT
+remains unchanged."
+  (let ((place from)
+        )
+    (while                        ; loop round occurrences of (PROPERTY VALUE)
+        (progn
+          (while           ; loop round changes in PROPERTY till we find VALUE
+              (and
+               (< place to)
+               (not (equal (get-text-property place property) value)))
+            (setq place (c-next-single-property-change place property nil to)))
+          (< place to))
+      (if (eq (char-after place) char)
+          (remove-text-properties place (1+ place) (cons property nil)))
+      ;; Do we have to do anything with stickiness here?
+      (setq place (1+ place)))))
+
+(defmacro c-clear-char-property-with-value-on-char (from to property value char)
+  "Remove all text-properties PROPERTY with value VALUE on
+characters with value CHAR from the region [FROM, TO), as tested
+by `equal'.  These properties are assumed to be over individual
+characters, having been put there by c-put-char-property.  POINT
+remains unchanged."
+  (if c-use-extents
+      ;; XEmacs
+      `(let ((-property- ,property)
+             (-char- ,char))
+         (map-extents (lambda (ext val)
+                        (if (and (equal (extent-property ext -property-) val)
+                                 (eq (char-after
+                                      (extent-start-position ext))
+                                     -char-))
+                            (delete-extent ext)))
+                      nil ,from ,to ,value nil -property-))
+    ;; Gnu Emacs
+    `(c-clear-char-property-with-value-on-char-function ,from ,to ,property
+                                                        ,value ,char)))
+
+(defmacro c-put-char-properties-on-char (from to property value char)
+  ;; This needs to be a macro because `property' passed to
+  ;; `c-put-char-property' must be a constant.
+  "Put the text property PROPERTY with value VALUE on characters
+with value CHAR in the region [FROM to)."
+  `(let ((skip-string (concat "^" (list ,char)))
+         (-to- ,to))
+     (save-excursion
+       (goto-char ,from)
+       (while (progn (skip-chars-forward skip-string -to-)
+                     (< (point) -to-))
+           (c-put-char-property (point) ,property ,value)
+           (forward-char)))))
 
 ;; Macros to put overlays (Emacs) or extents (XEmacs) on buffer text.
 ;; For our purposes, these are characterized by being possible to
@@ -1232,6 +1285,8 @@ been put there by c-put-char-property.  POINT remains unchanged."
 (def-edebug-spec c-put-char-property t)
 (def-edebug-spec c-get-char-property t)
 (def-edebug-spec c-clear-char-property t)
+(def-edebug-spec c-clear-char-property-with-value-on-char t)
+(def-edebug-spec c-put-char-properties-on-char t)
 (def-edebug-spec c-clear-char-properties t)
 (def-edebug-spec c-put-overlay t)
 (def-edebug-spec c-delete-overlay t)
diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index aa84ade083c..955e1ebb08d 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -4809,7 +4809,6 @@ comment at the start of cc-engine.el for more info."
 
   (c-self-bind-state-cache
    (let ((start (point))
-         state-2
          ;; A list of syntactically relevant positions in descending
          ;; order.  It's used to avoid scanning repeatedly over
          ;; potentially large regions with `parse-partial-sexp' to verify
@@ -7809,8 +7808,7 @@ comment at the start of cc-engine.el for more info."
   ;; looking (in C++) like this "FQN::of::base::Class".  Move to the start of
   ;; this construct and return t.  If the parsing fails, return nil, leaving
   ;; point unchanged.
-  (let ((here (point))
-        end)
+  (let (end)
     (if (not (c-on-identifier))
         nil
       (c-simple-skip-symbol-backward)
diff --git a/lisp/progmodes/cc-fonts.el b/lisp/progmodes/cc-fonts.el
index 9bae7d9aa2f..66f2575f49f 100644
--- a/lisp/progmodes/cc-fonts.el
+++ b/lisp/progmodes/cc-fonts.el
@@ -702,6 +702,36 @@ stuff.  Used on level 1 and higher."
              t)
            (c-put-font-lock-face start (1+ start) 'font-lock-warning-face)))))
 
+(defun c-font-lock-invalid-single-quotes (limit)
+  ;; This function will be called from font-lock for a region bounded by POINT
+  ;; and LIMIT, as though it were to identify a keyword for
+  ;; font-lock-keyword-face.  It always returns NIL to inhibit this and
+  ;; prevent a repeat invocation.  See elisp/lispref page "Search-based
+  ;; Fontification".
+  ;;
+  ;; This function fontifies invalid single quotes with
+  ;; `font-lock-warning-face'.  These are the single quotes which
+  ;; o - aren't inside a literal;
+  ;; o - are marked with a syntax-table text property value '(1); and
+  ;; o - are NOT marked with a non-null c-digit-separator property.
+  (let ((limits (c-literal-limits))
+        state beg end)
+    (if limits
+        (goto-char (cdr limits)))       ; Even for being in a ' '
+    (while (< (point) limit)
+      (setq beg (point))
+      (setq state (parse-partial-sexp (point) limit nil nil nil 'syntax-table))
+      (setq end (point))
+      (goto-char beg)
+      (while (progn (skip-chars-forward "^'" end)
+                    (< (point) end))
+        (if (and (equal (c-get-char-property (point) 'syntax-table) '(1))
+                 (not (c-get-char-property (point) 'c-digit-separator)))
+            (c-put-font-lock-face (point) (1+ (point)) font-lock-warning-face))
+        (forward-char))
+      (parse-partial-sexp end limit nil nil state 'syntax-table)))
+    nil)
+
 (c-lang-defconst c-basic-matchers-before
   "Font lock matchers for basic keywords, labels, references and various
 other easily recognizable things that should be fontified before generic
@@ -723,6 +753,9 @@ casts and declarations are fontified.  Used on level 2 and higher."
         (concat ".\\(" c-string-limit-regexp "\\)")
         '((c-font-lock-invalid-string)))
 
+      ;; Invalid single quotes.
+      c-font-lock-invalid-single-quotes
+
       ;; Fontify C++ raw strings.
       ,@(when (c-major-mode-is 'c++-mode)
           '(c-font-lock-raw-strings))
@@ -777,7 +810,8 @@ casts and declarations are fontified.  Used on level 2 and higher."
                                     (c-backward-syntactic-ws)
                                     (setq id-end (point))
                                     (< (skip-chars-backward
-                                        ,(c-lang-const c-symbol-chars)) 0))
+                                        ,(c-lang-const c-symbol-chars))
+                                       0))
                                   (not (get-text-property (point) 'face)))
                         (c-put-font-lock-face (point) id-end
                                               c-reference-face-name)
@@ -1013,13 +1047,11 @@ casts and declarations are fontified.  Used on level 2 and higher."
 
   ;;(message "c-font-lock-declarators from %s to %s" (point) limit)
   (c-fontify-types-and-refs
-      ((pos (point)) next-pos id-start id-end
+      ((pos (point)) next-pos id-start
        decl-res
-       paren-depth
        id-face got-type got-init
        c-last-identifier-range
-       (separator-prop (if types 'c-decl-type-start 'c-decl-id-start))
-       brackets-after-id)
+       (separator-prop (if types 'c-decl-type-start 'c-decl-id-start)))
 
     ;; The following `while' fontifies a single declarator id each time round.
     ;; It loops only when LIST is non-nil.
@@ -1036,7 +1068,7 @@ casts and declarations are fontified.  Used on level 2 and higher."
                                    (forward-char)
                                    (c-forward-syntactic-ws)
                                    (looking-at "[*&]")))
-                             (not (car (cddr decl-res))) ; brackets-after-id
+                             (not (car (cddr decl-res)))
                              (or (not (c-major-mode-is 'c++-mode))
                                  (save-excursion
                                    (let (c-last-identifier-range)
@@ -1375,7 +1407,6 @@ casts and declarations are fontified.  Used on level 2 and higher."
           ;; it finds any.  That's necessary so that we later will
           ;; stop inside them to fontify types there.
           (c-parse-and-markup-<>-arglists t)
-          lbrace ; position of some {.
           ;; The font-lock package in Emacs is known to clobber
           ;; `parse-sexp-lookup-properties' (when it exists).
           (parse-sexp-lookup-properties
@@ -2503,7 +2534,7 @@ need for `c++-font-lock-extra-types'.")
      limit
      "[-+]"
      nil
-     (lambda (match-pos inside-macro &optional top-level)
+     (lambda (_match-pos _inside-macro &optional _top-level)
        (forward-char)
        (c-font-lock-objc-method))))
   nil)
diff --git a/lisp/progmodes/cc-langs.el b/lisp/progmodes/cc-langs.el
index a9d5ac34ad4..8be806094cd 100644
--- a/lisp/progmodes/cc-langs.el
+++ b/lisp/progmodes/cc-langs.el
@@ -130,7 +130,7 @@
 
 
 ;; This file is not always loaded.  See note above.
-(cc-external-require (if (eq c--mapcan-status 'cl-mapcan) 'cl-lib 'cl))
+(cc-external-require (if (eq c--cl-library 'cl-lib) 'cl-lib 'cl))
 
 
 ;;; Setup for the `c-lang-defvar' system.
@@ -474,18 +474,19 @@ so that all identifiers are recognized as words.")
   ;; The value here may be a list of functions or a single function.
   t nil
   c++ '(c-extend-region-for-CPP
-;       c-before-after-change-extend-region-for-lambda-capture ; doesn't seem needed.
         c-before-change-check-raw-strings
         c-before-change-check-<>-operators
         c-depropertize-CPP
-        c-before-after-change-digit-quote
         c-invalidate-macro-cache
-        c-truncate-bs-cache)
+        c-truncate-bs-cache
+        c-parse-quotes-before-change)
   (c objc) '(c-extend-region-for-CPP
              c-depropertize-CPP
              c-invalidate-macro-cache
-             c-truncate-bs-cache)
-  ;; java 'c-before-change-check-<>-operators
+             c-truncate-bs-cache
+             c-parse-quotes-before-change)
+  java 'c-parse-quotes-before-change
+       ;; 'c-before-change-check-<>-operators
   awk 'c-awk-record-region-clear-NL)
 (c-lang-defvar c-get-state-before-change-functions
                (let ((fs (c-lang-const c-get-state-before-change-functions)))
@@ -515,18 +516,19 @@ parameters \(point-min) and \(point-max).")
   t '(c-depropertize-new-text
       c-change-expand-fl-region)
   (c objc) '(c-depropertize-new-text
+             c-parse-quotes-after-change
              c-extend-font-lock-region-for-macros
              c-neutralize-syntax-in-and-mark-CPP
              c-change-expand-fl-region)
   c++ '(c-depropertize-new-text
+        c-parse-quotes-after-change
         c-extend-font-lock-region-for-macros
-;       c-before-after-change-extend-region-for-lambda-capture ; doesn't seem needed.
-        c-before-after-change-digit-quote
         c-after-change-re-mark-raw-strings
         c-neutralize-syntax-in-and-mark-CPP
         c-restore-<>-properties
         c-change-expand-fl-region)
   java '(c-depropertize-new-text
+         c-parse-quotes-after-change
          c-restore-<>-properties
          c-change-expand-fl-region)
   awk '(c-depropertize-new-text
@@ -609,6 +611,12 @@ EOL terminated statements."
   (c c++ objc) t)
 (c-lang-defvar c-has-bitfields (c-lang-const c-has-bitfields))
 
+(c-lang-defconst c-has-quoted-numbers
+  "Whether the language has numbers quoted like 4'294'967'295."
+  t nil
+  c++ t)
+(c-lang-defvar c-has-quoted-numbers (c-lang-const c-has-quoted-numbers))
+
 (c-lang-defconst c-modified-constant
   "Regexp that matches a “modified” constant literal such as \"L\\='a\\='\",
 a “long character”.  In particular, this recognizes forms of constant
diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el
index a501ebba256..ef93f75c5f3 100644
--- a/lisp/progmodes/cc-mode.el
+++ b/lisp/progmodes/cc-mode.el
@@ -1083,101 +1083,219 @@ Note that the style variables are always made local to the buffer."
             (forward-line))           ; no infinite loop with, e.g., "#//"
           )))))
 
-(defun c-before-after-change-digit-quote (beg end &optional old-len)
-  ;; This function either removes or applies the punctuation value ('(1)) of
-  ;; the `syntax-table' text property on single quote marks which are
-  ;; separator characters in long integer literals, e.g. "4'294'967'295".  It
-  ;; applies to both decimal/octal and hex literals.  (FIXME (2016-06-10): it
-  ;; should also apply to binary literals.)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Parsing of quotes.
+;;
+;; Valid digit separators in numbers will get the syntax-table "punctuation"
+;; property, '(1), and also the text property `c-digit-separator' value t.
+;;
+;; Invalid other quotes (i.e. those not validly bounding a single character,
+;; or escaped character) will get the syntax-table "punctuation" property,
+;; '(1), too.
+;;
+;; Note that, for convenience, these properties are applied even inside
+;; comments and strings.
+
+(defconst c-maybe-quoted-number-head
+  (concat
+   "\\(0\\("
+       "\\([Xx]\\([0-9a-fA-F]\\('[0-9a-fA-F]\\|[0-9a-fA-F]\\)*'?\\)?\\)"
+       "\\|"
+       "\\([Bb]\\([01]\\('[01]\\|[01]\\)*'?\\)?\\)"
+       "\\|"
+       "\\('[0-7]\\|[0-7]\\)*'?"
+       "\\)"
+   "\\|"
+       "[1-9]\\('[0-9]\\|[0-9]\\)*'?"
+   "\\)")
+  "Regexp matching the head of a numeric literal, including with digit separators.")
+
+(defun c-quoted-number-head-before-point ()
+  ;; Return non-nil when the head of a possibly quoted number is found
+  ;; immediately before point.  The value returned in this case is the buffer
+  ;; position of the start of the head.  That position is also in
+  ;; (match-beginning 0).
+  (when c-has-quoted-numbers
+    (save-excursion
+      (let ((here (point))
+            found)
+        (skip-chars-backward "0-9a-fA-F'")
+        (if (and (memq (char-before) '(?x ?X))
+                 (eq (char-before (1- (point))) ?0))
+            (backward-char 2))
+        (while
+            (and
+             (setq found
+                   (search-forward-regexp c-maybe-quoted-number-head here t))
+             (< found here)))
+        (and (eq found here) (match-beginning 0))))))
+
+(defconst c-maybe-quoted-number-tail
+  (concat
+   "\\("
+       "\\([xX']?[0-9a-fA-F]\\('[0-9a-fA-F]\\|[0-9a-fA-F]\\)*\\)"
+   "\\|"
+       "\\([bB']?[01]\\('[01]\\|[01]\\)*\\)"
+   "\\|"
+       "\\('?[0-9]\\('[0-9]\\|[0-9]\\)*\\)"
+   "\\)")
+  "Regexp matching the tail of a numeric literal, including with digit separators.
+Note that this is a strict tail, so won't match, e.g. \"0x....\".")
+
+(defun c-quoted-number-tail-after-point ()
+  ;; Return non-nil when a proper tail of a possibly quoted number is found
+  ;; immediately after point.  The value returned in this case is the buffer
+  ;; position of the end of the tail.  That position is also in (match-end 0).
+  (when c-has-quoted-numbers
+    (and (looking-at c-maybe-quoted-number-tail)
+         (match-end 0))))
+
+(defconst c-maybe-quoted-number
+  (concat
+   "\\(0\\("
+       "\\([Xx][0-9a-fA-F]\\('[0-9a-fA-F]\\|[0-9a-fA-F]\\)*\\)"
+       "\\|"
+       "\\([Bb][01]\\('[01]\\|[01]\\)*\\)"
+       "\\|"
+       "\\('[0-7]\\|[0-7]\\)*"
+       "\\)"
+   "\\|"
+       "[1-9]\\('[0-9]\\|[0-9]\\)*"
+   "\\)")
+  "Regexp matching a numeric literal, including with digit separators.")
+
+(defun c-quoted-number-straddling-point ()
+  ;; Return non-nil if a definitely quoted number starts before point and ends
+  ;; after point.  In this case the number is bounded by (match-beginning 0)
+  ;; and (match-end 0).
+  (when c-has-quoted-numbers
+    (save-excursion
+      (let ((here (point))
+            (bound (progn (skip-chars-forward "0-9a-fA-F'") (point))))
+        (goto-char here)
+        (when (< (skip-chars-backward "0-9a-fA-F'") 0)
+          (if (and (memq (char-before) '(?x ?X))
+                   (eq (char-before (1- (point))) ?0))
+              (backward-char 2))
+          (while (and (search-forward-regexp c-maybe-quoted-number bound t)
+                      (<= (match-end 0) here)))
+          (and (< (match-beginning 0) here)
+               (> (match-end 0) here)
+               (save-match-data
+                 (goto-char (match-beginning 0))
+                 (save-excursion (search-forward "'" (match-end 0) t)))))))))
+
+(defun c-parse-quotes-before-change (beg end)
+  ;; This function analyzes 's near the region (c-new-BEG c-new-END), amending
+  ;; those two variables as needed to include 's into that region when they
+  ;; might be syntactically relevant to the change in progress.
   ;;
-  ;; In both uses of the function, the `syntax-table' properties are
-  ;; removed/applied only on quote marks which appear to be digit separators.
+  ;; Having amended that region, the function removes pertinent text
+  ;; properties (syntax-table properties with value '(1) and c-digit-separator
+  ;; props with value t) from 's in it.  This operation is performed even
+  ;; within strings and comments.
   ;;
-  ;; Point is undefined on both entry and exit to this function, and the
-  ;; return value has no significance.  The function is called solely as a
-  ;; before-change function (see `c-get-state-before-change-functions') and as
-  ;; an after change function (see `c-before-font-lock-functions', with the
-  ;; parameters BEG, END, and (optionally) OLD-LEN being given the standard
-  ;; values for before/after-change functions.
-  (c-save-buffer-state ((num-begin c-new-BEG) digit-re try-end)
+  ;; This function is called exclusively as a before-change function via the
+  ;; variable `c-get-state-before-change-functions'.
+  (c-save-buffer-state (p-limit limits found)
+    ;; Special consideraton for deleting \ from '\''.
+    (if (and (> end beg)
+             (eq (char-before end) ?\\)
+             (<= c-new-END end))
+        (setq c-new-END (min (1+ end) (point-max))))
+
+    ;; Do we have a ' (or something like ',',',',',') within range of
+    ;; c-new-BEG?
+    (goto-char c-new-BEG)
+    (setq p-limit (max (- (point) 2) (point-min)))
+    (while (and (skip-chars-backward "^\\\\'" p-limit)
+                (> (point) p-limit))
+      (when (eq (char-before) ?\\)
+        (setq p-limit (max (1- p-limit) (point-min))))
+      (backward-char)
+      (setq c-new-BEG (point)))
+    (beginning-of-line)
+    (while (and
+            (setq found (search-forward-regexp "\\('\\([^'\\]\\|\\\\.\\)\\)*'"
+                                               c-new-BEG 'limit))
+            (< (point) (1- c-new-BEG))))
+    (if found
+        (setq c-new-BEG
+              (if (and (eq (point) (1- c-new-BEG))
+                       (eq (char-after) ?')) ; "''" before c-new-BEG.
+                  (1- c-new-BEG)
+                (match-beginning 0))))
+
+    ;; Check for a number with quote separators straddling c-new-BEG
+    (when c-has-quoted-numbers
+      (goto-char c-new-BEG)
+      (when ;; (c-quoted-number-straddling-point)
+          (c-quoted-number-head-before-point)
+        (setq c-new-BEG (match-beginning 0))))
+
+    ;; Do we have a ' (or something like ',',',',...,',') within range of
+    ;; c-new-END?
     (goto-char c-new-END)
-    (when (looking-at "\\(x\\)?[0-9a-fA-F']+")
-      (setq c-new-END (match-end 0)))
+    (setq p-limit (min (+ (point) 2) (point-max)))
+    (while (and (skip-chars-forward "^\\\\'" p-limit)
+                (< (point) p-limit))
+      (when (eq (char-after) ?\\)
+        (setq p-limit (min (1+ p-limit) (point-max))))
+      (forward-char)
+      (setq c-new-END (point)))
+    (if (looking-at "[^']?\\('\\([^'\\]\\|\\\\.\\)\\)*'")
+        (setq c-new-END (match-end 0)))
+
+    ;; Check for a number with quote separators straddling c-new-END.
+    (when c-has-quoted-numbers
+      (goto-char c-new-END)
+      (when ;; (c-quoted-number-straddling-point)
+          (c-quoted-number-tail-after-point)
+        (setq c-new-END (match-end 0))))
+
+    ;; Remove the '(1) syntax-table property from all "'"s within (c-new-BEG
+    ;; c-new-END).
+    (c-clear-char-property-with-value-on-char
+     c-new-BEG c-new-END
+     'syntax-table '(1)
+     ?')
+    ;; Remove the c-digit-separator text property from the same "'"s.
+    (when c-has-quoted-numbers
+      (c-clear-char-property-with-value-on-char
+       c-new-BEG c-new-END
+       'c-digit-separator t
+       ?'))))
+
+(defun c-parse-quotes-after-change (beg end old-len)
+  ;; This function applies syntax-table properties (value '(1)) and
+  ;; c-digit-separator properties as needed to 's within the range (c-new-BEG
+  ;; c-new-END).  This operation is performed even within strings and
+  ;; comments.
+  ;;
+  ;; This function is called exclusively as an after-change function via the
+  ;; variable `c-before-font-lock-functions'.
+  (c-save-buffer-state (p-limit limits num-beg num-end clear-from-BEG-to)
+    ;; Apply the needed syntax-table and c-digit-separator text properties to
+    ;; quotes.
     (goto-char c-new-BEG)
-    (when (looking-at "\\(x?\\)[0-9a-fA-F']")
-      (if (re-search-backward "\\(0x\\)?[0-9a-fA-F]*\\=" nil t)
-          (setq c-new-BEG (point))))
-
-    (while
-        (re-search-forward "[0-9a-fA-F]'[0-9a-fA-F]" c-new-END t)
-      (setq try-end (1- (point)))
-      (re-search-backward "[^0-9a-fA-F']" num-begin t)
-      (setq digit-re
-            (cond
-             ((and (not (bobp)) (eq (char-before) ?0) (memq (char-after) '(?x ?X)))
-              "[0-9a-fA-F]")
-             ((and (eq (char-after (1+ (point))) ?0)
-                   (memq (char-after (+ 2 (point))) '(?b ?B)))
-              "[01]")
-             ((memq (char-after (1+ (point))) '(?0 ?1 ?2 ?3 ?4 ?5 ?6 ?7 ?8 ?9))
-              "[0-9]")
-             (t nil)))
-      (when digit-re
-        (cond ((eq (char-after) ?x) (forward-char))
-              ((looking-at ".?0[Bb]") (goto-char (match-end 0)))
-              ((looking-at digit-re))
-              (t (forward-char)))
-        (when (not (c-in-literal))
-          (let ((num-end             ; End of valid sequence of digits/quotes.
-                 (save-excursion
-                   (re-search-forward
-                    (concat "\\=\\(" digit-re "+'\\)*" digit-re "+") nil t)
-                   (point))))
-            (setq try-end               ; End of sequence of digits/quotes
+    (while (and (< (point) c-new-END)
+                (search-forward "'" c-new-END 'limit))
+      (cond ((and (eq (char-before (1- (point))) ?\\)
+                  ;; Check we've got an odd number of \s, here.
                   (save-excursion
-                    (re-search-forward
-                     (concat "\\=\\(" digit-re "\\|'\\)+") nil t)
-                    (point)))
-            (while (re-search-forward
-                    (concat digit-re "\\('\\)" digit-re) num-end t)
-              (if old-len           ; i.e. are we in an after-change function?
-                  (c-put-char-property (match-beginning 1) 'syntax-table '(1))
-                (c-clear-char-property (match-beginning 1) 'syntax-table))
-              (backward-char)))))
-      (goto-char try-end)
-      (setq num-begin (point)))))
-
-;; The following doesn't seem needed at the moment (2016-08-15).
-;; (defun c-before-after-change-extend-region-for-lambda-capture
-;;     (_beg _end &optional _old-len)
-;;   ;; In C++ Mode, extend the region (c-new-BEG c-new-END) to cover any lambda
-;;   ;; function capture lists we happen to be inside.  This function is expected
-;;   ;; to be called both as a before-change and after change function.
-;;   ;;
-;;   ;; Note that these things _might_ be nested, with a capture list looking
-;;   ;; like:
-;;   ;;
-;;   ;;     [ ...., &foo = [..](){...}(..), ... ]
-;;   ;;
-;;   ;; .  What a wonderful language is C++.  ;-)
-;;   (c-save-buffer-state (paren-state pos)
-;;     (goto-char c-new-BEG)
-;;     (setq paren-state (c-parse-state))
-;;     (while (setq pos (c-pull-open-brace paren-state))
-;;       (goto-char pos)
-;;       (when (c-looking-at-c++-lambda-capture-list)
-;;      (setq c-new-BEG (min c-new-BEG pos))
-;;      (if (c-go-list-forward)
-;;          (setq c-new-END (max c-new-END (point))))))
-
-;;     (goto-char c-new-END)
-;;     (setq paren-state (c-parse-state))
-;;     (while (setq pos (c-pull-open-brace paren-state))
-;;       (goto-char pos)
-;;       (when (c-looking-at-c++-lambda-capture-list)
-;;      (setq c-new-BEG (min c-new-BEG pos))
-;;      (if (c-go-list-forward)
-;;          (setq c-new-END (max c-new-END (point))))))))
+                    (backward-char)
+                    (eq (logand (skip-chars-backward "\\\\") 1) 1)))) ; not a real '.
+            ((c-quoted-number-straddling-point)
+             (setq num-beg (match-beginning 0)
+                   num-end (match-end 0))
+             (c-put-char-properties-on-char num-beg num-end
+                                            'syntax-table '(1) ?')
+             (c-put-char-properties-on-char num-beg num-end
+                                            'c-digit-separator t ?')
+             (goto-char num-end))
+            ((looking-at "\\([^\\']\\|\\\\.\\)'") ; balanced quoted expression.
+             (goto-char (match-end 0)))
+            (t (c-put-char-property (1- (point)) 'syntax-table '(1)))))))
 
 (defun c-before-change (beg end)
   ;; Function to be put on `before-change-functions'.  Primarily, this calls
diff --git a/lisp/progmodes/cc-styles.el b/lisp/progmodes/cc-styles.el
index b3848a74f97..b1c94c3bc6a 100644
--- a/lisp/progmodes/cc-styles.el
+++ b/lisp/progmodes/cc-styles.el
@@ -47,6 +47,7 @@
 ;; `c-add-style' often contains references to functions defined there.
 
 ;; Silence the compiler.
+(cc-bytecomp-defun c-guess-basic-syntax)
 (cc-bytecomp-defvar adaptive-fill-first-line-regexp) ; Emacs
 
 
diff --git a/lisp/progmodes/tcl.el b/lisp/progmodes/tcl.el
index 902a5aace08..de0cd50911a 100644
--- a/lisp/progmodes/tcl.el
+++ b/lisp/progmodes/tcl.el
@@ -353,8 +353,6 @@ information):
     Quotes all \"#\" characters that don't correspond to actual
     Tcl comments.  (Useful when editing code not originally created
     with this mode).
-  `tcl-auto-fill-mode'
-    Auto-filling of Tcl comments.
 
 Add functions to the hook with `add-hook':
 
@@ -1413,6 +1411,9 @@ Prefix argument means switch to the Tcl buffer afterwards."
 
 (defun tcl-auto-fill-mode (&optional arg)
   "Like `auto-fill-mode', but sets `comment-auto-fill-only-comments'."
+  (declare
+   (obsolete
+    "Use `auto-fill-mode' with `comment-auto-fill-only-comments'." "26.1"))
   (interactive "P")
   (auto-fill-mode arg)
   (if auto-fill-function
diff --git a/lisp/select.el b/lisp/select.el
index 4849d7d515e..579c5c7e2ee 100644
--- a/lisp/select.el
+++ b/lisp/select.el
@@ -475,6 +475,9 @@ two markers or an overlay.  Otherwise, it is nil."
            (t
             (error "Unknown selection type: %S" type)))))
 
+      ;; Most programs are unable to handle NUL bytes in strings.
+      (setq str (replace-regexp-in-string "\0" "\\0" str t t))
+
       (setq next-selection-coding-system nil)
       (cons type str))))
 
diff --git a/lisp/ses.el b/lisp/ses.el
index fd7174d383d..97bade380ec 100644
--- a/lisp/ses.el
+++ b/lisp/ses.el
@@ -437,7 +437,7 @@ is nil if SYM is not a symbol that names a cell."
   (declare (debug t))
   `(let ((rc (and (symbolp ,sym) (get ,sym 'ses-cell))))
      (if (eq rc :ses-named)
-         (gethash ,sym ses--named-cell-hashmap)
+         (and ses--named-cell-hashmap (gethash ,sym ses--named-cell-hashmap))
        rc)))
 
 (defun ses-cell-p (cell)
@@ -868,27 +868,39 @@ means Emacs will crash if FORMULA contains a circular list."
           (oldref (ses-formula-references old))
           (newref (ses-formula-references formula))
           (inhibit-quit t)
+          not-a-cell-ref-list
           x xrow xcol)
       (cl-pushnew sym ses--deferred-recalc)
       ;;Delete old references from this cell.  Skip the ones that are also
       ;;in the new list.
       (dolist (ref oldref)
         (unless (memq ref newref)
-          (setq x    (ses-sym-rowcol ref)
-                xrow (car x)
-                xcol (cdr x))
-          (ses-set-cell xrow xcol 'references
-                        (delq sym (ses-cell-references xrow xcol)))))
+          ;; because we do not cancel edit when the user provides a
+          ;; false reference in it, then we need to check that ref
+          ;; points to a cell that is within the spreadsheet.
+          (setq x    (ses-sym-rowcol ref))
+          (and x
+               (< (setq xrow (car x)) ses--numrows)
+               (< (setq xcol (cdr x)) ses--numcols)
+               (ses-set-cell xrow xcol 'references
+                            (delq sym (ses-cell-references xrow xcol))))))
       ;;Add new ones.  Skip ones left over from old list
       (dolist (ref newref)
-        (setq x    (ses-sym-rowcol ref)
-              xrow (car x)
-              xcol (cdr x)
-              x    (ses-cell-references xrow xcol))
-        (or (memq sym x)
-            (ses-set-cell xrow xcol 'references (cons sym x))))
+        (setq x    (ses-sym-rowcol ref))
+        ;;Do not trust the user, the reference may be outside the spreadsheet
+        (if (and
+             x
+             (<  (setq xrow (car x)) ses--numrows)
+             (<  (setq xcol (cdr x)) ses--numcols))
+          (progn
+            (setq x (ses-cell-references xrow xcol))
+            (or (memq sym x)
+                (ses-set-cell xrow xcol 'references (cons sym x))))
+          (cl-pushnew ref not-a-cell-ref-list)))
       (ses-formula-record formula)
-      (ses-set-cell row col 'formula formula))))
+      (ses-set-cell row col 'formula formula)
+      (and not-a-cell-ref-list
+           (error "Found in formula cells not in spreadsheet: %S" not-a-cell-ref-list)))))
 
 
 (defun ses-repair-cell-reference-all ()
@@ -1529,7 +1541,13 @@ by (ROWINCR,COLINCR)."
           ;;Relocate this variable, unless it is a named cell
           (if (eq (get sym 'ses-cell) :ses-named)
               sym
-            (ses-create-cell-symbol row col))
+            ;; otherwise, we create the relocated cell symbol because
+            ;; ses-cell-symbol gives the old symbols, however since
+            ;; renamed cell are not relocated we keep the relocated
+            ;; cell old symbol in this case.
+            (if (eq  (get (setq sym (ses-cell-symbol row col)) 'ses-cell) :ses-named)
+                sym
+              (ses-create-cell-symbol row col)))
         ;;Delete reference to a deleted cell
         nil))))
 
@@ -2337,7 +2355,8 @@ to are recalculated first."
   "Recalculate and reprint all cells."
   (interactive "*")
   (let ((startcell    (ses--cell-at-pos (point)))
-        (ses--curcell (cons 'A1 (ses-cell-symbol (1- ses--numrows)
+        (ses--curcell (cons (ses-cell-symbol 0 0)
+                            (ses-cell-symbol (1- ses--numrows)
                                                  (1- ses--numcols)))))
     (ses-recalculate-cell ses--curcell)
     (ses-jump-safe startcell)))
diff --git a/lisp/subr.el b/lisp/subr.el
index ef00286b341..a9edff6166f 100644
--- a/lisp/subr.el
+++ b/lisp/subr.el
@@ -121,6 +121,7 @@ BODY should be a list of Lisp expressions.
 (defmacro setq-local (var val)
   "Set variable VAR to value VAL in current buffer."
   ;; Can't use backquote here, it's too early in the bootstrap.
+  (declare (debug (symbolp form)))
   (list 'set (list 'make-local-variable (list 'quote var)) val))
 
 (defmacro defvar-local (var val &optional docstring)
@@ -4513,7 +4514,8 @@ EVALD, FUNC, ARGS, FLAGS are as in `mapbacktrace'."
 (defun backtrace ()
   "Print a trace of Lisp function calls currently active.
 Output stream used is value of `standard-output'."
-  (let ((print-level (or print-level 8)))
+  (let ((print-level (or print-level 8))
+        (print-escape-control-characters t))
     (mapbacktrace #'backtrace--print-frame 'backtrace)))
 
 (defun backtrace-frames (&optional base)
diff --git a/lisp/term/w32-win.el b/lisp/term/w32-win.el
index fda93884c40..be895a040da 100644
--- a/lisp/term/w32-win.el
+++ b/lisp/term/w32-win.el
@@ -396,7 +396,7 @@ See the documentation of `create-fontset-from-fontset-spec' for the format.")
 ;;; Fix interface to (X-specific) mouse.el
 (defun w32--set-selection (type value)
   (if (eq type 'CLIPBOARD)
-      (w32-set-clipboard-data value)
+      (w32-set-clipboard-data (replace-regexp-in-string "\0" "\\0" value t t))
     (put 'x-selections (or type 'PRIMARY) value)))
 
 (defun w32--get-selection  (&optional type data-type)
diff --git a/lisp/tooltip.el b/lisp/tooltip.el
index 367114b83f5..c011f1b01bc 100644
--- a/lisp/tooltip.el
+++ b/lisp/tooltip.el
@@ -119,7 +119,8 @@ the value of `tooltip-y-offset' is ignored."
 (defcustom tooltip-frame-parameters
   '((name . "tooltip")
     (internal-border-width . 2)
-    (border-width . 1))
+    (border-width . 1)
+    (no-special-glyphs . t))
   "Frame parameters used for tooltips.
 
 If `left' or `top' parameters are included, they specify the absolute
@@ -130,7 +131,8 @@ of the `tooltip' face are used instead."
   :type '(repeat (cons :format "%v"
                        (symbol :tag "Parameter")
                        (sexp :tag "Value")))
-  :group 'tooltip)
+  :group 'tooltip
+  :version "26.1")
 
 (defface tooltip
   '((((class color))
diff --git a/lisp/url/url-history.el b/lisp/url/url-history.el
index 1fa085400d8..8657d19da8c 100644
--- a/lisp/url/url-history.el
+++ b/lisp/url/url-history.el
@@ -1,4 +1,4 @@
-;;; url-history.el --- Global history tracking for URL package
+;;; url-history.el --- Global history tracking for URL package  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 1996-1999, 2004-2017 Free Software Foundation, Inc.
 
@@ -106,7 +106,7 @@ to run the `url-history-setup-save-timer' function manually."
 
 (defun url-history-update-url (url time)
   (setq url-history-changed-since-last-save t)
-  (puthash (if (vectorp url) (url-recreate-url url) url) time
+  (puthash (if (url-p url) (url-recreate-url url) url) time
            url-history-hash-table))
 
 (autoload 'url-make-private-file "url-util")
@@ -157,6 +157,7 @@ user for what type to save as."
   (gethash url url-history-hash-table nil))
 
 (defun url-completion-function (string predicate function)
+  (declare (obsolete url-history-hash-table "26.1"))
   ;; Completion function to complete urls from the history.
   ;; This is obsolete since we can now pass the hash-table directly as a
   ;; completion table.
@@ -164,7 +165,7 @@ user for what type to save as."
   (cond
    ((eq function nil)
     (let ((list nil))
-      (maphash (lambda (key val) (push key list))
+      (maphash (lambda (key _) (push key list))
                url-history-hash-table)
       ;; Not sure why we bother reversing the list.  --Stef
       (try-completion string (nreverse list) predicate)))
@@ -172,7 +173,7 @@ user for what type to save as."
     (let ((stub (concat "\\`" (regexp-quote string)))
           (retval nil))
       (maphash
-       (lambda (url time)
+       (lambda (url _)
          (if (string-match stub url) (push url retval)))
        url-history-hash-table)
       retval))
diff --git a/lisp/window.el b/lisp/window.el
index 8b07ed462c9..c933996a72f 100644
--- a/lisp/window.el
+++ b/lisp/window.el
@@ -3703,7 +3703,7 @@ are one more than the actual value of these edges.  Note that if
 ABSOLUTE is non-nil, PIXELWISE is implicitly non-nil too."
   (let* ((window (window-normalize-window window body))
          (frame (window-frame window))
-         (border-width (frame-border-width frame))
+         (border-width (frame-internal-border-width frame))
          (char-width (frame-char-width frame))
          (char-height (frame-char-height frame))
          (left (if pixelwise
@@ -4572,12 +4572,13 @@ The function is called with one argument - a frame.
 Functions affected by this option are those that bury a buffer
 shown in a separate frame like `quit-window' and `bury-buffer'."
   :type '(choice (const :tag "Iconify" iconify-frame)
+                 (const :tag "Make invisible" make-frame-invisible)
                  (const :tag "Delete" delete-frame)
                  (const :tag "Do nothing" ignore)
                  function)
   :group 'windows
   :group 'frames
-  :version "24.1")
+  :version "26.1")
 
 (defun window--delete (&optional window dedicated-only kill)
   "Delete WINDOW if possible.
@@ -4595,7 +4596,9 @@ if WINDOW gets deleted or its frame is auto-hidden."
           (cond
            (kill
             (delete-frame frame))
-           ((functionp frame-auto-hide-function)
+           ((functionp (frame-parameter frame 'auto-hide-function))
+            (funcall (frame-parameter frame 'auto-hide-function)))
+           ((functionp frame-auto-hide-function)
             (funcall frame-auto-hide-function frame))))
         'frame)
        (deletable
@@ -6734,15 +6737,17 @@ live."
     window))
 
 (defun window--maybe-raise-frame (frame)
-  (let ((visible (frame-visible-p frame)))
-    (unless (or (not visible)
-                ;; Assume the selected frame is already visible enough.
-                (eq frame (selected-frame))
-                ;; Assume the frame from which we invoked the
-                ;; minibuffer is visible.
-                (and (minibuffer-window-active-p (selected-window))
-                     (eq frame (window-frame (minibuffer-selected-window)))))
-      (raise-frame frame))))
+  (make-frame-visible frame)
+  (unless (or (frame-parameter frame 'no-focus-on-map)
+              ;; Don't raise frames that should not get focus.
+              (frame-parameter frame 'no-accept-focus)
+              ;; Assume the selected frame is already visible enough.
+              (eq frame (selected-frame))
+              ;; Assume the frame from which we invoked the
+              ;; minibuffer is visible.
+              (and (minibuffer-window-active-p (selected-window))
+                   (eq frame (window-frame (minibuffer-selected-window)))))
+    (raise-frame frame)))
 
 ;; FIXME: Not implemented.
 ;; FIXME: By the way, there could be more levels of dedication:
@@ -6762,6 +6767,7 @@ The actual non-nil value of this variable will be copied to the
            (const display-buffer-pop-up-window)
            (const display-buffer-same-window)
            (const display-buffer-pop-up-frame)
+           (const display-buffer-in-child-frame)
            (const display-buffer-below-selected)
            (const display-buffer-at-bottom)
            (const display-buffer-in-previous-window)
@@ -6908,6 +6914,7 @@ Available action functions include:
  `display-buffer-same-window'
  `display-buffer-reuse-window'
  `display-buffer-pop-up-frame'
+ `display-buffer-in-child-frame'
  `display-buffer-pop-up-window'
  `display-buffer-in-previous-window'
  `display-buffer-use-some-window'
@@ -7239,6 +7246,7 @@ raising the frame."
                                  (get-largest-window frame t) alist)
                                 (window--try-to-split-window
                                  (get-lru-window frame t) alist))))
+
       (prog1 (window--display-buffer
               buffer window 'window alist display-buffer-mark-dedicated)
         (unless (cdr (assq 'inhibit-switch-frame alist))
@@ -7258,6 +7266,47 @@ again with `display-buffer-pop-up-window'."
       (and pop-up-windows
            (display-buffer-pop-up-window buffer alist))))
 
+(defun display-buffer-in-child-frame (buffer alist)
+  "Display BUFFER in a child frame.
+By default, this either reuses a child frame of the selected
+frame or makes a new child frame of the selected frame.  If
+successful, return the window used; otherwise return nil.
+
+If ALIST has a non-nil 'child-frame-parameters' entry, the
+corresponding value is an alist of frame parameters to give the
+new frame.  A 'parent-frame' parameter specifying the selected
+frame is provided by default.  If the child frame should be or
+become the child of any other frame, a corresponding entry must
+be added to ALIST."
+  (let* ((parameters
+          (append
+           (cdr (assq 'child-frame-parameters alist))
+           `((parent-frame . ,(selected-frame)))))
+         (parent (or (assq 'parent-frame parameters)
+                     (selected-frame)))
+         (share (assq 'share-child-frame parameters))
+         share1 frame window)
+    (with-current-buffer buffer
+      (when (frame-live-p parent)
+        (catch 'frame
+          (dolist (frame1 (frame-list))
+            (when (eq (frame-parent frame1) parent)
+              (setq share1 (assq 'share-child-frame
+                                 (frame-parameters frame1)))
+              (when (eq share share1)
+                (setq frame frame1)
+                (throw 'frame t))))))
+
+      (if frame
+          (setq window (frame-selected-window frame))
+        (setq frame (make-frame parameters))
+        (setq window (frame-selected-window frame))))
+
+    (prog1 (window--display-buffer
+            buffer window 'frame alist display-buffer-mark-dedicated)
+      (unless (cdr (assq 'inhibit-switch-frame alist))
+        (window--maybe-raise-frame frame)))))
+
 (defun display-buffer-below-selected (buffer alist)
   "Try displaying BUFFER in a window below the selected window.
 If there is a window below the selected one and that window
@@ -7272,7 +7321,8 @@ below the selected one, use that window."
         (and (not (frame-parameter nil 'unsplittable))
              (let ((split-height-threshold 0)
                    split-width-threshold)
-               (setq window (window--try-to-split-window (selected-window) alist)))
+               (setq window (window--try-to-split-window
+                             (selected-window) alist)))
              (window--display-buffer
               buffer window 'window alist display-buffer-mark-dedicated))
         (and (setq window (window-in-direction 'below))
@@ -7885,10 +7935,12 @@ See also `fit-frame-to-buffer-margins'."
 (declare-function x-display-pixel-height "xfns.c" (&optional terminal))
 
 (defun window--sanitize-margin (margin left right)
-  "Return MARGIN if it's a number between LEFT and RIGHT."
-  (when (and (numberp margin)
-             (<= left (- right margin)) (<= margin right))
-    margin))
+  "Return MARGIN if it's a number between LEFT and RIGHT.
+Return 0 otherwise."
+  (if (and (numberp margin)
+           (<= left (- right margin)) (<= margin right))
+      margin
+    0))
 
 (declare-function tool-bar-height "xdisp.c" (&optional frame pixelwise))
 
@@ -7906,190 +7958,197 @@ horizontally only.
 
 The new position and size of FRAME can be additionally determined
 by customizing the options `fit-frame-to-buffer-sizes' and
-`fit-frame-to-buffer-margins' or the corresponding parameters of
-FRAME."
+`fit-frame-to-buffer-margins' or setting the corresponding
+parameters of FRAME."
   (interactive)
-  (unless (and (fboundp 'x-display-pixel-height)
-               ;; We need the respective sizes now.
-               (fboundp 'display-monitor-attributes-list))
+  (unless (fboundp 'display-monitor-attributes-list)
     (user-error "Cannot resize frame in non-graphic Emacs"))
   (setq frame (window-normalize-frame frame))
   (when (window-live-p (frame-root-window frame))
-    (with-selected-window (frame-root-window frame)
-      (let* ((char-width (frame-char-width))
-             (char-height (frame-char-height))
-             (monitor-attributes (car (display-monitor-attributes-list
-                                       (frame-parameter frame 'display))))
-             (geometry (cdr (assq 'geometry monitor-attributes)))
-             (display-width (- (nth 2 geometry) (nth 0 geometry)))
-             (display-height (- (nth 3 geometry) (nth 1 geometry)))
-             (workarea (cdr (assq 'workarea monitor-attributes)))
-             ;; Handle margins.
-             (margins (or (frame-parameter frame 'fit-frame-to-buffer-margins)
-                          fit-frame-to-buffer-margins))
-             (left-margin (if (nth 0 margins)
-                              (or (window--sanitize-margin
-                                   (nth 0 margins) 0 display-width)
-                                  0)
-                            (nth 0 workarea)))
-             (top-margin (if (nth 1 margins)
-                             (or (window--sanitize-margin
-                                  (nth 1 margins) 0 display-height)
-                                 0)
-                           (nth 1 workarea)))
-             (workarea-width (nth 2 workarea))
-             (right-margin (if (nth 2 margins)
-                               (- display-width
-                                  (or (window--sanitize-margin
-                                       (nth 2 margins) left-margin display-width)
-                                      0))
-                             (nth 2 workarea)))
-             (workarea-height (nth 3 workarea))
-             (bottom-margin (if (nth 3 margins)
-                                (- display-height
-                                   (or (window--sanitize-margin
-                                        (nth 3 margins) top-margin display-height)
-                                       0))
-                              (nth 3 workarea)))
-             ;; The pixel width of FRAME (which does not include the
-             ;; window manager's decorations).
-             (frame-width (frame-pixel-width))
-             ;; The pixel width of the body of FRAME's root window.
-             (window-body-width (window-body-width nil t))
-             ;; The difference in pixels between total and body width of
-             ;; FRAME's window.
-             (window-extra-width (- (window-pixel-width) window-body-width))
-             ;; The difference in pixels between the frame's pixel width
-             ;; and the window's body width.  This is the space we can't
-             ;; use for fitting.
-             (extra-width (- frame-width window-body-width))
-             ;; The pixel position of FRAME's left border.  We usually
-             ;; try to leave this alone.
-             (left
-              (let ((left (frame-parameter nil 'left)))
-                (if (consp left)
-                    (funcall (car left) (cadr left))
-                  left)))
-             ;; The pixel height of FRAME (which does not include title
-             ;; line, decorations, and sometimes neither the menu nor
-             ;; the toolbar).
-             (frame-height (frame-pixel-height))
-             ;; The pixel height of FRAME's root window (we don't care
-             ;; about the window's body height since the return value of
-             ;; `window-text-pixel-size' includes header and mode line).
-             (window-height (window-pixel-height))
-             ;; The difference in pixels between the frame's pixel
-             ;; height and the window's height.
-             (extra-height (- frame-height window-height))
-             ;; The pixel position of FRAME's top border.
-             (top
-              (let ((top (frame-parameter nil 'top)))
-                (if (consp top)
-                    (funcall (car top) (cadr top))
-                  top)))
-             ;; Sanitize minimum and maximum sizes.
-             (sizes (or (frame-parameter frame 'fit-frame-to-buffer-sizes)
-                        fit-frame-to-buffer-sizes))
-             (max-height
-              (cond
-               ((numberp (nth 0 sizes)) (* (nth 0 sizes) char-height))
-               ((numberp max-height) (* max-height char-height))
-               (t display-height)))
-             (min-height
-              (cond
-               ((numberp (nth 1 sizes)) (* (nth 1 sizes) char-height))
-               ((numberp min-height) (* min-height char-height))
-               (t (* window-min-height char-height))))
-             (max-width
-              (cond
-               ((numberp (nth 2 sizes))
-                (- (* (nth 2 sizes) char-width) window-extra-width))
-               ((numberp max-width)
-                (- (* max-width char-width) window-extra-width))
-               (t display-width)))
-             (min-width
-              (cond
-               ((numberp (nth 3 sizes))
-                (- (* (nth 3 sizes) char-width) window-extra-width))
-               ((numberp min-width)
-                (- (* min-width char-width) window-extra-width))
-               (t (* window-min-width char-width))))
-             ;; Note: Currently, for a new frame the sizes of the header
-             ;; and mode line may be estimated incorrectly
-             (value (window-text-pixel-size
-                     nil t t workarea-width workarea-height t))
-             (width (+ (car value) (window-right-divider-width)))
-             (height
-              (+ (cdr value)
-                 (window-bottom-divider-width)
-                 (window-scroll-bar-height))))
-        ;; Don't change height or width when the window's size is fixed
-        ;; in either direction or ONLY forbids it.
-        (cond
-         ((or (eq window-size-fixed 'width) (eq only 'vertically))
-          (setq width nil))
-         ((or (eq window-size-fixed 'height) (eq only 'horizontally))
-          (setq height nil)))
-        ;; Fit width to constraints.
-        (when width
-          (unless frame-resize-pixelwise
-            ;; Round to character sizes.
-            (setq width (* (/ (+ width char-width -1) char-width)
-                           char-width)))
-          ;; Fit to maximum and minimum widths.
-          (setq width (max (min width max-width) min-width))
-          ;; Add extra width.
-          (setq width (+ width extra-width))
-          ;; Preserve margins.
-          (let ((right (+ left width)))
-            (cond
-             ((> right right-margin)
-              ;; Move frame to left (we don't know its real width).
-              (setq left (max left-margin (- left (- right right-margin)))))
-             ((< left left-margin)
-              ;; Move frame to right.
-              (setq left left-margin)))))
-        ;; Fit height to constraints.
-        (when height
-          (unless frame-resize-pixelwise
-            (setq height (* (/ (+ height char-height -1) char-height)
-                            char-height)))
-          ;; Fit to maximum and minimum heights.
-          (setq height (max (min height max-height) min-height))
-          ;; Add extra height.
-          (setq height (+ height extra-height))
-          ;; Preserve margins.
-          (let ((bottom (+ top height)))
-            (cond
-             ((> bottom bottom-margin)
-              ;; Move frame up (we don't know its real height).
-              (setq top (max top-margin (- top (- bottom bottom-margin)))))
-             ((< top top-margin)
-              ;; Move frame down.
-              (setq top top-margin)))))
-        ;; Apply changes.
-        (set-frame-position frame left top)
-        ;; Clumsily try to translate our calculations to what
-        ;; `set-frame-size' wants.
-        (when width
-          (setq width (- (+ (frame-text-width) width)
-                         extra-width window-body-width)))
-        (when height
-          (setq height (- (+ (frame-text-height) height)
-                          extra-height window-height)))
-        (set-frame-size
-         frame
-         (if width
-             (if frame-resize-pixelwise
-                 width
-               (/ width char-width))
-           (frame-text-width))
-         (if height
-             (if frame-resize-pixelwise
-                 height
-               (/ height char-height))
-           (frame-text-height))
-         frame-resize-pixelwise)))))
+    (let* ((char-width (frame-char-width frame))
+           (char-height (frame-char-height frame))
+           ;; WINDOW is FRAME's root window.
+           (window (frame-root-window frame))
+           (parent (frame-parent frame))
+           (monitor-attributes
+            (unless parent
+              (car (display-monitor-attributes-list
+                    (frame-parameter frame 'display)))))
+           ;; FRAME'S parent or display sizes.  Used in connection
+           ;; with margins.
+           (geometry
+            (unless parent
+              (cdr (assq 'geometry monitor-attributes))))
+           (parent-or-display-width
+            (if parent
+                (frame-native-width parent)
+              (- (nth 2 geometry) (nth 0 geometry))))
+           (parent-or-display-height
+            (if parent
+                (frame-native-height parent)
+              (- (nth 3 geometry) (nth 1 geometry))))
+           ;; FRAME'S parent or workarea sizes.  Used when no margins
+           ;; are specified.
+           (parent-or-workarea
+            (if parent
+                `(0 0 ,parent-or-display-width ,parent-or-display-height)
+              (cdr (assq 'workarea monitor-attributes))))
+           ;; The outer size of FRAME.  Needed to calculate the
+           ;; margins around the root window's body that have to
+           ;; remain untouched by fitting.
+           (outer-edges (frame-edges frame 'outer-edges))
+           (outer-width (if outer-edges
+                            (- (nth 2 outer-edges) (nth 0 outer-edges))
+                          ;; A poor guess.
+                          (frame-pixel-width frame)))
+           (outer-height (if outer-edges
+                             (- (nth 3 outer-edges) (nth 1 outer-edges))
+                           ;; Another poor guess.
+                           (frame-pixel-height frame)))
+           ;; The text size of of FRAME.  Needed to specify FRAME's
+           ;; text size after the root window's body's new sizes have
+           ;; been calculated.
+           (text-width (frame-text-width frame))
+           (text-height (frame-text-height frame))
+           ;; WINDOW's body size.
+           (body-width (window-body-width window t))
+           (body-height (window-body-height window t))
+           ;; The difference between FRAME's outer size and WINDOW's
+           ;; body size.
+           (outer-minus-body-width (- outer-width body-width))
+           (outer-minus-body-height (- outer-height body-height))
+           ;; The difference between FRAME's text size and WINDOW's
+           ;; body size (these values "should" be positive).
+           (text-minus-body-width (- text-width body-width))
+           (text-minus-body-height (- text-height body-height))
+           ;; The current position of FRAME.
+           (position (frame-position frame))
+           (left (car position))
+           (top (cdr position))
+           ;; The margins specified for FRAME.  These represent pixel
+           ;; offsets from the left, top, right and bottom edge of the
+           ;; display or FRAME's parent's native rectangle and have to
+           ;; take care of the display's taskbar and other obstacles.
+           ;; If they are unspecified, constrain the resulting frame
+           ;; to its workarea or the parent frame's native rectangle.
+           (margins (or (frame-parameter frame 'fit-frame-to-buffer-margins)
+                        fit-frame-to-buffer-margins))
+           ;; Convert margins intto pixel offsets from the left-top
+           ;; corner of FRAME's display or parent.
+           (left-margin (if (nth 0 margins)
+                            (window--sanitize-margin
+                             (nth 0 margins) 0 parent-or-display-width)
+                          (nth 0 parent-or-workarea)))
+           (top-margin (if (nth 1 margins)
+                           (window--sanitize-margin
+                            (nth 1 margins) 0 parent-or-display-height)
+                         (nth 1 parent-or-workarea)))
+           (right-margin (if (nth 2 margins)
+                             (- parent-or-display-width
+                                (window--sanitize-margin
+                                 (nth 2 margins) left-margin
+                                 parent-or-display-width))
+                           (nth 2 parent-or-workarea)))
+           (bottom-margin (if (nth 3 margins)
+                              (- parent-or-display-height
+                                 (window--sanitize-margin
+                                  (nth 3 margins) top-margin
+                                  parent-or-display-height))
+                            (nth 3 parent-or-workarea)))
+           ;; Minimum and maximum sizes specified for FRAME.
+           (sizes (or (frame-parameter frame 'fit-frame-to-buffer-sizes)
+                      fit-frame-to-buffer-sizes))
+           ;; Calculate the minimum and maximum pixel sizes of FRAME
+           ;; from the values provided by the MAX-HEIGHT, MIN-HEIGHT,
+           ;; MAX-WIDTH and MIN-WIDTH arguments or, if these are nil,
+           ;; from those provided by `fit-frame-to-buffer-sizes'.
+           (max-height
+            (min
+             (cond
+              ((numberp max-height) (* max-height char-height))
+              ((numberp (nth 0 sizes)) (* (nth 0 sizes) char-height))
+              (t parent-or-display-height))
+             ;; The following is the maximum height that fits into the
+             ;; top and bottom margins.
+             (max (- bottom-margin top-margin outer-minus-body-height))))
+           (min-height
+            (cond
+             ((numberp min-height) (* min-height char-height))
+             ((numberp (nth 1 sizes)) (* (nth 1 sizes) char-height))
+             (t (window-min-size window nil nil t))))
+           (max-width
+            (min
+             (cond
+              ((numberp max-width) (* max-width char-width))
+              ((numberp (nth 2 sizes)) (* (nth 2 sizes) char-width))
+              (t parent-or-display-width))
+             ;; The following is the maximum width that fits into the
+             ;; left and right margins.
+             (max (- right-margin left-margin outer-minus-body-width))))
+           (min-width
+            (cond
+             ((numberp min-width) (* min-width char-width))
+             ((numberp (nth 3 sizes)) (nth 3 sizes))
+             (t (window-min-size window t nil t))))
+           ;; Note: Currently, for a new frame the sizes of the header
+           ;; and mode line may be estimated incorrectly
+           (size
+            (window-text-pixel-size window t t max-width max-height))
+           (width (max (car size) min-width))
+           (height (max (cdr size) min-height)))
+      ;; Don't change height or width when the window's size is fixed
+      ;; in either direction or ONLY forbids it.
+      (cond
+       ((or (eq window-size-fixed 'width) (eq only 'vertically))
+        (setq width nil))
+       ((or (eq window-size-fixed 'height) (eq only 'horizontally))
+        (setq height nil)))
+      ;; Fit width to constraints.
+      (when width
+        (unless frame-resize-pixelwise
+          ;; Round to character sizes.
+          (setq width (* (/ (+ width char-width -1) char-width)
+                         char-width)))
+        ;; The new outer width (in pixels).
+        (setq outer-width (+ width outer-minus-body-width))
+        ;; Maybe move FRAME to preserve margins.
+        (let ((right (+ left outer-width)))
+          (cond
+           ((> right right-margin)
+            ;; Move frame to left.
+            (setq left (max left-margin (- left (- right right-margin)))))
+           ((< left left-margin)
+            ;; Move frame to right.
+            (setq left left-margin)))))
+      ;; Fit height to constraints.
+      (when height
+        (unless frame-resize-pixelwise
+          (setq height (* (/ (+ height char-height -1) char-height)
+                          char-height)))
+        ;; The new outer height.
+        (setq outer-height (+ height outer-minus-body-height))
+        ;; Preserve margins.
+        (let ((bottom (+ top outer-height)))
+          (cond
+           ((> bottom bottom-margin)
+            ;; Move frame up.
+            (setq top (max top-margin (- top (- bottom bottom-margin)))))
+           ((< top top-margin)
+            ;; Move frame down.
+            (setq top top-margin)))))
+      ;; Apply our changes.
+      (setq text-width
+            (if width
+                (+ width text-minus-body-width)
+              (frame-text-width frame)))
+      (setq text-height
+            (if height
+                (+ height text-minus-body-height)
+              (frame-text-height frame)))
+      (modify-frame-parameters
+       frame `((left . ,left) (top . ,top)
+               (width . (text-pixels . ,text-width))
+               (height . (text-pixels . ,text-height)))))))
 
 (defun fit-window-to-buffer (&optional window max-height min-height max-width min-width preserve-size)
   "Adjust size of WINDOW to display its buffer's contents exactly.
@@ -8286,6 +8345,168 @@ Return non-nil if the window was shrunk, nil otherwise."
   (when (and (window-combined-p window)
              (pos-visible-in-window-p (point-min) window))
     (fit-window-to-buffer window (window-total-height window))))
+
+(defun window-largest-empty-rectangle--maximums-1 (quad maximums)
+  "Support function for `window-largest-empty-rectangle'."
+  (cond
+   ((null maximums)
+    (list quad))
+   ((> (car quad) (caar maximums))
+    (cons quad maximums))
+   (t
+    (cons (car maximums)
+          (window-largest-empty-rectangle--maximums-1 quad (cdr maximums))))))
+
+(defun window-largest-empty-rectangle--maximums (quad maximums count)
+  "Support function for `window-largest-empty-rectangle'."
+  (setq maximums (window-largest-empty-rectangle--maximums-1 quad maximums))
+  (if (> (length maximums) count)
+      (nbutlast maximums)
+    maximums))
+
+(defun window-largest-empty-rectangle--disjoint-maximums (maximums count)
+  "Support function for `window-largest-empty-rectangle'."
+  (setq maximums (sort maximums (lambda (x y) (> (car x) (car y)))))
+  (let ((new-length 0)
+        new-maximums)
+    (while (and maximums (< new-length count))
+      (let* ((maximum (car maximums))
+             (at (nth 2 maximum))
+             (to (nth 3 maximum)))
+        (catch 'drop
+          (dolist (new-maximum new-maximums)
+            (let ((new-at (nth 2 new-maximum))
+                  (new-to (nth 3 new-maximum)))
+              (when (if (< at new-at) (> to new-at) (< at new-to))
+                ;; Intersection -> drop.
+                (throw 'drop nil))))
+          (setq new-maximums (cons maximum new-maximums))
+          (setq new-length (1+ new-length)))
+        (setq maximums (cdr maximums))))
+
+    (nreverse new-maximums)))
+
+(defun window-largest-empty-rectangle (&optional window count min-width min-height positions left)
+  "Return dimensions of largest empty rectangle in WINDOW.
+WINDOW must be a live window and defaults to the selected one.
+
+The return value is a triple of the width and the start and end
+Y-coordinates of the largest rectangle that can be inscribed into
+the empty space (the space not displaying any text) of WINDOW's
+text area.  The return value is nil if the current glyph matrix
+of WINDOW is not up-to-date.
+
+Optional argument COUNT, if non-nil, specifies the maximum number
+of rectangles to return.  This means that the return value is a
+list of triples specifying rectangles with the largest rectangle
+first.  COUNT can be also a cons cell whose car specifies the
+number of rectangles to return and whose cdr, if non-nil, states
+that all rectangles returned must be disjoint.
+
+Note that the right edge of any rectangle returned by this
+function is the right edge of WINDOW (the left edge if its buffer
+displays RTL text).
+
+Optional arguments MIN-WIDTH and MIN-HEIGHT, if non-nil, specify
+the minimum width and height of any rectangle returned.
+
+Optional argument POSITIONS, if non-nil, is a cons cell whose car
+specifies the uppermost and whose cdr specifies the lowermost
+pixel position that must be covered by any rectangle returned.
+Note that positions are counted from the start of the text area
+of WINDOW.
+
+Optional argument LEFT, if non-nil, means to return values suitable for
+buffers displaying right to left text."
+  ;; Process lines as returned by ‘window-lines-pixel-dimensions’.
+  ;; STACK is a stack that contains rows that have to be processed yet.
+  (let* ((window (window-normalize-window window t))
+         (disjoint (and (consp count) (cdr count)))
+         (count (or (and (numberp count) count)
+                    (and (consp count) (numberp (car count)) (car count))))
+         (rows (window-lines-pixel-dimensions window nil nil t t left))
+         (rows-at 0)
+         (max-size 0)
+         row stack stack-at stack-to
+         top top-width top-at top-to top-size
+         max-width max-at max-to maximums)
+    ;; ROWS-AT is the position where the first element of ROWS starts.
+    ;; STACK-AT is the position where the first element of STACK starts.
+    (while rows
+      (setq row (car rows))
+      (if (or (not stack) (>= (car row) (caar stack)))
+          (progn
+            (unless stack
+              (setq stack-at rows-at))
+            (setq stack (cons row stack))
+            ;; Set ROWS-AT to where the first element of ROWS ends
+            ;; which, after popping ROW, makes it the start position of
+            ;; the next ROW.
+            (setq rows-at (cdr row))
+            (setq rows (cdr rows)))
+        (setq top (car stack))
+        (setq stack (cdr stack))
+        (setq top-width (car top))
+        (setq top-at (if stack (cdar stack) stack-at))
+        (setq top-to (cdr top))
+        (setq top-size (* top-width (- top-to top-at)))
+        (unless (or (and min-width (< top-width min-width))
+                    (and min-height (< (- top-to top-at) min-height))
+                    (and positions
+                         (or (> top-at (car positions))
+                             (< top-to (cdr positions)))))
+          (if count
+              (if disjoint
+                  (setq maximums (cons (list top-size top-width top-at top-to)
+                                       maximums))
+                (setq maximums (window-largest-empty-rectangle--maximums
+                                (list top-size top-width top-at top-to)
+                                maximums count)))
+            (when (> top-size max-size)
+              (setq max-size top-size)
+              (setq max-width top-width)
+              (setq max-at top-at)
+              (setq max-to top-to))))
+        (if (and stack (> (caar stack) (car row)))
+            ;; Have new top element of stack include old top.
+            (setq stack (cons (cons (caar stack) (cdr top)) (cdr stack)))
+          ;; Move rows-at backwards to top-at.
+          (setq rows-at top-at))))
+
+    (when stack
+      ;; STACK-TO is the position where the stack ends.
+      (setq stack-to (cdar stack))
+      (while stack
+        (setq top (car stack))
+        (setq stack (cdr stack))
+        (setq top-width (car top))
+        (setq top-at (if stack (cdar stack) stack-at))
+        (setq top-size (* top-width (- stack-to top-at)))
+        (unless (or (and min-width (< top-width min-width))
+                    (and min-height (< (- stack-to top-at) min-height))
+                    (and positions
+                         (or (> top-at (car positions))
+                             (< stack-to (cdr positions)))))
+          (if count
+              (if disjoint
+                  (setq maximums (cons (list top-size top-width top-at stack-to)
+                                       maximums))
+                (setq maximums (window-largest-empty-rectangle--maximums
+                                (list top-size top-width top-at stack-to)
+                                maximums count)))
+            (when (> top-size max-size)
+              (setq max-size top-size)
+              (setq max-width top-width)
+              (setq max-at top-at)
+              (setq max-to stack-to))))))
+
+    (cond
+     (maximums
+      (if disjoint
+          (window-largest-empty-rectangle--disjoint-maximums maximums count)
+        maximums))
+     ((> max-size 0)
+      (list max-width max-at max-to)))))
 
 (defun kill-buffer-and-window ()
   "Kill the current buffer and delete the selected window."