Merge branch 'master' of git.sv.gnu.org:/srv/git/emacs

52 files changed, 1157 insertions, 847 deletions

diff --git a/lisp/Makefile.in b/lisp/Makefile.in
index cbe7718981e..185554ca63a 100644
--- a/lisp/Makefile.in
+++ b/lisp/Makefile.in
@@ -47,6 +47,9 @@ am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
 am__v_at_0 = @
 am__v_at_1 =
 
+
+FIND_DELETE = @FIND_DELETE@
+
 # You can specify a different executable on the make command line,
 # e.g. "make EMACS=../src/emacs ...".
 
@@ -343,7 +346,7 @@ compile: $(LOADDEFS) autoloads compile-first
 # unconditionally.  Some files don't actually get compiled because they
 # set the local variable no-byte-compile.
 compile-always:
-        cd $(lisp) && rm -f *.elc */*.elc */*/*.elc */*/*/*.elc
+        find $(lisp) -name '*.elc' $(FIND_DELETE)
         $(MAKE) compile
 
 .PHONY: backup-compiled-files compile-after-backup
@@ -433,7 +436,8 @@ $(CAL_DIR)/hol-loaddefs.el: $(CAL_SRC) $(CAL_DIR)/diary-loaddefs.el
 .PHONY: bootstrap-clean distclean maintainer-clean
 
 bootstrap-clean:
-        -cd $(lisp) && rm -f *.elc */*.elc */*/*.elc */*/*/*.elc $(AUTOGENEL)
+        find $(lisp) -name '*.elc' $(FIND_DELETE)
+        -cd $(lisp) && rm -f $(AUTOGENEL)
 
 distclean:
         -rm -f ./Makefile $(lisp)/loaddefs.el~
diff --git a/lisp/cedet/semantic/wisent/wisent.el b/lisp/cedet/semantic/wisent/wisent.el
index 36dff019792..08cad524aed 100644
--- a/lisp/cedet/semantic/wisent/wisent.el
+++ b/lisp/cedet/semantic/wisent/wisent.el
@@ -114,7 +114,7 @@ If OBJ is a symbol check its value."
   (and (vectorp obj) (= 4 (length obj))
        (vectorp (aref obj 0)) (vectorp (aref obj 1))
        (= (length (aref obj 0)) (length (aref obj 1)))
-       (listp (aref obj 2)) (vectorp (aref obj 3))))
+       (listp (aref obj 2)) (obarrayp (aref obj 3))))
 
 (defsubst wisent-region (&rest positions)
   "Return the start/end positions of the region including POSITIONS.
diff --git a/lisp/dired-x.el b/lisp/dired-x.el
index 6c8fb0e7dae..527685acf37 100644
--- a/lisp/dired-x.el
+++ b/lisp/dired-x.el
@@ -332,46 +332,73 @@ See also the functions:
 
 ;;; EXTENSION MARKING FUNCTIONS.
 
+(defun dired--mark-suffix-interactive-spec ()
+  (let* ((default
+           (let ((file (dired-get-filename nil t)))
+             (when file
+               (file-name-extension file))))
+         (suffix
+          (read-string (format "%s extension%s: "
+                               (if (equal current-prefix-arg '(4))
+                                   "UNmarking"
+                                 "Marking")
+                               (if default
+                                   (format " (default %s)" default)
+                                 "")) nil nil default))
+         (marker
+          (pcase current-prefix-arg
+            ('(4) ?\s)
+            ('(16)
+             (let* ((dflt (char-to-string dired-marker-char))
+                    (input (read-string
+                            (format
+                             "Marker character to use (default %s): " dflt)
+                            nil nil dflt)))
+               (aref input 0)))
+            (_ dired-marker-char))))
+    (list suffix marker)))
+
 ;; Mark files with some extension.
 (defun dired-mark-extension (extension &optional marker-char)
   "Mark all files with a certain EXTENSION for use in later commands.
-A `.' is *not* automatically prepended to the string entered.
+A `.' is automatically prepended to EXTENSION when not present.
 EXTENSION may also be a list of extensions instead of a single one.
 Optional MARKER-CHAR is marker to use.
 Interactively, ask for EXTENSION.
 Prefixed with one C-u, unmark files instead.
 Prefixed with two C-u's, prompt for MARKER-CHAR and mark files with it."
-  (interactive
-   (let* ((default
-            (let ((file (dired-get-filename nil t)))
-              (when file
-                (file-name-extension file))))
-          (suffix
-           (read-string (format "%s extension%s: "
-                                (if (equal current-prefix-arg '(4))
-                                    "UNmarking"
-                                  "Marking")
-                                (if default
-                                    (format " (default %s)" default)
-                                  "")) nil nil default))
-          (marker
-           (pcase current-prefix-arg
-             ('(4) ?\s)
-             ('(16)
-              (let* ((dflt (char-to-string dired-marker-char))
-                     (input (read-string
-                             (format
-                              "Marker character to use (default %s): " dflt)
-                             nil nil dflt)))
-                (aref input 0)))
-             (_ dired-marker-char))))
-     (list suffix marker)))
-  (or (listp extension)
-      (setq extension (list extension)))
+  (interactive (dired--mark-suffix-interactive-spec))
+  (unless (listp extension)
+    (setq extension (list extension)))
+  (dired-mark-files-regexp
+   (concat ".";; don't match names with nothing but an extension
+           "\\("
+           (mapconcat
+            (lambda (x)
+              (regexp-quote
+               (if (string-prefix-p "." x) x (concat "." x))))
+            extension "\\|")
+           "\\)$")
+   marker-char))
+
+;; Mark files ending with some suffix.
+(defun dired-mark-suffix (suffix &optional marker-char)
+  "Mark all files with a certain SUFFIX for use in later commands.
+A `.' is *not* automatically prepended to the string entered;  see
+also `dired-mark-extension', which is similar but automatically
+prepends `.' when not present.
+SUFFIX may also be a list of suffixes instead of a single one.
+Optional MARKER-CHAR is marker to use.
+Interactively, ask for SUFFIX.
+Prefixed with one C-u, unmark files instead.
+Prefixed with two C-u's, prompt for MARKER-CHAR and mark files with it."
+  (interactive (dired--mark-suffix-interactive-spec))
+  (unless (listp suffix)
+    (setq suffix (list suffix)))
   (dired-mark-files-regexp
    (concat ".";; don't match names with nothing but an extension
            "\\("
-           (mapconcat 'regexp-quote extension "\\|")
+           (mapconcat 'regexp-quote suffix "\\|")
            "\\)$")
    marker-char))
 
diff --git a/lisp/emacs-lisp/bytecomp.el b/lisp/emacs-lisp/bytecomp.el
index f45ae359f6c..2c2996ebab4 100644
--- a/lisp/emacs-lisp/bytecomp.el
+++ b/lisp/emacs-lisp/bytecomp.el
@@ -443,7 +443,7 @@ Return the compile-time value of FORM."
   ;; Macroexpand (not macroexpand-all!) form at toplevel in case it
   ;; expands into a toplevel-equivalent `progn'.  See CLHS section
   ;; 3.2.3.1, "Processing of Top Level Forms".  The semantics are very
-  ;; subtle: see test/automated/bytecomp-tests.el for interesting
+  ;; subtle: see test/lisp/emacs-lisp/bytecomp-tests.el for interesting
   ;; cases.
   (setf form (macroexp-macroexpand form byte-compile-macro-environment))
   (if (eq (car-safe form) 'progn)
diff --git a/lisp/emacs-lisp/edebug.el b/lisp/emacs-lisp/edebug.el
index 60133055623..4116e31d0a9 100644
--- a/lisp/emacs-lisp/edebug.el
+++ b/lisp/emacs-lisp/edebug.el
@@ -733,9 +733,9 @@ Maybe clear the markers and delete the symbol's edebug property?"
      ((eq class 'string) (read (current-buffer)))
      ((eq class 'quote) (forward-char 1)
       (list 'quote (edebug-read-sexp)))
-     ((eq class 'backquote)
+     ((eq class 'backquote) (forward-char 1)
       (list '\` (edebug-read-sexp)))
-     ((eq class 'comma)
+     ((eq class 'comma) (forward-char 1)
       (list '\, (edebug-read-sexp)))
      (t ; anything else, just read it.
       (read (current-buffer))))))
diff --git a/lisp/emacs-lisp/ert.el b/lisp/emacs-lisp/ert.el
index cadd66ca6ed..e7387e463cb 100644
--- a/lisp/emacs-lisp/ert.el
+++ b/lisp/emacs-lisp/ert.el
@@ -1236,7 +1236,7 @@ SELECTOR is the selector that was used to select TESTS."
         (funcall listener 'test-ended stats test result))
       (setf (ert--stats-current-test stats) nil))))
 
-(defun ert-run-tests (selector listener)
+(defun ert-run-tests (selector listener &optional interactively)
   "Run the tests specified by SELECTOR, sending progress updates to LISTENER."
   (let* ((tests (ert-select-tests selector t))
          (stats (ert--make-stats tests selector)))
@@ -1247,10 +1247,14 @@ SELECTOR is the selector that was used to select TESTS."
           (let ((ert--current-run-stats stats))
             (force-mode-line-update)
             (unwind-protect
-                (progn
-                  (cl-loop for test in tests do
-                           (ert-run-or-rerun-test stats test listener))
-                  (setq abortedp nil))
+                (cl-loop for test in tests do
+                         (ert-run-or-rerun-test stats test listener)
+                         (when (and interactively
+                                    (ert-test-quit-p
+                                     (ert-test-most-recent-result test))
+                                    (y-or-n-p "Abort testing? "))
+                           (cl-return))
+                         finally (setq abortedp nil))
               (setf (ert--stats-aborted-p stats) abortedp)
               (setf (ert--stats-end-time stats) (current-time))
               (funcall listener 'run-ended stats abortedp)))
@@ -1442,7 +1446,8 @@ Returns the stats object."
                                                  (ert-test-result-expected-p
                                                   test result))
                      (1+ (ert--stats-test-pos stats test))
-                     (ert-test-name test)))))))))
+                     (ert-test-name test)))))))
+   nil))
 
 ;;;###autoload
 (defun ert-run-tests-batch-and-exit (&optional selector)
@@ -2033,9 +2038,8 @@ and how to display message."
                                                       test result)))
                      (ert--results-update-stats-display-maybe ewoc stats)
                      (ewoc-invalidate ewoc node))))))))
-    (ert-run-tests
-     selector
-     listener)))
+    (ert-run-tests selector listener t)))
+
 ;;;###autoload
 (defalias 'ert 'ert-run-tests-interactively)
 
diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index eb07c18b03d..b7a5eb774da 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -259,6 +259,24 @@ This will generate compile-time constants from BINDINGS."
                     (funcall loop bindings)))))))
     (funcall loop bindings)))
 
+(defun elisp--font-lock-backslash ()
+  (let* ((beg0 (match-beginning 0))
+         (end0 (match-end 0))
+         (ppss (save-excursion (syntax-ppss beg0))))
+    (and (nth 3 ppss)                  ;Inside a string.
+         (not (nth 5 ppss))            ;The \ is not itself \-escaped.
+         ;; Don't highlight the \( introduced because of
+         ;; `open-paren-in-column-0-is-defun-start'.
+         (not (eq ?\n (char-before beg0)))
+         (equal (ignore-errors
+                  (car (read-from-string
+                        (format "\"%s\""
+                                (buffer-substring-no-properties
+                                 beg0 end0)))))
+                (buffer-substring-no-properties (1+ beg0) end0))
+         `(face ,font-lock-warning-face
+                help-echo "This \\ has no effect"))))
+
 (let-when-compile
     ((lisp-fdefs '("defmacro" "defun"))
      (lisp-vdefs '("defvar"))
@@ -413,17 +431,7 @@ This will generate compile-time constants from BINDINGS."
           (1 font-lock-constant-face prepend))
          ;; Ineffective backslashes (typically in need of doubling).
          ("\\(\\\\\\)\\([^\"\\]\\)"
-          (1 (let ((ppss (save-excursion (syntax-ppss (match-beginning 0)))))
-               (and (nth 3 ppss)        ;Inside a string.
-                    (not (nth 5 ppss))  ;The \ is not itself \-escaped.
-                    (equal (ignore-errors
-                             (car (read-from-string
-                                   (format "\"%s\""
-                                           (match-string-no-properties 0)))))
-                           (match-string-no-properties 2))
-                    `(face ,font-lock-warning-face
-                           help-echo "This \\ has no effect")))
-             prepend))
+          (1 (elisp--font-lock-backslash) prepend))
          ;; Words inside ‘’ and `' tend to be symbol names.
          (,(concat "[`‘]\\(\\(?:\\sw\\|\\s_\\|\\\\.\\)"
                    lisp-mode-symbol-regexp "\\)['’]")
@@ -1083,7 +1091,8 @@ ENDPOS is encountered."
          (init-depth (car state))
          (next-depth init-depth)
          (last-depth init-depth)
-         (last-syntax-point (point)))
+         (last-syntax-point (point))
+         (real-endpos endpos))
     (unless endpos
       ;; Get error now if we don't have a complete sexp after point.
       (save-excursion (forward-sexp 1)
@@ -1116,6 +1125,8 @@ ENDPOS is encountered."
                 last-depth (- last-depth next-depth)
                 next-depth init-depth))
         (forward-line 1)
+        (when (and (not real-endpos) (<= next-depth init-depth))
+          (goto-char endpos))
         (when (< (point) endpos)
           (let ((depth-delta (- next-depth last-depth)))
             (cond ((< depth-delta 0)
diff --git a/lisp/emacs-lisp/pcase.el b/lisp/emacs-lisp/pcase.el
index 289265abf27..fc5474ecc43 100644
--- a/lisp/emacs-lisp/pcase.el
+++ b/lisp/emacs-lisp/pcase.el
@@ -175,8 +175,8 @@ Emacs Lisp manual for more information and examples."
       ;; (when (gethash (car cases) pcase--memoize-2)
       ;;   (message "pcase-memoize failed because of eq test on %S"
       ;;            (car cases)))
-      (when data
-        (message "pcase-memoize: equal first branch, yet different"))
+      ;; (when data
+      ;;   (message "pcase-memoize: equal first branch, yet different"))
       (let ((expansion (pcase--expand exp cases)))
         (puthash (car cases) `(,exp ,cases ,@expansion) pcase--memoize)
         ;; (puthash (car cases) `(,exp ,cases ,@expansion) pcase--memoize-1)
diff --git a/lisp/emacs-lisp/seq.el b/lisp/emacs-lisp/seq.el
index 41187646624..10de2484798 100644
--- a/lisp/emacs-lisp/seq.el
+++ b/lisp/emacs-lisp/seq.el
@@ -52,7 +52,7 @@
 ;; - `seq-copy'
 ;; - `seq-into'
 ;;
-;; All functions are tested in test/automated/seq-tests.el
+;; All functions are tested in test/lisp/emacs-lisp/seq-tests.el
 
 ;;; Code:
 
diff --git a/lisp/emacs-lisp/thunk.el b/lisp/emacs-lisp/thunk.el
index be0a90fefde..f4c075d22ce 100644
--- a/lisp/emacs-lisp/thunk.el
+++ b/lisp/emacs-lisp/thunk.el
@@ -42,8 +42,6 @@
 ;;
 ;;    (thunk-force delayed)
 
-;; Tests are located at test/automated/thunk-tests.el
-
 ;;; Code:
 
 (defmacro thunk-delay (&rest body)
diff --git a/lisp/ffap.el b/lisp/ffap.el
index d7222bfb681..1ea32b75f12 100644
--- a/lisp/ffap.el
+++ b/lisp/ffap.el
@@ -1110,32 +1110,67 @@ The arguments CHARS, BEG and END are handled as described in
 
 (defun ffap-string-at-point (&optional mode)
   "Return a string of characters from around point.
+
 MODE (defaults to value of `major-mode') is a symbol used to look up
 string syntax parameters in `ffap-string-at-point-mode-alist'.
+
 If MODE is not found, we use `file' instead of MODE.
+
 If the region is active, return a string from the region.
-Set the variable `ffap-string-at-point' and the variable
+
+If the point is in a comment, ensure that the returned string does not
+contain the comment start characters (especially for major modes that
+have '//' as comment start characters).
+
+Set the variables `ffap-string-at-point' and
 `ffap-string-at-point-region'.
+
 When the region is active and larger than `ffap-max-region-length',
 return an empty string, and set `ffap-string-at-point-region' to '(1 1)."
   (let* ((args
           (cdr
            (or (assq (or mode major-mode) ffap-string-at-point-mode-alist)
                (assq 'file ffap-string-at-point-mode-alist))))
+         (region-selected (use-region-p))
          (pt (point))
-         (beg (if (use-region-p)
+         (beg (if region-selected
                   (region-beginning)
                 (save-excursion
                   (skip-chars-backward (car args))
                   (skip-chars-forward (nth 1 args) pt)
                   (point))))
-         (end (if (use-region-p)
+         (end (if region-selected
                   (region-end)
                 (save-excursion
                   (skip-chars-forward (car args))
                   (skip-chars-backward (nth 2 args) pt)
                   (point))))
          (region-len (- (max beg end) (min beg end))))
+
+    ;; If the initial characters of the to-be-returned string are the
+    ;; current major mode's comment starter characters, *and* are
+    ;; not part of a comment, remove those from the returned string
+    ;; (Bug#24057).
+    ;; Example comments in `c-mode' (which considers lines beginning
+    ;; with "//" as comments):
+    ;;  //tmp - This is a comment. It does not contain any path reference.
+    ;;  ///tmp - This is a comment. The "/tmp" portion in that is a path.
+    ;;  ////tmp - This is a comment. The "//tmp" portion in that is a path.
+    (when (and
+           ;; Proceed if no region is selected by the user.
+           (null region-selected)
+           ;; Check if END character is part of a comment.
+           (save-excursion
+             (nth 4 (syntax-ppss end))))
+      ;; Move BEG to beginning of comment (after the comment start
+      ;; characters), or END, whichever comes first.
+      (save-excursion
+        (let ((state (syntax-ppss beg)))
+          ;; (nth 4 (syntax-ppss)) will be nil for comment start chars.
+          (unless (nth 4 state)
+            (parse-partial-sexp beg end nil nil state :commentstop)
+            (setq beg (point))))))
+
     (if (and (natnump ffap-max-region-length)
              (< region-len ffap-max-region-length)) ; Bug#25243.
         (setf ffap-string-at-point-region (list beg end)
diff --git a/lisp/filenotify.el b/lisp/filenotify.el
index 7eb6229976a..8bbe348f332 100644
--- a/lisp/filenotify.el
+++ b/lisp/filenotify.el
@@ -28,6 +28,7 @@
 ;;; Code:
 
 (require 'cl-lib)
+(require 'subr-x)
 
 (defconst file-notify--library
   (cond
@@ -40,41 +41,43 @@ The value is the name of the low-level file notification package
 to be used for local file systems.  Remote file notifications
 could use another implementation.")
 
+(cl-defstruct (file-notify--watch
+               (:constructor nil)
+               (:constructor
+                file-notify--watch-make (directory filename callback)))
+  ;; Watched directory
+  directory
+  ;; Watched relative filename, nil if watching the directory.
+  filename
+  ;; Function to propagate events to
+  callback)
+
+(defun file-notify--watch-absolute-filename (watch)
+  "Return the absolute filename observed by WATCH."
+  (if (file-notify--watch-filename watch)
+      (expand-file-name
+       (file-notify--watch-filename watch)
+       (file-notify--watch-directory watch))
+    (file-notify--watch-directory watch)))
+
 (defvar file-notify-descriptors (make-hash-table :test 'equal)
   "Hash table for registered file notification descriptors.
 A key in this hash table is the descriptor as returned from
 `inotify', `kqueue', `gfilenotify', `w32notify' or a file name
-handler.  The value in the hash table is a list
-
-  (DIR (FILE . CALLBACK) (FILE . CALLBACK) ...)
-
-Several values for a given DIR happen only for `inotify', when
-different files from the same directory are watched.")
+handler.  The value in the hash table is `file-notify--watch'
+struct.")
 
 (defun file-notify--rm-descriptor (descriptor)
   "Remove DESCRIPTOR from `file-notify-descriptors'.
 DESCRIPTOR should be an object returned by `file-notify-add-watch'.
 If it is registered in `file-notify-descriptors', a stopped event is sent."
-  (let* ((desc (if (consp descriptor) (car descriptor) descriptor))
-         (registered (gethash desc file-notify-descriptors))
-         (file (if (consp descriptor) (cdr descriptor) (cl-caadr registered)))
-         (dir (car registered)))
-
-    (when (consp registered)
-      ;; Send `stopped' event.
-      (when (consp (assoc file (cdr registered)))
+  (when-let (watch (gethash descriptor file-notify-descriptors))
+    ;; Send `stopped' event.
+    (unwind-protect
         (funcall
-         (cdr (assoc file (cdr registered)))
-         `(,descriptor stopped ,(if file (expand-file-name file dir) dir))))
-
-      ;; Modify `file-notify-descriptors'.
-      (if (not file)
-          (remhash desc file-notify-descriptors)
-        (setcdr registered
-                (delete (assoc file (cdr registered)) (cdr registered)))
-        (if (null (cdr registered))
-            (remhash desc file-notify-descriptors)
-          (puthash desc registered file-notify-descriptors))))))
+         (file-notify--watch-callback watch)
+         `(,descriptor stopped ,(file-notify--watch-absolute-filename watch)))
+      (remhash descriptor file-notify-descriptors))))
 
 ;; This function is used by `inotify', `kqueue', `gfilenotify' and
 ;; `w32notify' events.
@@ -88,7 +91,8 @@ If EVENT is a filewatch event, call its callback.  It has the format
 Otherwise, signal a `file-notify-error'."
   (interactive "e")
   ;;(message "file-notify-handle-event %S" event)
-  (if (and (eq (car event) 'file-notify)
+  (if (and (consp event)
+           (eq (car event) 'file-notify)
            (>= (length event) 3))
       (funcall (nth 2 event) (nth 1 event))
     (signal 'file-notify-error
@@ -96,33 +100,32 @@ Otherwise, signal a `file-notify-error'."
 
 ;; Needed for `inotify' and `w32notify'.  In the latter case, COOKIE is nil.
 (defvar file-notify--pending-event nil
-  "A pending file notification events for a future `renamed' action.
+  "A pending file notification event for a future `renamed' action.
 It is a form ((DESCRIPTOR ACTION FILE [FILE1-OR-COOKIE]) CALLBACK).")
 
 (defun file-notify--event-watched-file (event)
   "Return file or directory being watched.
 Could be different from the directory watched by the backend library."
-  (let* ((desc (if (consp (car event)) (caar event) (car event)))
-         (registered (gethash desc file-notify-descriptors))
-         (file (if (consp (car event)) (cdar event) (cl-caadr registered)))
-         (dir (car registered)))
-    (if file (expand-file-name file dir) dir)))
+  (when-let (watch (gethash (car event) file-notify-descriptors))
+    (file-notify--watch-absolute-filename watch)))
 
 (defun file-notify--event-file-name (event)
   "Return file name of file notification event, or nil."
-  (directory-file-name
-   (expand-file-name
-    (or  (and (stringp (nth 2 event)) (nth 2 event)) "")
-    (car (gethash (car event) file-notify-descriptors)))))
+  (when-let (watch (gethash (car event) file-notify-descriptors))
+    (directory-file-name
+     (expand-file-name
+      (or  (and (stringp (nth 2 event)) (nth 2 event)) "")
+      (file-notify--watch-directory watch)))))
 
 ;; Only `gfilenotify' could return two file names.
 (defun file-notify--event-file1-name (event)
   "Return second file name of file notification event, or nil.
 This is available in case a file has been moved."
-  (and (stringp (nth 3 event))
-       (directory-file-name
-        (expand-file-name
-         (nth 3 event) (car (gethash (car event) file-notify-descriptors))))))
+  (when-let (watch (gethash (car event) file-notify-descriptors))
+    (and (stringp (nth 3 event))
+         (directory-file-name
+          (expand-file-name
+           (nth 3 event) (file-notify--watch-directory watch))))))
 
 ;; Cookies are offered by `inotify' only.
 (defun file-notify--event-cookie (event)
@@ -130,21 +133,6 @@ This is available in case a file has been moved."
 This is available in case a file has been moved."
   (nth 3 event))
 
-;; `inotify' returns the same descriptor when the file (directory)
-;; uses the same inode.  We want to distinguish, and apply a virtual
-;; descriptor which make the difference.
-(defun file-notify--descriptor (desc file)
-  "Return the descriptor to be used in `file-notify-*-watch'.
-For `gfilenotify' and `w32notify' it is the same descriptor as
-used in the low-level file notification package."
-  (if (and (natnump desc) (eq file-notify--library 'inotify))
-      (cons desc
-            (and (stringp file)
-                 (car (assoc
-                       (file-name-nondirectory file)
-                       (gethash desc file-notify-descriptors)))))
-    desc))
-
 ;; The callback function used to map between specific flags of the
 ;; respective file notifications, and the ones we return.
 (defun file-notify-callback (event)
@@ -152,138 +140,123 @@ used in the low-level file notification package."
 EVENT is the cadr of the event in `file-notify-handle-event'
 \(DESCRIPTOR ACTIONS FILE [FILE1-OR-COOKIE])."
   (let* ((desc (car event))
-         (registered (gethash desc file-notify-descriptors))
+         (watch (gethash desc file-notify-descriptors))
          (actions (nth 1 event))
          (file (file-notify--event-file-name event))
-         file1 callback pending-event stopped)
+         file1 pending-event stopped)
 
     ;; Make actions a list.
     (unless (consp actions) (setq actions (cons actions nil)))
 
-    ;; Loop over registered entries.  In fact, more than one entry
-    ;; happens only for `inotify'.
-    (dolist (entry (cdr registered))
-
-      ;; Check, that event is meant for us.
-      (unless (setq callback (cdr entry))
-        (setq actions nil))
-
+    (when watch
       ;; Loop over actions.  In fact, more than one action happens only
       ;; for `inotify' and `kqueue'.
-      (dolist (action actions)
-
-        ;; Send pending event, if it doesn't match.
-        (when (and file-notify--pending-event
-                   ;; The cookie doesn't match.
-                   (not (eq (file-notify--event-cookie
-                             (car file-notify--pending-event))
-                            (file-notify--event-cookie event)))
-                   (or
-                    ;; inotify.
-                    (and (eq (nth 1 (car file-notify--pending-event))
-                             'moved-from)
-                         (not (eq action 'moved-to)))
-                    ;; w32notify.
-                    (and (eq (nth 1 (car file-notify--pending-event))
-                             'renamed-from)
-                         (not (eq action 'renamed-to)))))
-          (setq pending-event file-notify--pending-event
-                file-notify--pending-event nil)
-          (setcar (cdar pending-event) 'deleted))
-
-        ;; Map action.  We ignore all events which cannot be mapped.
-        (setq action
-              (cond
-               ((memq action
-                      '(attribute-changed changed created deleted renamed))
-                action)
-               ((memq action '(moved rename))
-                ;; The kqueue rename event does not return file1 in
-                ;; case a file monitor is established.
-                (if (setq file1 (file-notify--event-file1-name event))
-                    'renamed 'deleted))
-               ((eq action 'ignored)
-                (setq stopped t actions nil))
-               ((memq action '(attrib link)) 'attribute-changed)
-               ((memq action '(create added)) 'created)
-               ((memq action '(modify modified write)) 'changed)
-               ((memq action '(delete delete-self move-self removed)) 'deleted)
-               ;; Make the event pending.
-               ((memq action '(moved-from renamed-from))
-                (setq file-notify--pending-event
-                      `((,desc ,action ,file ,(file-notify--event-cookie event))
-                        ,callback))
-                nil)
-               ;; Look for pending event.
-               ((memq action '(moved-to renamed-to))
-                (if (null file-notify--pending-event)
-                    'created
-                  (setq file1 file
-                        file (file-notify--event-file-name
-                              (car file-notify--pending-event)))
-                  ;; If the source is handled by another watch, we
-                  ;; must fire the rename event there as well.
-                  (when (not (equal (file-notify--descriptor desc file1)
-                                    (file-notify--descriptor
-                                     (caar file-notify--pending-event)
-                                     (file-notify--event-file-name
-                                      file-notify--pending-event))))
-                    (setq pending-event
-                          `((,(caar file-notify--pending-event)
-                             renamed ,file ,file1)
-                            ,(cadr file-notify--pending-event))))
-                  (setq file-notify--pending-event nil)
-                  'renamed))))
-
-        ;; Apply pending callback.
-        (when pending-event
-          (setcar
-           (car pending-event)
-           (file-notify--descriptor
-            (caar pending-event)
-            (file-notify--event-file-name file-notify--pending-event)))
-          (funcall (cadr pending-event) (car pending-event))
-          (setq pending-event nil))
-
-        ;; Apply callback.
-        (when (and action
-                   (or
-                    ;; If there is no relative file name for that watch,
-                    ;; we watch the whole directory.
-                    (null (nth 0 entry))
-                    ;; File matches.
-                    (string-equal
-                     (nth 0 entry) (file-name-nondirectory file))
-                    ;; Directory matches.
-                    (string-equal
-                     (file-name-nondirectory file)
-                     (file-name-nondirectory (car registered)))
-                    ;; File1 matches.
-                    (and (stringp file1)
-                         (string-equal
-                          (nth 0 entry) (file-name-nondirectory file1)))))
-          ;;(message
-           ;;"file-notify-callback %S %S %S %S %S"
-           ;;(file-notify--descriptor desc (car entry))
-           ;;action file file1 registered)
-          (if file1
-              (funcall
-               callback
-               `(,(file-notify--descriptor desc (car entry))
-                 ,action ,file ,file1))
-            (funcall
-             callback
-             `(,(file-notify--descriptor desc (car entry)) ,action ,file))))
-
-        ;; Send `stopped' event.
-        (when (or stopped
-                  (and (memq action '(deleted renamed))
-                       ;; Not, when a file is backed up.
-                       (not (and (stringp file1) (backup-file-name-p file1)))
-                       ;; Watched file or directory is concerned.
-                       (string-equal
-                        file (file-notify--event-watched-file event))))
-          (file-notify-rm-watch (file-notify--descriptor desc (car entry))))))))
+      (while actions
+        (let ((action (pop actions)))
+          ;; Send pending event, if it doesn't match.
+          (when (and file-notify--pending-event
+                     ;; The cookie doesn't match.
+                     (not (equal (file-notify--event-cookie
+                                  (car file-notify--pending-event))
+                                 (file-notify--event-cookie event)))
+                     (or
+                      ;; inotify.
+                      (and (eq (nth 1 (car file-notify--pending-event))
+                               'moved-from)
+                           (not (eq action 'moved-to)))
+                      ;; w32notify.
+                      (and (eq (nth 1 (car file-notify--pending-event))
+                               'renamed-from)
+                           (not (eq action 'renamed-to)))))
+            (setq pending-event file-notify--pending-event
+                  file-notify--pending-event nil)
+            (setcar (cdar pending-event) 'deleted))
+
+          ;; Map action.  We ignore all events which cannot be mapped.
+          (setq action
+                (cond
+                 ((memq action
+                        '(attribute-changed changed created deleted renamed))
+                  action)
+                 ((memq action '(moved rename))
+                  ;; The kqueue rename event does not return file1 in
+                  ;; case a file monitor is established.
+                  (if (setq file1 (file-notify--event-file1-name event))
+                      'renamed 'deleted))
+                 ((eq action 'ignored)
+                  (setq stopped t actions nil))
+                 ((memq action '(attrib link)) 'attribute-changed)
+                 ((memq action '(create added)) 'created)
+                 ((memq action '(modify modified write)) 'changed)
+                 ((memq action
+                        '(delete delete-self move-self removed)) 'deleted)
+                 ;; Make the event pending.
+                 ((memq action '(moved-from renamed-from))
+                  (setq file-notify--pending-event
+                        `((,desc ,action ,file
+                           ,(file-notify--event-cookie event))
+                          ,(file-notify--watch-callback watch)))
+                  nil)
+                 ;; Look for pending event.
+                 ((memq action '(moved-to renamed-to))
+                  (if (null file-notify--pending-event)
+                      'created
+                    (setq file1 file
+                          file (file-notify--event-file-name
+                                (car file-notify--pending-event)))
+                    ;; If the source is handled by another watch, we
+                    ;; must fire the rename event there as well.
+                    (unless (equal desc (caar file-notify--pending-event))
+                      (setq pending-event
+                            `((,(caar file-notify--pending-event)
+                               renamed ,file ,file1)
+                              ,(cadr file-notify--pending-event))))
+                    (setq file-notify--pending-event nil)
+                    'renamed))))
+
+          ;; Apply pending callback.
+          (when pending-event
+            (funcall (cadr pending-event) (car pending-event))
+            (setq pending-event nil))
+
+          ;; Apply callback.
+          (when (and action
+                     (or
+                      ;; If there is no relative file name for that
+                      ;; watch, we watch the whole directory.
+                      (null (file-notify--watch-filename watch))
+                      ;; File matches.
+                      (string-equal
+                       (file-notify--watch-filename watch)
+                       (file-name-nondirectory file))
+                      ;; Directory matches.
+                      (string-equal
+                       (file-name-nondirectory file)
+                       (file-name-nondirectory
+                        (file-notify--watch-directory watch)))
+                      ;; File1 matches.
+                      (and (stringp file1)
+                           (string-equal
+                            (file-notify--watch-filename watch)
+                            (file-name-nondirectory file1)))))
+            ;;(message
+            ;;"file-notify-callback %S %S %S %S %S"
+            ;;desc action file file1 watch)
+            (if file1
+                (funcall (file-notify--watch-callback watch)
+                         `(,desc ,action ,file ,file1))
+              (funcall (file-notify--watch-callback watch)
+                       `(,desc  ,action ,file))))
+
+          ;; Send `stopped' event.
+          (when (or stopped
+                    (and (memq action '(deleted renamed))
+                         ;; Not, when a file is backed up.
+                         (not (and (stringp file1) (backup-file-name-p file1)))
+                         ;; Watched file or directory is concerned.
+                         (string-equal
+                          file (file-notify--event-watched-file event))))
+            (file-notify-rm-watch desc)))))))
 
 ;; `kqueue', `gfilenotify' and `w32notify' return a unique descriptor
 ;; for every `file-notify-add-watch', while `inotify' returns a unique
@@ -339,7 +312,7 @@ FILE is the name of the file whose event is being reported."
                (if (file-directory-p file)
                    file
                  (file-name-directory file))))
-        desc func l-flags registered entry)
+         desc func l-flags)
 
     (unless (file-directory-p dir)
       (signal 'file-notify-error `("Directory does not exist" ,dir)))
@@ -347,13 +320,7 @@ FILE is the name of the file whose event is being reported."
     (if handler
         ;; A file name handler could exist even if there is no local
         ;; file notification support.
-        (setq desc (funcall
-                    handler 'file-notify-add-watch
-                    ;; kqueue does not report file changes in
-                    ;; directory monitor.  So we must watch the file
-                    ;; itself.
-                    (if (eq file-notify--library 'kqueue) file dir)
-                    flags callback))
+        (setq desc (funcall handler 'file-notify-add-watch dir flags callback))
 
       ;; Check, whether Emacs has been compiled with file notification
       ;; support.
@@ -391,70 +358,52 @@ FILE is the name of the file whose event is being reported."
 
       ;; Call low-level function.
       (setq desc (funcall
+                  ;; kqueue does not report file changes in directory
+                  ;; monitor.  So we must watch the file itself.
                   func (if (eq file-notify--library 'kqueue) file dir)
                   l-flags 'file-notify-callback)))
 
     ;; Modify `file-notify-descriptors'.
-    (setq file (unless (file-directory-p file) (file-name-nondirectory file))
-          desc (if (consp desc) (car desc) desc)
-          registered (gethash desc file-notify-descriptors)
-          entry `(,file . ,callback))
-    (unless (member entry (cdr registered))
-      (puthash desc `(,dir ,entry . ,(cdr registered)) file-notify-descriptors))
-
+    (let ((watch (file-notify--watch-make
+                  dir
+                  (unless (file-directory-p file) (file-name-nondirectory file))
+                  callback)))
+      (puthash desc watch file-notify-descriptors))
     ;; Return descriptor.
-    (file-notify--descriptor desc file)))
+    desc))
 
 (defun file-notify-rm-watch (descriptor)
   "Remove an existing watch specified by its DESCRIPTOR.
 DESCRIPTOR should be an object returned by `file-notify-add-watch'."
-  (let* ((desc (if (consp descriptor) (car descriptor) descriptor))
-         (file (if (consp descriptor) (cdr descriptor)))
-         (registered (gethash desc file-notify-descriptors))
-         (dir (car registered))
-         (handler (and (stringp dir)
-                       (find-file-name-handler dir 'file-notify-rm-watch))))
-
-    (when (stringp dir)
-      ;; Call low-level function.
-      (when (or (not file)
-                (and (= (length (cdr registered)) 1)
-                     (assoc file (cdr registered))))
-        (condition-case nil
-            (if handler
-                ;; A file name handler could exist even if there is no local
-                ;; file notification support.
-                (funcall handler 'file-notify-rm-watch descriptor)
-
-              (funcall
-               (cond
-                ((eq file-notify--library 'inotify) 'inotify-rm-watch)
-                ((eq file-notify--library 'kqueue) 'kqueue-rm-watch)
-                ((eq file-notify--library 'gfilenotify) 'gfile-rm-watch)
-                ((eq file-notify--library 'w32notify) 'w32notify-rm-watch))
-               desc))
-          (file-notify-error nil)))
-
-      ;; Modify `file-notify-descriptors'.
-      (file-notify--rm-descriptor descriptor))))
+  (when-let (watch (gethash descriptor file-notify-descriptors))
+    (let ((handler (find-file-name-handler
+                    (file-notify--watch-directory watch)
+                    'file-notify-rm-watch)))
+      (condition-case nil
+          (if handler
+              ;; A file name handler could exist even if there is no
+              ;; local file notification support.
+              (funcall handler 'file-notify-rm-watch descriptor)
+
+            (funcall
+             (cond
+              ((eq file-notify--library 'inotify) 'inotify-rm-watch)
+              ((eq file-notify--library 'kqueue) 'kqueue-rm-watch)
+              ((eq file-notify--library 'gfilenotify) 'gfile-rm-watch)
+              ((eq file-notify--library 'w32notify) 'w32notify-rm-watch))
+             descriptor))
+        (file-notify-error nil)))
+    ;; Modify `file-notify-descriptors'.
+    (file-notify--rm-descriptor descriptor)))
 
 (defun file-notify-valid-p (descriptor)
   "Check a watch specified by its DESCRIPTOR.
 DESCRIPTOR should be an object returned by `file-notify-add-watch'."
-  (let* ((desc (if (consp descriptor) (car descriptor) descriptor))
-         (file (if (consp descriptor) (cdr descriptor)))
-         (registered (gethash desc file-notify-descriptors))
-         (dir (car registered))
-         handler)
-
-    (when (stringp dir)
-      (setq handler (find-file-name-handler dir 'file-notify-valid-p))
-
-      (and (or ;; It is a directory.
-               (not file)
-               ;; The file is registered.
-               (assoc file (cdr registered)))
-           (if handler
+  (when-let (watch (gethash descriptor file-notify-descriptors))
+    (let ((handler (find-file-name-handler
+                    (file-notify--watch-directory watch)
+                    'file-notify-valid-p)))
+      (and (if handler
                ;; A file name handler could exist even if there is no
                ;; local file notification support.
                (funcall handler 'file-notify-valid-p descriptor)
@@ -464,9 +413,19 @@ DESCRIPTOR should be an object returned by `file-notify-add-watch'."
                ((eq file-notify--library 'kqueue) 'kqueue-valid-p)
                ((eq file-notify--library 'gfilenotify) 'gfile-valid-p)
                ((eq file-notify--library 'w32notify) 'w32notify-valid-p))
-              desc))
+              descriptor))
            t))))
 
+
+;; TODO:
+;; * Watching a /dir/file may receive events for dir.
+;;   (This may be the desired behaviour.)
+;; * Watching a file in a already watched directory
+;;   If the file is created and *then* a watch is added to that file, the
+;;   watch might receive events which occurred prior to it being created,
+;;   due to the way events are propagated during idle time.  Note: This
+;;   may be perfectly acceptable.
+
 ;; The end:
 (provide 'filenotify)
 
diff --git a/lisp/files-x.el b/lisp/files-x.el
index a0cad708425..b7c6f51e658 100644
--- a/lisp/files-x.el
+++ b/lisp/files-x.el
@@ -585,7 +585,7 @@ Return a new ordered plist list containing only property names from PROPERTIES."
    nil
    (mapcar
     (lambda (property)
-      (when (plist-member criteria property)
+      (when (and (plist-member criteria property) (plist-get criteria property))
         (list property (plist-get criteria property))))
     properties)))
 
@@ -606,12 +606,10 @@ using this connection, see `connection-local-criteria-alist'."
 
 ;;;###autoload
 (defun connection-local-set-profiles (criteria &rest profiles)
-  "Add PROFILES for remote servers.
-CRITERIA is either a regular expression identifying a remote
-server, or a function with one argument IDENTIFICATION, which
-returns non-nil when a remote server shall apply PROFILE's
-variables.  If CRITERIA is nil, it always applies.
-PROFILES are the names of a connection profile (a symbol).
+  "Add PROFILES for CRITERIA.
+CRITERIA is a plist identifying a connection and the application
+using this connection, see `connection-local-criteria-alist'.
+PROFILES are the names of connection profiles (a symbol).
 
 When a connection to a remote server is opened and CRITERIA
 matches to that server, the connection-local variables from
@@ -678,7 +676,7 @@ will not be changed."
 ;;;###autoload
 (defmacro with-connection-local-profiles (profiles &rest body)
   "Apply connection-local variables according to PROFILES in current buffer.
-Execute BODY, and unwind connection local variables."
+Execute BODY, and unwind connection-local variables."
   (declare (indent 1) (debug t))
   `(let ((enable-connection-local-variables t)
          (old-buffer-local-variables (buffer-local-variables))
diff --git a/lisp/files.el b/lisp/files.el
index 0a023a88b10..b4872e46b01 100644
--- a/lisp/files.el
+++ b/lisp/files.el
@@ -279,8 +279,13 @@ The value `never' means do not make them."
                  (const :tag "If existing" nil)
                  (other :tag "Always" t))
   :group 'backup)
+
+(defun version-control-safe-local-p (x)
+  "Return whether X is safe as local value for `version-control'."
+  (or (booleanp x) (equal x 'never)))
+
 (put 'version-control 'safe-local-variable
-     (lambda (x) (or (booleanp x) (equal x 'never))))
+     #'version-control-safe-local-p)
 
 (defcustom dired-kept-versions 2
   "When cleaning directory, number of versions to keep."
diff --git a/lisp/gnus/gnus-start.el b/lisp/gnus/gnus-start.el
index be46339cd38..90f3cb48c27 100644
--- a/lisp/gnus/gnus-start.el
+++ b/lisp/gnus/gnus-start.el
@@ -3196,7 +3196,7 @@ If this variable is nil, don't do anything."
 
 (defun gnus-display-time-event-handler ()
   (if (and (fboundp 'display-time-event-handler)
-           (gnus-boundp 'display-time-timer))
+           (bound-and-true-p display-time-timer))
       (display-time-event-handler)))
 
 (defun gnus-check-reasonable-setup ()
diff --git a/lisp/gnus/gnus-util.el b/lisp/gnus/gnus-util.el
index 20eceb58edd..b509d8ad448 100644
--- a/lisp/gnus/gnus-util.el
+++ b/lisp/gnus/gnus-util.el
@@ -84,11 +84,6 @@ This is a compatibility function for different Emacsen."
   (declare (obsolete replace-regexp-in-string "26.1"))
   (replace-regexp-in-string regexp newtext string nil literal))
 
-(defun gnus-boundp (variable)
-  "Return non-nil if VARIABLE is bound and non-nil."
-  (and (boundp variable)
-       (symbol-value variable)))
-
 (defmacro gnus-eval-in-buffer-window (buffer &rest forms)
   "Pop to BUFFER, evaluate FORMS, and then return to the original window."
   (let ((tempvar (make-symbol "GnusStartBufferWindow"))
diff --git a/lisp/help.el b/lisp/help.el
index d3aaa1e251d..26be3b0e07f 100644
--- a/lisp/help.el
+++ b/lisp/help.el
@@ -1419,7 +1419,7 @@ ARGLIST can also be t or a string of the form \"(FUN ARG1 ARG2 ...)\"."
 
 (defun help-function-arglist (def &optional preserve-names)
   "Return a formal argument list for the function DEF.
-IF PRESERVE-NAMES is non-nil, return a formal arglist that uses
+If PRESERVE-NAMES is non-nil, return a formal arglist that uses
 the same names as used in the original source code, when possible."
   ;; Handle symbols aliased to other symbols.
   (if (and (symbolp def) (fboundp def)) (setq def (indirect-function def)))
diff --git a/lisp/ibuffer.el b/lisp/ibuffer.el
index 66916b2bca1..c83c21315a1 100644
--- a/lisp/ibuffer.el
+++ b/lisp/ibuffer.el
@@ -1689,7 +1689,7 @@ If point is on a group name, this function operates on that group."
                     ;; generate a call to the column function.
                     (ibuffer-aif (assq sym ibuffer-inline-columns)
                         (nth 1 it)
-                      `(,sym buffer mark)))
+                      `(or (,sym buffer mark) "")))
                    ;; You're not expected to understand this.  Hell, I
                    ;; don't even understand it, and I wrote it five
                    ;; minutes ago.
diff --git a/lisp/info.el b/lisp/info.el
index 8dc85f48a43..a6bab290a72 100644
--- a/lisp/info.el
+++ b/lisp/info.el
@@ -1998,19 +1998,20 @@ If DIRECTION is `backward', search in the reverse direction."
                   Info-isearch-initial-node
                   bound
                   (and found (> found opoint-min) (< found opoint-max)))
-        (signal 'search-failed (list regexp "end of node")))
+        (user-error "Search failed: `%s' (end of node)" regexp))
 
       ;; If no subfiles, give error now.
       (unless (or found Info-current-subfile)
         (if isearch-mode
-            (signal 'search-failed (list regexp "end of manual"))
+            (user-error "Search failed: `%s' (end of manual)" regexp)
           (let ((search-spaces-regexp Info-search-whitespace-regexp))
-            (if backward
-                (re-search-backward regexp)
-              (re-search-forward regexp)))))
+            (unless (if backward
+                        (re-search-backward regexp nil t)
+                      (re-search-forward regexp nil t))
+              (user-error "Search failed: `%s'" regexp)))))
 
       (if (and bound (not found))
-          (signal 'search-failed (list regexp)))
+          (user-error "Search failed: `%s'" regexp))
 
       (unless (or found bound)
         (unwind-protect
@@ -2054,9 +2055,8 @@ If DIRECTION is `backward', search in the reverse direction."
                     (setq list nil)))
               (if found
                   (message "")
-                (signal 'search-failed (if isearch-mode
-                                           (list regexp "end of manual")
-                                         (list regexp)))))
+                (user-error "Search failed: `%s'%s"
+                            regexp (if isearch-mode " (end of manual)" ""))))
           (if (not found)
               (progn (Info-read-subfile osubfile)
                      (goto-char opoint)
@@ -2699,7 +2699,8 @@ Because of ambiguities, this should be concatenated with something like
             (orignode Info-current-node)
             nextnode)
         (goto-char (point-min))
-        (search-forward "\n* Menu:")
+        (unless (search-forward "\n* Menu:" nil t)
+          (user-error "No menu in this node"))
         (cond
          ((eq (car-safe action) 'boundaries) nil)
          ((eq action 'lambda)
@@ -5237,9 +5238,6 @@ BUFFER is the buffer speedbar is requesting buttons for."
       (erase-buffer))
   (Info-speedbar-hierarchy-buttons nil 0))
 
-;; FIXME: Really?  Why here?
-(add-to-list 'debug-ignored-errors 'search-failed)
-
 ;;;;  Desktop support
 
 (defun Info-desktop-buffer-misc-data (_desktop-dirname)
diff --git a/lisp/ldefs-boot.el b/lisp/ldefs-boot.el
index 01a3e5d1506..411969a5420 100644
--- a/lisp/ldefs-boot.el
+++ b/lisp/ldefs-boot.el
@@ -5224,7 +5224,9 @@ You might also use mode hooks to specify it in certain modes, like this:
                 (concat \"make -k \"
                         (if buffer-file-name
                           (shell-quote-argument
-                            (file-name-sans-extension buffer-file-name))))))))")
+                            (file-name-sans-extension buffer-file-name))))))))
+
+It's often useful to leave a space at the end of the value.")
 
 (custom-autoload 'compile-command "compile" t)
 (put 'compile-command 'safe-local-variable (lambda (a) (and (stringp a) (or (not (boundp 'compilation-read-command)) compilation-read-command))))
@@ -12465,12 +12467,10 @@ Copy directory-local variables to the -*- line.
 Non-nil means enable use of connection-local variables.")
 
 (autoload 'connection-local-set-profiles "files-x" "\
-Add PROFILES for remote servers.
-CRITERIA is either a regular expression identifying a remote
-server, or a function with one argument IDENTIFICATION, which
-returns non-nil when a remote server shall apply PROFILE's
-variables.  If CRITERIA is nil, it always applies.
-PROFILES are the names of a connection profile (a symbol).
+Add PROFILES for CRITERIA.
+CRITERIA is a plist identifying a connection and the application
+using this connection, see `connection-local-criteria-alist'.
+PROFILES are the names of connection profiles (a symbol).
 
 When a connection to a remote server is opened and CRITERIA
 matches to that server, the connection-local variables from
@@ -12504,7 +12504,7 @@ will not be changed.
 
 (autoload 'with-connection-local-profiles "files-x" "\
 Apply connection-local variables according to PROFILES in current buffer.
-Execute BODY, and unwind connection local variables.
+Execute BODY, and unwind connection-local variables.
 
 \(fn PROFILES &rest BODY)" nil t)
 
@@ -15857,14 +15857,6 @@ This discards the buffer's undo information.
 
 ;;;***
 
-;;;### (autoloads "actual autoloads are elsewhere" "hfy-cmap" "hfy-cmap.el"
-;;;;;;  (0 0 0 0))
-;;; Generated autoloads from hfy-cmap.el
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "hfy-cmap" '("hfy-" "htmlfontify-unload-rgb-file")))
-
-;;;***
-
 ;;;### (autoloads nil "hi-lock" "hi-lock.el" (0 0 0 0))
 ;;; Generated autoloads from hi-lock.el
 
@@ -21868,7 +21860,7 @@ QUALITY can be:
   `approximate', in which case we may cut some corners to avoid
     excessive work.
   `exact', in which case we may end up re-(en/de)coding a large
-    part of the file/buffer.
+    part of the file/buffer, this can be expensive and slow.
   nil, in which case we may return nil rather than an approximation.
 
 \(fn BYTE &optional QUALITY CODING-SYSTEM)" nil nil)
@@ -21882,7 +21874,7 @@ QUALITY can be:
   `approximate', in which case we may cut some corners to avoid
     excessive work.
   `exact', in which case we may end up re-(en/de)coding a large
-    part of the file/buffer.
+    part of the file/buffer, this can be expensive and slow.
   nil, in which case we may return nil rather than an approximation.
 
 \(fn POSITION &optional QUALITY CODING-SYSTEM)" nil nil)
@@ -33879,7 +33871,7 @@ It can have the following values:
 
 (custom-autoload 'tramp-syntax "tramp" t)
 
-(defconst tramp-file-name-regexp-unified (if (memq system-type '(cygwin windows-nt)) "\\`/\\(\\[.*\\]\\|[^/|:]\\{2,\\}[^/|]*\\):" "\\`/[^/|:][^/|]*:") "\
+(defconst tramp-file-name-regexp-unified "\\`/.+:.*:" "\
 Value for `tramp-file-name-regexp' for unified remoting.
 See `tramp-file-name-structure' for more explanations.
 
@@ -33889,23 +33881,23 @@ On W32 systems, the volume letter must be ignored.")
 Value for `tramp-file-name-regexp' for separate remoting.
 See `tramp-file-name-structure' for more explanations.")
 
-(defvar tramp-file-name-regexp (cond ((equal tramp-syntax 'ftp) tramp-file-name-regexp-unified) ((equal tramp-syntax 'sep) tramp-file-name-regexp-separate) (t (error "Wrong `tramp-syntax' defined"))) "\
+(defvar tramp-file-name-regexp (cond ((eq tramp-syntax 'ftp) tramp-file-name-regexp-unified) ((eq tramp-syntax 'sep) tramp-file-name-regexp-separate) (t (error "Wrong `tramp-syntax' defined"))) "\
 Regular expression matching file names handled by Tramp.
 This regexp should match Tramp file names but no other file
 names.  When calling `tramp-register-file-name-handlers', the
 initial value is overwritten by the car of `tramp-file-name-structure'.")
 
-(defconst tramp-completion-file-name-regexp-unified (if (memq system-type '(cygwin windows-nt)) "\\`/[^/]\\{2,\\}\\'" "\\`/[^/]*\\'") "\
+(defconst tramp-completion-file-name-regexp-unified (concat "\\`/\\(" "\\([^/|:]+:[^/|:]*|\\)*" (if (memq system-type '(cygwin windows-nt)) "\\(-\\|[^/|:]\\{2,\\}\\)" "[^/|:]+") "\\(:[^/|:]*\\)?" "\\)?\\'") "\
 Value for `tramp-completion-file-name-regexp' for unified remoting.
 See `tramp-file-name-structure' for more explanations.
 
 On W32 systems, the volume letter must be ignored.")
 
-(defconst tramp-completion-file-name-regexp-separate "\\`/\\([[][^]]*\\)?\\'" "\
+(defconst tramp-completion-file-name-regexp-separate "\\`/\\[\\([^]]*\\)?\\'" "\
 Value for `tramp-completion-file-name-regexp' for separate remoting.
 See `tramp-file-name-structure' for more explanations.")
 
-(defconst tramp-completion-file-name-regexp (cond ((equal tramp-syntax 'ftp) tramp-completion-file-name-regexp-unified) ((equal tramp-syntax 'sep) tramp-completion-file-name-regexp-separate) (t (error "Wrong `tramp-syntax' defined"))) "\
+(defconst tramp-completion-file-name-regexp (cond ((eq tramp-syntax 'ftp) tramp-completion-file-name-regexp-unified) ((eq tramp-syntax 'sep) tramp-completion-file-name-regexp-separate) (t (error "Wrong `tramp-syntax' defined"))) "\
 Regular expression matching file names handled by Tramp completion.
 This regexp should match partial Tramp file names only.
 
@@ -33916,20 +33908,31 @@ updated after changing this variable.
 
 Also see `tramp-file-name-structure'.")
 
-(defun tramp-completion-run-real-handler (operation args) "\
-Invoke `tramp-file-name-handler' for OPERATION.
+(defconst tramp-completion-file-name-handler-alist '((file-name-all-completions . tramp-completion-handle-file-name-all-completions) (file-name-completion . tramp-completion-handle-file-name-completion)) "\
+Alist of completion handler functions.
+Used for file names matching `tramp-completion-file-name-regexp'.
+Operations not mentioned here will be handled by Tramp's file
+name handler functions, or the normal Emacs functions.")
+
+(defun tramp-run-real-handler (operation args) "\
+Invoke normal file name handler for OPERATION.
 First arg specifies the OPERATION, second arg is a list of arguments to
-pass to the OPERATION." (let* ((inhibit-file-name-handlers (\` (tramp-completion-file-name-handler cygwin-mount-name-hook-function cygwin-mount-map-drive-hook-function \, (and (eq inhibit-file-name-operation operation) inhibit-file-name-handlers)))) (inhibit-file-name-operation operation)) (apply operation args)))
-(defun tramp-completion-file-name-handler (operation &rest args)
- (if (tramp-completion-mode-p)
-     (apply 'tramp-autoload-file-name-handler operation args)
-   (tramp-completion-run-real-handler operation args)))
+pass to the OPERATION." (let* ((inhibit-file-name-handlers (\` (tramp-file-name-handler tramp-vc-file-name-handler tramp-completion-file-name-handler cygwin-mount-name-hook-function cygwin-mount-map-drive-hook-function \, (and (eq inhibit-file-name-operation operation) inhibit-file-name-handlers)))) (inhibit-file-name-operation operation)) (apply operation args)))
 
-(defun tramp-autoload-file-name-handler (operation &rest args) "\
-Load Tramp file name handler, and perform OPERATION." (if (and (not (and (stringp (car args)) (string-equal (car args) "/"))) (let ((default-directory temporary-file-directory)) (and (null load-in-progress) (load "tramp" (quote noerror) (quote nomessage))))) (apply operation args) (tramp-completion-run-real-handler operation args)))
+(autoload 'tramp-file-name-handler "tramp" "\
+Invoke Tramp file name handler.
+Falls back to normal file name handler if no Tramp file name handler exists.
+
+\(fn OPERATION &rest ARGS)" nil nil)
+
+(autoload 'tramp-completion-file-name-handler "tramp" "\
+Invoke Tramp file name completion handler.
+Falls back to normal file name handler if no Tramp file name handler exists.
+
+\(fn OPERATION &rest ARGS)" nil nil)
 
 (defun tramp-register-autoload-file-name-handlers nil "\
-Add Tramp file name handlers to `file-name-handler-alist' during autoload." (add-to-list (quote file-name-handler-alist) (cons tramp-file-name-regexp (quote tramp-autoload-file-name-handler))) (put (quote tramp-autoload-file-name-handler) (quote safe-magic) t) (add-to-list (quote file-name-handler-alist) (cons tramp-completion-file-name-regexp (quote tramp-completion-file-name-handler))) (put (quote tramp-completion-file-name-handler) (quote safe-magic) t))
+Add Tramp file name handlers to `file-name-handler-alist' during autoload." (add-to-list (quote file-name-handler-alist) (cons tramp-file-name-regexp (quote tramp-file-name-handler))) (put (quote tramp-file-name-handler) (quote safe-magic) t) (put (quote tramp-file-name-handler) (quote operations) (quote (file-name-all-completions file-name-completion file-remote-p))) (add-to-list (quote file-name-handler-alist) (cons tramp-completion-file-name-regexp (quote tramp-completion-file-name-handler))) (put (quote tramp-completion-file-name-handler) (quote safe-magic) t) (put (quote tramp-completion-file-name-handler) (quote operations) (mapcar (quote car) tramp-completion-file-name-handler-alist)))
 
 (tramp-register-autoload-file-name-handlers)
 
@@ -33939,15 +33942,7 @@ Unload Tramp file name handlers from `file-name-handler-alist'.
 \(fn)" nil nil)
 
 (defvar tramp-completion-mode nil "\
-If non-nil, external packages signal that they are in file name completion.
-
-This is necessary, because Tramp uses a heuristic depending on last
-input event.  This fails when external packages use other characters
-but <TAB>, <SPACE> or ?\\? for file name completion.  This variable
-should never be set globally, the intention is to let-bind it.")
-
-(defun tramp-completion-mode-p nil "\
-Check, whether method / user name / host name completion is active." (or (and (boundp (quote non-essential)) (symbol-value (quote non-essential))) tramp-completion-mode (equal last-input-event (quote tab))))
+If non-nil, external packages signal that they are in file name completion.")
 
 (autoload 'tramp-unload-tramp "tramp" "\
 Discard Tramp from loading remote files.
@@ -37759,7 +37754,7 @@ The major browsing mode used is essentially the standard Man mode.
 Choose the filename for the man page using completion, based on the
 topic selected from the directories specified in `woman-manpath' and
 `woman-path'.  The directory expansions and topics are cached for
-speed, but a non-nil interactive argument forces the caches to be
+speed.  With a prefix argument, force the caches to be
 updated (e.g. to re-interpret the current directory).
 
 Used non-interactively, arguments are optional: if given then TOPIC
@@ -38050,17 +38045,16 @@ Zone out, completely.
 ;;;***
 
 ;;;### (autoloads nil nil ("abbrev.el" "bindings.el" "buff-menu.el"
-;;;;;;  "button.el" "calc/calc-aent.el" "calc/calc-embed.el" "calc/calc-loaddefs.el"
-;;;;;;  "calc/calc-misc.el" "calc/calc-yank.el" "calendar/cal-loaddefs.el"
-;;;;;;  "calendar/diary-loaddefs.el" "calendar/hol-loaddefs.el" "case-table.el"
-;;;;;;  "cedet/ede/base.el" "cedet/ede/config.el" "cedet/ede/cpp-root.el"
-;;;;;;  "cedet/ede/custom.el" "cedet/ede/dired.el" "cedet/ede/emacs.el"
-;;;;;;  "cedet/ede/files.el" "cedet/ede/generic.el" "cedet/ede/linux.el"
-;;;;;;  "cedet/ede/loaddefs.el" "cedet/ede/locate.el" "cedet/ede/make.el"
-;;;;;;  "cedet/ede/shell.el" "cedet/ede/speedbar.el" "cedet/ede/system.el"
-;;;;;;  "cedet/ede/util.el" "cedet/semantic/analyze.el" "cedet/semantic/analyze/complete.el"
-;;;;;;  "cedet/semantic/analyze/refs.el" "cedet/semantic/bovine.el"
-;;;;;;  "cedet/semantic/bovine/c.el" "cedet/semantic/bovine/el.el"
+;;;;;;  "button.el" "calc/calc-aent.el" "calc/calc-embed.el" "calc/calc-misc.el"
+;;;;;;  "calc/calc-yank.el" "calendar/cal-loaddefs.el" "calendar/diary-loaddefs.el"
+;;;;;;  "calendar/hol-loaddefs.el" "case-table.el" "cedet/ede/base.el"
+;;;;;;  "cedet/ede/config.el" "cedet/ede/cpp-root.el" "cedet/ede/custom.el"
+;;;;;;  "cedet/ede/dired.el" "cedet/ede/emacs.el" "cedet/ede/files.el"
+;;;;;;  "cedet/ede/generic.el" "cedet/ede/linux.el" "cedet/ede/locate.el"
+;;;;;;  "cedet/ede/make.el" "cedet/ede/shell.el" "cedet/ede/speedbar.el"
+;;;;;;  "cedet/ede/system.el" "cedet/ede/util.el" "cedet/semantic/analyze.el"
+;;;;;;  "cedet/semantic/analyze/complete.el" "cedet/semantic/analyze/refs.el"
+;;;;;;  "cedet/semantic/bovine.el" "cedet/semantic/bovine/c.el" "cedet/semantic/bovine/el.el"
 ;;;;;;  "cedet/semantic/bovine/gcc.el" "cedet/semantic/bovine/make.el"
 ;;;;;;  "cedet/semantic/bovine/scm.el" "cedet/semantic/complete.el"
 ;;;;;;  "cedet/semantic/ctxt.el" "cedet/semantic/db-file.el" "cedet/semantic/db-find.el"
@@ -38071,40 +38065,38 @@ Zone out, completely.
 ;;;;;;  "cedet/semantic/find.el" "cedet/semantic/format.el" "cedet/semantic/html.el"
 ;;;;;;  "cedet/semantic/ia-sb.el" "cedet/semantic/ia.el" "cedet/semantic/idle.el"
 ;;;;;;  "cedet/semantic/imenu.el" "cedet/semantic/lex-spp.el" "cedet/semantic/lex.el"
-;;;;;;  "cedet/semantic/loaddefs.el" "cedet/semantic/mru-bookmark.el"
-;;;;;;  "cedet/semantic/scope.el" "cedet/semantic/senator.el" "cedet/semantic/sort.el"
-;;;;;;  "cedet/semantic/symref.el" "cedet/semantic/symref/cscope.el"
-;;;;;;  "cedet/semantic/symref/global.el" "cedet/semantic/symref/grep.el"
-;;;;;;  "cedet/semantic/symref/idutils.el" "cedet/semantic/symref/list.el"
-;;;;;;  "cedet/semantic/tag-file.el" "cedet/semantic/tag-ls.el" "cedet/semantic/tag-write.el"
+;;;;;;  "cedet/semantic/mru-bookmark.el" "cedet/semantic/scope.el"
+;;;;;;  "cedet/semantic/senator.el" "cedet/semantic/sort.el" "cedet/semantic/symref.el"
+;;;;;;  "cedet/semantic/symref/cscope.el" "cedet/semantic/symref/global.el"
+;;;;;;  "cedet/semantic/symref/grep.el" "cedet/semantic/symref/idutils.el"
+;;;;;;  "cedet/semantic/symref/list.el" "cedet/semantic/tag-file.el"
+;;;;;;  "cedet/semantic/tag-ls.el" "cedet/semantic/tag-write.el"
 ;;;;;;  "cedet/semantic/tag.el" "cedet/semantic/texi.el" "cedet/semantic/util-modes.el"
 ;;;;;;  "cedet/semantic/wisent/java-tags.el" "cedet/semantic/wisent/javascript.el"
 ;;;;;;  "cedet/semantic/wisent/python.el" "cedet/srecode/compile.el"
 ;;;;;;  "cedet/srecode/cpp.el" "cedet/srecode/document.el" "cedet/srecode/el.el"
 ;;;;;;  "cedet/srecode/expandproto.el" "cedet/srecode/getset.el"
-;;;;;;  "cedet/srecode/insert.el" "cedet/srecode/java.el" "cedet/srecode/loaddefs.el"
-;;;;;;  "cedet/srecode/map.el" "cedet/srecode/mode.el" "cedet/srecode/srt.el"
-;;;;;;  "cedet/srecode/template.el" "cedet/srecode/texi.el" "composite.el"
-;;;;;;  "cus-face.el" "cus-start.el" "custom.el" "dired-aux.el" "dired-loaddefs.el"
-;;;;;;  "dired-x.el" "electric.el" "emacs-lisp/backquote.el" "emacs-lisp/byte-run.el"
-;;;;;;  "emacs-lisp/cl-extra.el" "emacs-lisp/cl-loaddefs.el" "emacs-lisp/cl-macs.el"
+;;;;;;  "cedet/srecode/insert.el" "cedet/srecode/java.el" "cedet/srecode/map.el"
+;;;;;;  "cedet/srecode/mode.el" "cedet/srecode/srt.el" "cedet/srecode/template.el"
+;;;;;;  "cedet/srecode/texi.el" "composite.el" "cus-face.el" "cus-start.el"
+;;;;;;  "custom.el" "dired-aux.el" "dired-x.el" "electric.el" "emacs-lisp/backquote.el"
+;;;;;;  "emacs-lisp/byte-run.el" "emacs-lisp/cl-extra.el" "emacs-lisp/cl-macs.el"
 ;;;;;;  "emacs-lisp/cl-preloaded.el" "emacs-lisp/cl-seq.el" "emacs-lisp/eieio-compat.el"
-;;;;;;  "emacs-lisp/eieio-custom.el" "emacs-lisp/eieio-loaddefs.el"
-;;;;;;  "emacs-lisp/eieio-opt.el" "emacs-lisp/eldoc.el" "emacs-lisp/float-sup.el"
-;;;;;;  "emacs-lisp/lisp-mode.el" "emacs-lisp/lisp.el" "emacs-lisp/macroexp.el"
-;;;;;;  "emacs-lisp/map-ynp.el" "emacs-lisp/nadvice.el" "emacs-lisp/syntax.el"
-;;;;;;  "emacs-lisp/timer.el" "env.el" "epa-hook.el" "eshell/em-alias.el"
-;;;;;;  "eshell/em-banner.el" "eshell/em-basic.el" "eshell/em-cmpl.el"
-;;;;;;  "eshell/em-dirs.el" "eshell/em-glob.el" "eshell/em-hist.el"
-;;;;;;  "eshell/em-ls.el" "eshell/em-pred.el" "eshell/em-prompt.el"
-;;;;;;  "eshell/em-rebind.el" "eshell/em-script.el" "eshell/em-smart.el"
-;;;;;;  "eshell/em-term.el" "eshell/em-tramp.el" "eshell/em-unix.el"
-;;;;;;  "eshell/em-xtra.el" "eshell/esh-groups.el" "facemenu.el"
-;;;;;;  "faces.el" "files.el" "font-core.el" "font-lock.el" "format.el"
-;;;;;;  "frame.el" "help.el" "hfy-cmap.el" "htmlfontify-loaddefs.el"
-;;;;;;  "ibuf-ext.el" "ibuffer-loaddefs.el" "indent.el" "international/characters.el"
-;;;;;;  "international/charprop.el" "international/charscript.el"
-;;;;;;  "international/cp51932.el" "international/eucjp-ms.el" "international/mule-cmds.el"
+;;;;;;  "emacs-lisp/eieio-custom.el" "emacs-lisp/eieio-opt.el" "emacs-lisp/eldoc.el"
+;;;;;;  "emacs-lisp/float-sup.el" "emacs-lisp/lisp-mode.el" "emacs-lisp/lisp.el"
+;;;;;;  "emacs-lisp/macroexp.el" "emacs-lisp/map-ynp.el" "emacs-lisp/nadvice.el"
+;;;;;;  "emacs-lisp/syntax.el" "emacs-lisp/timer.el" "env.el" "epa-hook.el"
+;;;;;;  "eshell/em-alias.el" "eshell/em-banner.el" "eshell/em-basic.el"
+;;;;;;  "eshell/em-cmpl.el" "eshell/em-dirs.el" "eshell/em-glob.el"
+;;;;;;  "eshell/em-hist.el" "eshell/em-ls.el" "eshell/em-pred.el"
+;;;;;;  "eshell/em-prompt.el" "eshell/em-rebind.el" "eshell/em-script.el"
+;;;;;;  "eshell/em-smart.el" "eshell/em-term.el" "eshell/em-tramp.el"
+;;;;;;  "eshell/em-unix.el" "eshell/em-xtra.el" "facemenu.el" "faces.el"
+;;;;;;  "files.el" "font-core.el" "font-lock.el" "format.el" "frame.el"
+;;;;;;  "help.el" "hfy-cmap.el" "htmlfontify-loaddefs.el" "ibuf-ext.el"
+;;;;;;  "indent.el" "international/characters.el" "international/charprop.el"
+;;;;;;  "international/charscript.el" "international/cp51932.el"
+;;;;;;  "international/eucjp-ms.el" "international/mule-cmds.el"
 ;;;;;;  "international/mule-conf.el" "international/mule.el" "international/uni-bidi.el"
 ;;;;;;  "international/uni-brackets.el" "international/uni-category.el"
 ;;;;;;  "international/uni-combining.el" "international/uni-comment.el"
@@ -38132,32 +38124,30 @@ Zone out, completely.
 ;;;;;;  "leim/quail/pypunct-b5.el" "leim/quail/rfc1345.el" "leim/quail/sgml-input.el"
 ;;;;;;  "leim/quail/slovak.el" "leim/quail/symbol-ksc.el" "leim/quail/tamil-dvorak.el"
 ;;;;;;  "leim/quail/vntelex.el" "leim/quail/vnvni.el" "leim/quail/welsh.el"
-;;;;;;  "loadup.el" "mail/blessmail.el" "mail/rmail-loaddefs.el"
-;;;;;;  "mail/rmailedit.el" "mail/rmailkwd.el" "mail/rmailmm.el"
-;;;;;;  "mail/rmailmsc.el" "mail/rmailsort.el" "mail/rmailsum.el"
-;;;;;;  "mail/undigest.el" "menu-bar.el" "mh-e/mh-gnus.el" "mh-e/mh-loaddefs.el"
-;;;;;;  "minibuffer.el" "mouse.el" "net/tramp-loaddefs.el" "newcomment.el"
-;;;;;;  "obarray.el" "org/ob-core.el" "org/ob-keys.el" "org/ob-lob.el"
-;;;;;;  "org/ob-matlab.el" "org/ob-tangle.el" "org/ob.el" "org/org-archive.el"
-;;;;;;  "org/org-attach.el" "org/org-bbdb.el" "org/org-clock.el"
-;;;;;;  "org/org-datetree.el" "org/org-element.el" "org/org-feed.el"
-;;;;;;  "org/org-footnote.el" "org/org-id.el" "org/org-indent.el"
-;;;;;;  "org/org-install.el" "org/org-irc.el" "org/org-loaddefs.el"
-;;;;;;  "org/org-mobile.el" "org/org-plot.el" "org/org-table.el"
-;;;;;;  "org/org-timer.el" "org/ox-ascii.el" "org/ox-beamer.el" "org/ox-html.el"
-;;;;;;  "org/ox-icalendar.el" "org/ox-latex.el" "org/ox-man.el" "org/ox-md.el"
-;;;;;;  "org/ox-odt.el" "org/ox-org.el" "org/ox-publish.el" "org/ox-texinfo.el"
-;;;;;;  "org/ox.el" "progmodes/elisp-mode.el" "progmodes/prog-mode.el"
-;;;;;;  "ps-def.el" "ps-mule.el" "ps-print-loaddefs.el" "register.el"
-;;;;;;  "replace.el" "rfn-eshadow.el" "select.el" "simple.el" "startup.el"
-;;;;;;  "subdirs.el" "subr.el" "textmodes/fill.el" "textmodes/page.el"
-;;;;;;  "textmodes/paragraphs.el" "textmodes/reftex-auc.el" "textmodes/reftex-cite.el"
-;;;;;;  "textmodes/reftex-dcr.el" "textmodes/reftex-global.el" "textmodes/reftex-index.el"
-;;;;;;  "textmodes/reftex-loaddefs.el" "textmodes/reftex-parse.el"
-;;;;;;  "textmodes/reftex-ref.el" "textmodes/reftex-sel.el" "textmodes/reftex-toc.el"
-;;;;;;  "textmodes/text-mode.el" "uniquify.el" "vc/ediff-hook.el"
-;;;;;;  "vc/vc-hooks.el" "version.el" "widget.el" "window.el") (0
-;;;;;;  0 0 0))
+;;;;;;  "loadup.el" "mail/blessmail.el" "mail/rmailedit.el" "mail/rmailkwd.el"
+;;;;;;  "mail/rmailmm.el" "mail/rmailmsc.el" "mail/rmailsort.el"
+;;;;;;  "mail/rmailsum.el" "mail/undigest.el" "menu-bar.el" "mh-e/mh-gnus.el"
+;;;;;;  "mh-e/mh-loaddefs.el" "minibuffer.el" "mouse.el" "net/tramp-loaddefs.el"
+;;;;;;  "newcomment.el" "obarray.el" "org/ob-core.el" "org/ob-keys.el"
+;;;;;;  "org/ob-lob.el" "org/ob-matlab.el" "org/ob-tangle.el" "org/ob.el"
+;;;;;;  "org/org-archive.el" "org/org-attach.el" "org/org-bbdb.el"
+;;;;;;  "org/org-clock.el" "org/org-datetree.el" "org/org-element.el"
+;;;;;;  "org/org-feed.el" "org/org-footnote.el" "org/org-id.el" "org/org-indent.el"
+;;;;;;  "org/org-install.el" "org/org-irc.el" "org/org-mobile.el"
+;;;;;;  "org/org-plot.el" "org/org-table.el" "org/org-timer.el" "org/ox-ascii.el"
+;;;;;;  "org/ox-beamer.el" "org/ox-html.el" "org/ox-icalendar.el"
+;;;;;;  "org/ox-latex.el" "org/ox-man.el" "org/ox-md.el" "org/ox-odt.el"
+;;;;;;  "org/ox-org.el" "org/ox-publish.el" "org/ox-texinfo.el" "org/ox.el"
+;;;;;;  "progmodes/elisp-mode.el" "progmodes/prog-mode.el" "ps-def.el"
+;;;;;;  "ps-mule.el" "register.el" "replace.el" "rfn-eshadow.el"
+;;;;;;  "select.el" "simple.el" "startup.el" "subdirs.el" "subr.el"
+;;;;;;  "textmodes/fill.el" "textmodes/page.el" "textmodes/paragraphs.el"
+;;;;;;  "textmodes/reftex-auc.el" "textmodes/reftex-cite.el" "textmodes/reftex-dcr.el"
+;;;;;;  "textmodes/reftex-global.el" "textmodes/reftex-index.el"
+;;;;;;  "textmodes/reftex-parse.el" "textmodes/reftex-ref.el" "textmodes/reftex-sel.el"
+;;;;;;  "textmodes/reftex-toc.el" "textmodes/text-mode.el" "uniquify.el"
+;;;;;;  "vc/ediff-hook.el" "vc/vc-hooks.el" "version.el" "widget.el"
+;;;;;;  "window.el") (0 0 0 0))
 
 ;;;***
 
diff --git a/lisp/man.el b/lisp/man.el
index 4f6e1187e0d..0e1c92956b3 100644
--- a/lisp/man.el
+++ b/lisp/man.el
@@ -832,10 +832,7 @@ indicating optional parts and whitespace being interpreted
 somewhat loosely.
 
 foo[, bar [, ...]] [other stuff] (sec) - description
-foo(sec)[, bar(sec) [, ...]] [other stuff] - description
-
-For more details and some regression tests, please see
-test/automated/man-tests.el in the emacs repository."
+foo(sec)[, bar(sec) [, ...]] [other stuff] - description"
   (goto-char (point-min))
   ;; See man-tests for data about which systems use which format (hopefully we
   ;; will be able to simplify the code if/when some of those formats aren't
diff --git a/lisp/net/shr.el b/lisp/net/shr.el
index 6ec647e8028..7472c4133ad 100644
--- a/lisp/net/shr.el
+++ b/lisp/net/shr.el
@@ -933,17 +933,19 @@ If EXTERNAL, browse the URL using `shr-external-browser'."
         (let ((data (shr-parse-image-data)))
           (with-current-buffer buffer
             (save-excursion
-              (let ((alt (buffer-substring start end))
-                    (properties (text-properties-at start))
-                    (inhibit-read-only t))
-                (delete-region start end)
-                (goto-char start)
-                (funcall shr-put-image-function data alt flags)
-                (while properties
-                  (let ((type (pop properties))
-                        (value (pop properties)))
-                    (unless (memq type '(display image-size))
-                      (put-text-property start (point) type value))))))))))
+              (save-restriction
+                (widen)
+                (let ((alt (buffer-substring start end))
+                      (properties (text-properties-at start))
+                      (inhibit-read-only t))
+                  (delete-region start end)
+                  (goto-char start)
+                  (funcall shr-put-image-function data alt flags)
+                  (while properties
+                    (let ((type (pop properties))
+                          (value (pop properties)))
+                      (unless (memq type '(display image-size))
+                        (put-text-property start (point) type value)))))))))))
     (kill-buffer image-buffer)))
 
 (defun shr-image-from-data (data)
diff --git a/lisp/net/tramp-adb.el b/lisp/net/tramp-adb.el
index bf89ab37123..240e017279c 100644
--- a/lisp/net/tramp-adb.el
+++ b/lisp/net/tramp-adb.el
@@ -1,4 +1,4 @@
-;;; tramp-adb.el --- Functions for calling Android Debug Bridge from Tramp
+;;; tramp-adb.el --- Functions for calling Android Debug Bridge from Tramp  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 2011-2017 Free Software Foundation, Inc.
 
@@ -94,9 +94,6 @@ It is used for TCP/IP devices."
     tramp-adb-method '((tramp-adb-parse-device-names ""))))
 
 ;;;###tramp-autoload
-(add-to-list 'tramp-foreign-file-name-handler-alist
-             (cons 'tramp-adb-file-name-p 'tramp-adb-file-name-handler))
-
 (defconst tramp-adb-file-name-handler-alist
   '((access-file . ignore)
     (add-name-to-file . tramp-adb-handle-copy-file)
@@ -190,6 +187,10 @@ pass to the OPERATION."
       (tramp-run-real-handler operation args))))
 
 ;;;###tramp-autoload
+(tramp-register-foreign-file-name-handler
+ 'tramp-adb-file-name-p 'tramp-adb-file-name-handler)
+
+;;;###tramp-autoload
 (defun tramp-adb-parse-device-names (_ignore)
   "Return a list of (nil host) tuples allowed to access."
   (with-timeout (10)
@@ -209,7 +210,7 @@ pass to the OPERATION."
         (tramp-message v 6 "\n%s" (buffer-string))
         (goto-char (point-min))
         (while (search-forward-regexp "^\\(\\S-+\\)[[:space:]]+device$" nil t)
-          (add-to-list 'result (list nil (match-string 1))))
+          (push (list nil (match-string 1)) result))
 
         ;; Replace ":" by "#".
         (mapc
@@ -1060,8 +1061,7 @@ E.g. a host name \"192.168.1.1#5555\" returns \"192.168.1.1:5555\"
   ;; unwanted entries first.
   (tramp-flush-connection-property nil)
   (with-tramp-connection-property (tramp-get-connection-process vec) "device"
-    (let* ((method (tramp-file-name-method vec))
-           (host (tramp-file-name-host vec))
+    (let* ((host (tramp-file-name-host vec))
            (port (tramp-file-name-port vec))
            (devices (mapcar 'cadr (tramp-adb-parse-device-names nil))))
       (replace-regexp-in-string
diff --git a/lisp/net/tramp-cache.el b/lisp/net/tramp-cache.el
index ce7df02e094..64268cfc25a 100644
--- a/lisp/net/tramp-cache.el
+++ b/lisp/net/tramp-cache.el
@@ -1,4 +1,4 @@
-;;; tramp-cache.el --- file information caching for Tramp
+;;; tramp-cache.el --- file information caching for Tramp  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 2000, 2005-2017 Free Software Foundation, Inc.
 
diff --git a/lisp/net/tramp-cmds.el b/lisp/net/tramp-cmds.el
index 576f9b1eadc..c41b5b5659e 100644
--- a/lisp/net/tramp-cmds.el
+++ b/lisp/net/tramp-cmds.el
@@ -1,4 +1,4 @@
-;;; tramp-cmds.el --- Interactive commands for Tramp
+;;; tramp-cmds.el --- Interactive commands for Tramp  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 2007-2017 Free Software Foundation, Inc.
 
diff --git a/lisp/net/tramp-compat.el b/lisp/net/tramp-compat.el
index 8e5b3e45d13..8f346eb4409 100644
--- a/lisp/net/tramp-compat.el
+++ b/lisp/net/tramp-compat.el
@@ -1,4 +1,4 @@
-;;; tramp-compat.el --- Tramp compatibility functions
+;;; tramp-compat.el --- Tramp compatibility functions  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 2007-2017 Free Software Foundation, Inc.
 
diff --git a/lisp/net/tramp-ftp.el b/lisp/net/tramp-ftp.el
index 85e4f2b0f0c..231383fde3d 100644
--- a/lisp/net/tramp-ftp.el
+++ b/lisp/net/tramp-ftp.el
@@ -1,4 +1,4 @@
-;;; tramp-ftp.el --- Tramp convenience functions for Ange-FTP
+;;; tramp-ftp.el --- Tramp convenience functions for Ange-FTP  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 2002-2017 Free Software Foundation, Inc.
 
diff --git a/lisp/net/tramp-gvfs.el b/lisp/net/tramp-gvfs.el
index 7725d40f198..59d8771cf1d 100644
--- a/lisp/net/tramp-gvfs.el
+++ b/lisp/net/tramp-gvfs.el
@@ -1,4 +1,4 @@
-;;; tramp-gvfs.el --- Tramp access functions for GVFS daemon
+;;; tramp-gvfs.el --- Tramp access functions for GVFS daemon  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 2009-2017 Free Software Foundation, Inc.
 
@@ -452,6 +452,7 @@ Every entry is a list (NAME ADDRESS).")
 
 
 ;; New handlers should be added here.
+;;;###tramp-autoload
 (defconst tramp-gvfs-file-name-handler-alist
   '((access-file . ignore)
     (add-name-to-file . tramp-gvfs-handle-copy-file)
@@ -548,12 +549,10 @@ pass to the OPERATION."
         (save-match-data (apply (cdr fn) args))
       (tramp-run-real-handler operation args))))
 
-;; This might be moved to tramp.el.  It shall be the first file name
-;; handler.
 ;;;###tramp-autoload
 (when (featurep 'dbusbind)
-  (add-to-list 'tramp-foreign-file-name-handler-alist
-               (cons 'tramp-gvfs-file-name-p 'tramp-gvfs-file-name-handler)))
+  (tramp-register-foreign-file-name-handler
+   'tramp-gvfs-file-name-p 'tramp-gvfs-file-name-handler))
 
 
 ;; D-Bus helper function.
@@ -1874,12 +1873,9 @@ This uses \"avahi-browse\" in case D-Bus is not enabled in Avahi."
       (lambda (x)
         (let* ((list (split-string x ";"))
                (host (nth 6 list))
-               (port (nth 8 list))
                (text (tramp-compat-funcall
                       'split-string (nth 9 list) "\" \"" 'omit "\""))
                user)
-;         (when (and port (not (string-equal port "0")))
-;           (setq host (format "%s%s%s" host tramp-prefix-port-regexp port)))
           ;; A user is marked in a TXT field like "u=guest".
           (while text
             (when (string-match "u=\\(.+\\)$" (car text))
diff --git a/lisp/net/tramp-sh.el b/lisp/net/tramp-sh.el
index af27d3e28ec..e4a48b7f8e2 100644
--- a/lisp/net/tramp-sh.el
+++ b/lisp/net/tramp-sh.el
@@ -1,4 +1,4 @@
-;;; tramp-sh.el --- Tramp access functions for (s)sh-like connections
+;;; tramp-sh.el --- Tramp access functions for (s)sh-like connections  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 1998-2017 Free Software Foundation, Inc.
 
@@ -33,6 +33,9 @@
 (eval-when-compile
   (require 'cl)
   (require 'dired))
+
+(declare-function dired-remove-file "dired-aux")
+(defvar dired-compress-file-suffixes)
 (defvar vc-handled-backends)
 (defvar vc-bzr-program)
 (defvar vc-git-program)
@@ -978,6 +981,7 @@ here-document, otherwise the command could exceed maximum length
 of command line.")
 
 ;; New handlers should be added here.
+;;;###tramp-autoload
 (defconst tramp-sh-file-name-handler-alist
   '(;; `access-file' performed by default handler.
     (add-name-to-file . tramp-sh-handle-add-name-to-file)
@@ -1051,11 +1055,6 @@ of command line.")
   "Alist of handler functions.
 Operations not mentioned here will be handled by the normal Emacs functions.")
 
-;; This must be the last entry, because `identity' always matches.
-;;;###tramp-autoload
-(add-to-list 'tramp-foreign-file-name-handler-alist
-             '(identity . tramp-sh-file-name-handler) 'append)
-
 ;;; File Name Handler Functions:
 
 (defun tramp-sh-handle-make-symbolic-link
@@ -2593,9 +2592,6 @@ The method used must be an out-of-band method."
 
 ;; Dired.
 
-(defvar dired-compress-file-suffixes)
-(declare-function dired-remove-file "dired-aux")
-
 (defun tramp-sh-handle-dired-compress-file (file)
   "Like `dired-compress-file' for Tramp files."
   ;; Code stolen mainly from dired-aux.el.
@@ -3536,6 +3532,11 @@ Fall back to normal file name handler if no Tramp handler exists."
                 (tramp-run-real-handler operation args)))))
       (setq tramp-locked tl))))
 
+;; This must be the last entry, because `identity' always matches.
+;;;###tramp-autoload
+(tramp-register-foreign-file-name-handler
+ 'identity 'tramp-sh-file-name-handler 'append)
+
 (defun tramp-vc-file-name-handler (operation &rest args)
   "Invoke special file name handler, which collects files to be handled."
   (save-match-data
@@ -5221,7 +5222,7 @@ Nonexistent directories are removed from spec."
   "Determine remote locale, supporting UTF8 if possible."
   (with-tramp-connection-property vec "locale"
     (tramp-send-command vec "locale -a")
-    (let ((candidates '("en_US.utf8" "C.utf8" "en_US.UTF-8"))
+    (let ((candidates '("en_US.utf8" "C.utf8" "en_US.UTF-8" "C.UTF-8"))
           locale)
       (with-current-buffer (tramp-get-connection-buffer vec)
         (while candidates
diff --git a/lisp/net/tramp-smb.el b/lisp/net/tramp-smb.el
index 91f69567573..4205376d655 100644
--- a/lisp/net/tramp-smb.el
+++ b/lisp/net/tramp-smb.el
@@ -1,4 +1,4 @@
-;;; tramp-smb.el --- Tramp access functions for SMB servers
+;;; tramp-smb.el --- Tramp access functions for SMB servers  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 2002-2017 Free Software Foundation, Inc.
 
@@ -157,6 +157,7 @@ call, letting the SMB client use the default one."
          "NT_STATUS_OBJECT_NAME_COLLISION"
          "NT_STATUS_OBJECT_NAME_INVALID"
          "NT_STATUS_OBJECT_NAME_NOT_FOUND"
+         "NT_STATUS_PASSWORD_MUST_CHANGE"
          "NT_STATUS_SHARING_VIOLATION"
          "NT_STATUS_TRUSTED_RELATIONSHIP_FAILURE"
          "NT_STATUS_UNSUCCESSFUL"
@@ -217,6 +218,7 @@ This list is used for smbcacls actions.
 See `tramp-actions-before-shell' for more info.")
 
 ;; New handlers should be added here.
+;;;###tramp-autoload
 (defconst tramp-smb-file-name-handler-alist
   '(;; `access-file' performed by default handler.
     (add-name-to-file . tramp-smb-handle-add-name-to-file)
@@ -340,9 +342,8 @@ pass to the OPERATION."
 
 ;;;###tramp-autoload
 (unless (memq system-type '(cygwin windows-nt))
-  (add-to-list 'tramp-foreign-file-name-handler-alist
-               (cons 'tramp-smb-file-name-p 'tramp-smb-file-name-handler)))
-
+  (tramp-register-foreign-file-name-handler
+   'tramp-smb-file-name-p 'tramp-smb-file-name-handler))
 
 ;; File name primitives.
 
diff --git a/lisp/net/tramp-uu.el b/lisp/net/tramp-uu.el
index 0aa2cc09924..5e5f05da4a8 100644
--- a/lisp/net/tramp-uu.el
+++ b/lisp/net/tramp-uu.el
@@ -1,4 +1,4 @@
-;;; tramp-uu.el --- uuencode in Lisp
+;;; tramp-uu.el --- uuencode in Lisp  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 2002-2017 Free Software Foundation, Inc.
 
diff --git a/lisp/net/tramp.el b/lisp/net/tramp.el
index fdd4661decb..0ca5a6d3acb 100644
--- a/lisp/net/tramp.el
+++ b/lisp/net/tramp.el
@@ -1,4 +1,4 @@
-;;; tramp.el --- Transparent Remote Access, Multiple Protocol
+;;; tramp.el --- Transparent Remote Access, Multiple Protocol  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 1998-2017 Free Software Foundation, Inc.
 
@@ -60,7 +60,10 @@
 ;; Pacify byte-compiler.
 (eval-when-compile
   (require 'cl))
+(defvar auto-save-file-name-transforms)
 (defvar eshell-path-env)
+(defvar ls-lisp-use-insert-directory-program)
+(defvar outline-regexp)
 
 ;;; User Customizable Internal Variables:
 
@@ -1052,8 +1055,7 @@ means to use always cached values for the directory contents."
 
 ;;;###autoload
 (defconst tramp-completion-file-name-handler-alist
-  '(;(expand-file-name . tramp-completion-handle-expand-file-name)
-    (file-name-all-completions
+  '((file-name-all-completions
      . tramp-completion-handle-file-name-all-completions)
     (file-name-completion . tramp-completion-handle-file-name-completion))
   "Alist of completion handler functions.
@@ -1374,8 +1376,6 @@ Point must be at the beginning of a header line.
 The outline level is equal to the verbosity of the Tramp message."
   (1+ (string-to-number (match-string 1))))
 
-(defvar outline-regexp)
-
 (defun tramp-get-debug-buffer (vec)
   "Get the debug buffer for VEC."
   (with-current-buffer
@@ -1871,13 +1871,12 @@ temporary file names.  If `file-coding-system-alist' contains an
 expression, which matches more than the file name suffix, the
 coding system might not be determined.  This function repairs it."
   (let (result)
-    (dolist (elt file-coding-system-alist result)
+    (dolist (elt file-coding-system-alist (nreverse result))
       (when (and (consp elt) (string-match (car elt) filename))
         ;; We found a matching entry in `file-coding-system-alist'.
         ;; So we add a similar entry, but with the temporary file name
         ;; as regexp.
-        (add-to-list
-         'result (cons (regexp-quote tmpname) (cdr elt)) 'append)))))
+        (push (cons (regexp-quote tmpname) (cdr elt)) result)))))
 
 ;;;###autoload
 (progn (defun tramp-run-real-handler (operation args)
@@ -1995,6 +1994,7 @@ ARGS are the arguments OPERATION has been called with."
      (tramp-compat-condition-case-unless-debug ,var ,bodyform ,@handlers)))
 
 ;; Main function.
+;;;###autoload
 (defun tramp-file-name-handler (operation &rest args)
   "Invoke Tramp file name handler.
 Falls back to normal file name handler if no Tramp file name handler exists."
@@ -2113,20 +2113,7 @@ preventing reentrant calls of Tramp.")
 Together with `tramp-locked', this implements a locking mechanism
 preventing reentrant calls of Tramp.")
 
-;; Avoid recursive loading of tramp.el.
-;; FIXME: This must go better.  Checking for `operation' is wrong.
-;;;###autoload(defun tramp-completion-file-name-handler (operation &rest args)
-;;;###autoload  (let ((fn
-;;;###autoload         (assoc
-;;;###autoload          operation tramp-completion-file-name-handler-alist)))
-;;;###autoload    (if (and
-;;;###autoload         tramp-mode fn (null load-in-progress)
-;;;###autoload         (member
-;;;###autoload          operation
-;;;###autoload          '(file-name-all-completions file-name-completion)))
-;;;###autoload        (apply 'tramp-autoload-file-name-handler operation args)
-;;;###autoload      (tramp-run-real-handler operation args))))
-
+;;;###autoload
 (defun tramp-completion-file-name-handler (operation &rest args)
   "Invoke Tramp file name completion handler.
 Falls back to normal file name handler if no Tramp file name handler exists."
@@ -2135,36 +2122,26 @@ Falls back to normal file name handler if no Tramp file name handler exists."
         (save-match-data (apply (cdr fn) args))
       (tramp-run-real-handler operation args))))
 
-;;;###autoload
-(progn (defun tramp-autoload-file-name-handler (operation &rest args)
-  "Load Tramp file name handler, and perform OPERATION."
-  (if (and
-       ;; Do not load tramp.el just for "/".
-       (not (and (stringp (car args)) (string-equal (car args) "/")))
-       ;; Avoid recursive loading of tramp.el.
-       (let ((default-directory temporary-file-directory))
-        (and (null load-in-progress) (load "tramp" 'noerror 'nomessage))))
-      (apply operation args)
-    ;; tramp.el not needed or not available for loading, fall back.
-    (tramp-run-real-handler operation args))))
-
-;; `tramp-autoload-file-name-handler' must be registered before
-;; evaluation of site-start and init files, because there might exist
-;; remote files already, f.e. files kept via recentf-mode.  We cannot
-;; autoload `tramp-file-name-handler', because it would result in
-;; recursive loading of tramp.el when `default-directory' is set to
-;; remote.
+;; `tramp-file-name-handler' must be registered before evaluation of
+;; site-start and init files, because there might exist remote files
+;; already, f.e. files kept via recentf-mode.
 ;;;###autoload
 (progn (defun tramp-register-autoload-file-name-handlers ()
   "Add Tramp file name handlers to `file-name-handler-alist' during autoload."
   (add-to-list 'file-name-handler-alist
-               (cons tramp-file-name-regexp
-                     'tramp-autoload-file-name-handler))
-  (put 'tramp-autoload-file-name-handler 'safe-magic t)
+               (cons tramp-file-name-regexp 'tramp-file-name-handler))
+  (put 'tramp-file-name-handler 'safe-magic t)
+  ;; Mark `operations' the handler is responsible for.  It's a short list ...
+  (put 'tramp-file-name-handler 'operations
+       '(file-name-all-completions file-name-completion file-remote-p))
+
   (add-to-list 'file-name-handler-alist
                (cons tramp-completion-file-name-regexp
                      'tramp-completion-file-name-handler))
-  (put 'tramp-completion-file-name-handler 'safe-magic t)))
+  (put 'tramp-completion-file-name-handler 'safe-magic t)
+  ;; Mark `operations' the handler is responsible for.
+  (put 'tramp-completion-file-name-handler 'operations
+       (mapcar 'car tramp-completion-file-name-handler-alist))))
 
 ;;;###autoload
 (tramp-register-autoload-file-name-handlers)
@@ -2174,22 +2151,29 @@ Falls back to normal file name handler if no Tramp file name handler exists."
   ;; Remove autoloaded handlers from file name handler alist.  Useful,
   ;; if `tramp-syntax' has been changed.
   (dolist (fnh '(tramp-file-name-handler
-                 tramp-completion-file-name-handler
-                 tramp-autoload-file-name-handler))
+                 tramp-completion-file-name-handler))
     (let ((a1 (rassq fnh file-name-handler-alist)))
       (setq file-name-handler-alist (delq a1 file-name-handler-alist))))
+
   ;; The initial value of `tramp-file-name-regexp' is too simple
   ;; minded, but we cannot give it the real value in the autoload
   ;; pattern.  See Bug#24889.
   (setq tramp-file-name-regexp (car tramp-file-name-structure))
-  ;; Add the handlers.
+  ;; Add the handlers.  We do not add anything to the `operations'
+  ;; property of `tramp-file-name-handler', this shall be done by the
+  ;; respective foreign handlers.
   (add-to-list 'file-name-handler-alist
                (cons tramp-file-name-regexp 'tramp-file-name-handler))
   (put 'tramp-file-name-handler 'safe-magic t)
+
   (add-to-list 'file-name-handler-alist
                (cons tramp-completion-file-name-regexp
                      'tramp-completion-file-name-handler))
   (put 'tramp-completion-file-name-handler 'safe-magic t)
+  ;; Mark `operations' the handler is responsible for.
+  (put 'tramp-completion-file-name-handler 'operations
+       (mapcar 'car tramp-completion-file-name-handler-alist))
+
   ;; If jka-compr or epa-file are already loaded, move them to the
   ;; front of `file-name-handler-alist'.
   (dolist (fnh '(epa-file-handler jka-compr-handler))
@@ -2200,6 +2184,24 @@ Falls back to normal file name handler if no Tramp file name handler exists."
 
 (eval-after-load 'tramp (tramp-register-file-name-handlers))
 
+;;;###tramp-autoload
+(progn (defun tramp-register-foreign-file-name-handler
+    (func handler &optional append)
+  "Register (FUNC . HANDLER) in `tramp-foreign-file-name-handler-alist'.
+FUNC is the function, which determines whether HANDLER is to be called.
+Add operations defined in `HANDLER-alist' to `tramp-file-name-handler'."
+  (add-to-list
+   'tramp-foreign-file-name-handler-alist `(,func . ,handler) append)
+  ;; Mark `operations' the handler is responsible for.
+  (put 'tramp-file-name-handler
+       'operations
+       (cl-delete-duplicates
+        (append
+         (get 'tramp-file-name-handler 'operations)
+         (mapcar
+          'car
+          (symbol-value (intern (concat (symbol-name handler) "-alist")))))))))
+
 (defun tramp-exists-file-name-handler (operation &rest args)
   "Check, whether OPERATION runs a file name handler."
   ;; The file name handler is determined on base of either an
@@ -2258,15 +2260,6 @@ not in completion mode."
               (tramp-get-connection-process
                (tramp-dissect-file-name filename)))))))
 
-(defun tramp-completion-handle-expand-file-name (name &optional dir)
-  "Like `expand-file-name' for Tramp files."
-  ;; If DIR is not given, use `default-directory' or "/".
-  (setq dir (or dir default-directory "/"))
-  (cond
-   ((file-name-absolute-p name) name)
-   ((zerop (length name)) dir)
-   (t (concat (file-name-as-directory dir) name))))
-
 ;; Method, host name and user name completion.
 ;; `tramp-completion-dissect-file-name' returns a list of
 ;; tramp-file-name structures. For all of them we return possible completions.
@@ -2328,9 +2321,9 @@ not in completion mode."
       (when elt
         (string-match tramp-prefix-regexp elt)
         (setq elt (replace-match (concat tramp-prefix-format hop) nil nil elt))
-        (add-to-list
-         'result1
-         (substring elt (length (tramp-drop-volume-letter directory))))))
+        (push
+         (substring elt (length (tramp-drop-volume-letter directory)))
+         result1)))
 
     ;; Complete local parts.
     (append
@@ -2955,8 +2948,6 @@ User is always nil."
              backup-directory-alist)))
       (tramp-run-real-handler 'find-backup-file-name (list filename)))))
 
-(defvar ls-lisp-use-insert-directory-program)
-
 (defun tramp-handle-insert-directory
   (filename switches &optional wildcard full-directory-p)
   "Like `insert-directory' for Tramp files."
diff --git a/lisp/net/trampver.el b/lisp/net/trampver.el
index 35ad2f0acff..35b5eb6728a 100644
--- a/lisp/net/trampver.el
+++ b/lisp/net/trampver.el
@@ -1,4 +1,4 @@
-;;; trampver.el --- Transparent Remote Access, Multiple Protocol
+;;; trampver.el --- Transparent Remote Access, Multiple Protocol  -*- lexical-binding:t -*-
 ;;; lisp/trampver.el.  Generated from trampver.el.in by configure.
 
 ;; Copyright (C) 2003-2017 Free Software Foundation, Inc.
diff --git a/lisp/play/dunnet.el b/lisp/play/dunnet.el
index 677946262c5..8f013bb09f2 100644
--- a/lisp/play/dunnet.el
+++ b/lisp/play/dunnet.el
@@ -2106,28 +2106,23 @@ for a moment, then straighten yourself up.\n")
         (dun-mprincl "That answer is incorrect.")))))
 
 (defun dun-endgame-question ()
-(if (not dun-endgame-questions)
-    (progn
-      (dun-mprincl "Your question is:")
-      (dun-mprincl "No more questions, just do ‘answer foo’.")
-      (setq dun-correct-answer '("foo")))
-  (let (which i newques)
-    (setq i 0)
-    (setq newques nil)
-    (setq which (random (length dun-endgame-questions)))
-    (dun-mprincl "Your question is:")
-    (dun-mprincl (setq dun-endgame-question (car
-                                             (nth which
-                                                  dun-endgame-questions))))
-    (setq dun-correct-answer (cdr (nth which dun-endgame-questions)))
-    (while (< i which)
-      (setq newques (append newques (list (nth i dun-endgame-questions))))
-      (setq i (1+ i)))
-    (setq i (1+ which))
-    (while (< i (length dun-endgame-questions))
-      (setq newques (append newques (list (nth i dun-endgame-questions))))
-      (setq i (1+ i)))
-    (setq dun-endgame-questions newques))))
+  (let ((questions dun-endgame-questions))
+    (if (null questions)
+        (progn
+          (dun-mprincl "Your question is:")
+          (dun-mprincl "No more questions, just do ‘answer foo’.")
+          (setq dun-correct-answer '("foo")))
+      (let* ((which (random (length questions)))
+             (question (nth which questions)))
+        (dun-mprincl "Your question is:")
+        (dun-mprincl (setq dun-endgame-question (car question)))
+        (setq dun-correct-answer (cdr question))
+        (let ((i 0) res)
+          (dolist (q questions)
+            (when (/= i which)
+              (push q res))
+            (setq i (1+ i)))
+          (setq dun-endgame-questions (nreverse res)))))))
 
 (defun dun-power (_args)
   (if (not (= dun-current-room pc-area))
diff --git a/lisp/progmodes/cc-defs.el b/lisp/progmodes/cc-defs.el
index 3fdd56124c4..8dd56106af4 100644
--- a/lisp/progmodes/cc-defs.el
+++ b/lisp/progmodes/cc-defs.el
@@ -94,7 +94,7 @@
 
 ;;; Variables also used at compile time.
 
-(defconst c-version "5.32.99"
+(defconst c-version "5.33"
   "CC Mode version number.")
 
 (defconst c-version-sym (intern c-version))
diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index bdc77dc5028..de15d1d82fc 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -6243,9 +6243,9 @@ comment at the start of cc-engine.el for more info."
                     (eq (char-before) ?<))
         (c-backward-token-2)
         (when (eq (char-after) ?<)
-          (c-clear-<-pair-props-if-match-after beg)))
+          (c-clear-<-pair-props-if-match-after beg)
+          (setq new-beg (point))))
       (c-forward-syntactic-ws)
-      (setq new-beg (point))
 
       ;; ...Then the ones with < before end and > after end.
       (goto-char (if end-lit-limits (cdr end-lit-limits) end))
@@ -6254,9 +6254,9 @@ comment at the start of cc-engine.el for more info."
                   (eq (char-before) ?>))
         (c-end-of-current-token)
         (when (eq (char-before) ?>)
-          (c-clear->-pair-props-if-match-before end (1- (point)))))
+          (c-clear->-pair-props-if-match-before end (1- (point)))
+          (setq new-end (point))))
       (c-backward-syntactic-ws)
-      (setq new-end (point))
 
       ;; Extend the fontification region, if needed.
       (and new-beg
@@ -8863,7 +8863,29 @@ comment at the start of cc-engine.el for more info."
                  ;; it as a declaration if "a" has been used as a type
                  ;; somewhere else (if it's a known type we won't get here).
                  (setq maybe-expression t)
-                 (throw 'at-decl-or-cast t)))
+                 (throw 'at-decl-or-cast t))
+
+               ;; CASE 17.5
+               (when (and c-asymmetry-fontification-flag
+                          got-prefix-before-parens
+                          at-type
+                          (or (not got-suffix)
+                              at-decl-start))
+                 (let ((space-before-id
+                        (save-excursion
+                          (goto-char name-start)
+                          (or (bolp) (memq (char-before) '(?\  ?\t)))))
+                       (space-after-type
+                        (save-excursion
+                          (goto-char type-start)
+                          (and (c-forward-type)
+                               (progn (c-backward-syntactic-ws) t)
+                               (or (eolp)
+                                   (memq (char-after) '(?\  ?\t)))))))
+                   (when (not (eq (not space-before-id)
+                                  (not space-after-type)))
+                     (setq maybe-expression t)
+                     (throw 'at-decl-or-cast t)))))
 
            ;; CASE 18
            (when (and (not (memq context '(nil top)))
diff --git a/lisp/progmodes/cc-fonts.el b/lisp/progmodes/cc-fonts.el
index f623b9f3332..923f077b411 100644
--- a/lisp/progmodes/cc-fonts.el
+++ b/lisp/progmodes/cc-fonts.el
@@ -1117,6 +1117,124 @@ casts and declarations are fontified.  Used on level 2 and higher."
           (setq pos (point))))))     ; acts to make the `while' form continue.
   nil)
 
+(defun c-get-fontification-context (match-pos not-front-decl &optional toplev)
+  ;; Return a cons (CONTEXT . RESTRICTED-<>-ARGLISTS) for MATCH-POS.
+  ;; NOT-FRONT-DECL is non-nil when a declaration later in the buffer than
+  ;; MATCH-POS has already been parsed.  TOPLEV is non-nil when MATCH-POS is
+  ;; known to be at "top level", i.e. outside any braces, or directly inside a
+  ;; namespace, class, etc.
+  ;;
+  ;; CONTEXT is the fontification context of MATCH-POS, and is one of the
+  ;; following:
+  ;; 'decl     In a comma-separated declaration context (typically
+  ;;           inside a function declaration arglist).
+  ;; '<>       In an angle bracket arglist.
+  ;; 'arglist  Some other type of arglist.
+  ;; 'top      Some other context and point is at the top-level (either
+  ;;           outside any braces or directly inside a class or namespace,
+  ;;           etc.)
+  ;; nil       Some other context or unknown context.  Includes
+  ;;           within the parens of an if, for, ... construct.
+  ;; 'not-decl Definitely not in a declaration.
+  ;;
+  ;; RESTRICTED-<>-ARGLISTS is non-nil when a scan of template/generic
+  ;; arguments lists (i.e. lists enclosed by <...>) is more strict about what
+  ;; characters it allows within the list.
+  (let ((type (and (> match-pos (point-min))
+                   (c-get-char-property (1- match-pos) 'c-type))))
+    (cond ((not (memq (char-before match-pos) '(?\( ?, ?\[ ?< ?{)))
+           (cons (and toplev 'top) nil))
+          ;; A control flow expression or a decltype
+          ((and (eq (char-before match-pos) ?\()
+                (save-excursion
+                  (goto-char match-pos)
+                  (backward-char)
+                  (c-backward-token-2)
+                  (or (looking-at c-block-stmt-2-key)
+                      (looking-at c-block-stmt-1-2-key)
+                      (looking-at c-typeof-key))))
+           (cons nil t))
+          ;; Near BOB.
+          ((<= match-pos (point-min))
+           (cons 'arglist t))
+          ;; Got a cached hit in a declaration arglist.
+          ((eq type 'c-decl-arg-start)
+           (cons 'decl nil))
+          ;; We're inside (probably) a brace list.
+          ((eq type 'c-not-decl)
+           (cons 'not-decl nil))
+          ;; Inside a C++11 lambda function arglist.
+          ((and (c-major-mode-is 'c++-mode)
+                (eq (char-before match-pos) ?\()
+                (save-excursion
+                  (goto-char match-pos)
+                  (c-backward-token-2)
+                  (and
+                   (c-safe (goto-char (scan-sexps (point) -1)))
+                   (c-looking-at-c++-lambda-capture-list))))
+           (c-put-char-property (1- match-pos) 'c-type
+                                'c-decl-arg-start)
+           (cons 'decl nil))
+          ;; We're inside a brace list.
+          ((and (eq (char-before match-pos) ?{)
+                (save-excursion
+                  (goto-char (1- match-pos))
+                  (consp
+                   (c-looking-at-or-maybe-in-bracelist))))
+           (c-put-char-property (1- match-pos) 'c-type
+                                'c-not-decl)
+           (cons 'not-decl nil))
+          ;; We're inside an "ordinary" open brace.
+          ((eq (char-before match-pos) ?{)
+           (cons (and toplev 'top) nil))
+          ;; Inside an angle bracket arglist.
+          ((or (eq type 'c-<>-arg-sep)
+               (eq (char-before match-pos) ?<))
+           (cons '<> nil))
+          ;; Got a cached hit in some other type of arglist.
+          (type
+           (cons 'arglist t))
+          (not-front-decl
+           ;; The point is within the range of a previously
+           ;; encountered type decl expression, so the arglist
+           ;; is probably one that contains declarations.
+           ;; However, if `c-recognize-paren-inits' is set it
+           ;; might also be an initializer arglist.
+           ;;
+           ;; The result of this check is cached with a char
+           ;; property on the match token, so that we can look
+           ;; it up again when refontifying single lines in a
+           ;; multiline declaration.
+           (c-put-char-property (1- match-pos)
+                                'c-type 'c-decl-arg-start)
+           (cons 'decl nil))
+          ;; Got an open paren preceded by an arith operator.
+          ((and (eq (char-before match-pos) ?\()
+                (save-excursion
+                  (and (zerop (c-backward-token-2 2))
+                       (looking-at c-arithmetic-op-regexp))))
+           (cons nil nil))
+          ;; At start of a declaration inside a declaration paren.
+          ((save-excursion
+             (and (memq (char-before match-pos) '(?\( ?\,))
+                  (c-go-up-list-backward match-pos)
+                  (eq (char-after) ?\()
+                  (let ((type (c-get-char-property (point) 'c-type)))
+                    (or (memq type '(c-decl-arg-start c-decl-type-start))
+                        (and
+                         (progn (c-backward-syntactic-ws) t)
+                         (c-back-over-compound-identifier)
+                         (progn
+                           (c-backward-syntactic-ws)
+                           (or (bobp)
+                               (progn
+                                 (setq type (c-get-char-property (1- (point))
+                                                                 'c-type))
+                                 (memq type '(c-decl-arg-start
+                                              c-decl-type-start))))))))))
+           (cons 'decl nil))
+          (t (cons 'arglist t)))))
+
 (defun c-font-lock-declarations (limit)
   ;; Fontify all the declarations, casts and labels from the point to LIMIT.
   ;; Assumes that strings and comments have been fontified already.
@@ -1231,95 +1349,15 @@ casts and declarations are fontified.  Used on level 2 and higher."
             ;; "<" for the sake of C++-style template arglists.
             ;; Ignore "(" when it's part of a control flow construct
             ;; (e.g. "for (").
-            (let ((type (and (> match-pos (point-min))
-                             (c-get-char-property (1- match-pos) 'c-type))))
-              (cond ((not (memq (char-before match-pos) '(?\( ?, ?\[ ?< ?{)))
-                     (setq context (and toplev 'top)
-                           c-restricted-<>-arglists nil))
-                    ;; A control flow expression or a decltype
-                    ((and (eq (char-before match-pos) ?\()
-                          (save-excursion
-                            (goto-char match-pos)
-                            (backward-char)
-                            (c-backward-token-2)
-                            (or (looking-at c-block-stmt-2-key)
-                                (looking-at c-block-stmt-1-2-key)
-                                (looking-at c-typeof-key))))
-                     (setq context nil
-                           c-restricted-<>-arglists t))
-                    ;; Near BOB.
-                    ((<= match-pos (point-min))
-                     (setq context 'arglist
-                           c-restricted-<>-arglists t))
-                    ;; Got a cached hit in a declaration arglist.
-                    ((eq type 'c-decl-arg-start)
-                     (setq context 'decl
-                           c-restricted-<>-arglists nil))
-                    ;; We're inside (probably) a brace list.
-                    ((eq type 'c-not-decl)
-                     (setq context 'not-decl
-                           c-restricted-<>-arglists nil))
-                    ;; Inside a C++11 lambda function arglist.
-                    ((and (c-major-mode-is 'c++-mode)
-                          (eq (char-before match-pos) ?\()
-                          (save-excursion
-                            (goto-char match-pos)
-                            (c-backward-token-2)
-                            (and
-                             (c-safe (goto-char (scan-sexps (point) -1)))
-                             (c-looking-at-c++-lambda-capture-list))))
-                     (setq context 'decl
-                           c-restricted-<>-arglists nil)
-                     (c-put-char-property (1- match-pos) 'c-type
-                                          'c-decl-arg-start))
-                    ;; We're inside a brace list.
-                    ((and (eq (char-before match-pos) ?{)
-                          (save-excursion
-                            (goto-char (1- match-pos))
-                            (consp
-                             (c-looking-at-or-maybe-in-bracelist))))
-                     (setq context 'not-decl
-                           c-restricted-<>-arglists nil)
-                     (c-put-char-property (1- match-pos) 'c-type
-                                          'c-not-decl))
-                    ;; We're inside an "ordinary" open brace.
-                    ((eq (char-before match-pos) ?{)
-                     (setq context (and toplev 'top)
-                           c-restricted-<>-arglists nil))
-                    ;; Inside an angle bracket arglist.
-                    ((or (eq type 'c-<>-arg-sep)
-                         (eq (char-before match-pos) ?<))
-                     (setq context '<>
-                           c-restricted-<>-arglists nil))
-                    ;; Got a cached hit in some other type of arglist.
-                    (type
-                     (setq context 'arglist
-                           c-restricted-<>-arglists t))
-                    ((if inside-macro
-                         (< match-pos max-type-decl-end-before-token)
-                       (< match-pos max-type-decl-end))
-                     ;; The point is within the range of a previously
-                     ;; encountered type decl expression, so the arglist
-                     ;; is probably one that contains declarations.
-                     ;; However, if `c-recognize-paren-inits' is set it
-                     ;; might also be an initializer arglist.
-                     (setq context 'decl
-                           c-restricted-<>-arglists nil)
-                     ;; The result of this check is cached with a char
-                     ;; property on the match token, so that we can look
-                     ;; it up again when refontifying single lines in a
-                     ;; multiline declaration.
-                     (c-put-char-property (1- match-pos)
-                                          'c-type 'c-decl-arg-start))
-                    ;; Got an open paren preceded by an arith operator.
-                    ((and (eq (char-before match-pos) ?\()
-                          (save-excursion
-                            (and (zerop (c-backward-token-2 2))
-                                 (looking-at c-arithmetic-op-regexp))))
-                     (setq context nil
-                           c-restricted-<>-arglists nil))
-                    (t (setq context 'arglist
-                             c-restricted-<>-arglists t))))
+            (let ((got-context
+                   (c-get-fontification-context
+                    match-pos
+                    (< match-pos (if inside-macro
+                                     max-type-decl-end-before-token
+                                   max-type-decl-end))
+                    toplev)))
+              (setq context (car got-context)
+                    c-restricted-<>-arglists (cdr got-context)))
 
             ;; Check we haven't missed a preceding "typedef".
             (when (not (looking-at c-typedef-key))
diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el
index 8326e6a6f29..20c63d4dbe2 100644
--- a/lisp/progmodes/cc-mode.el
+++ b/lisp/progmodes/cc-mode.el
@@ -1363,6 +1363,7 @@ Note that the style variables are always made local to the buffer."
   ;; This function is called indirectly from font locking stuff - either from
   ;; c-after-change (to prepare for after-change font-locking) or from font
   ;; lock context (etc.) fontification.
+  (goto-char pos)
   (let ((lit-start (c-literal-start))
         (new-pos pos)
         capture-opener
diff --git a/lisp/progmodes/cc-vars.el b/lisp/progmodes/cc-vars.el
index 1114b21381d..ccd4fd29940 100644
--- a/lisp/progmodes/cc-vars.el
+++ b/lisp/progmodes/cc-vars.el
@@ -1634,6 +1634,18 @@ names)."))
   :type 'c-extra-types-widget
   :group 'c)
 
+(defcustom c-asymmetry-fontification-flag t
+  "Whether to fontify certain ambiguous constructs by white space asymmetry.
+
+In the fontification engine, it is sometimes impossible to determine
+whether a construct is a declaration or an expression.  This happens
+particularly in C++, due to ambiguities in the language.  When such a
+construct is like \"foo * bar\" or \"foo &bar\", and this variable is non-nil
+(the default), the construct will be fontified as a declaration if there is
+white space either before or after the operator, but not both."
+  :type 'boolean
+  :group 'c)
+
 (defvar c-noise-macro-with-parens-name-re "\\<\\>")
 (defvar c-noise-macro-name-re "\\<\\>")
 
diff --git a/lisp/progmodes/js.el b/lisp/progmodes/js.el
index aed42a85076..3c720c05610 100644
--- a/lisp/progmodes/js.el
+++ b/lisp/progmodes/js.el
@@ -1713,7 +1713,7 @@ This performs fontification according to `js--class-styles'."
               (not (any ?\] ?\\))
               (and "\\" not-newline)))
          "]")))
-   (group "/"))
+   (group (zero-or-one "/")))
   "Regular expression matching a JavaScript regexp literal.")
 
 (defun js-syntax-propertize-regexp (end)
@@ -1721,12 +1721,13 @@ This performs fontification according to `js--class-styles'."
     (when (eq (nth 3 ppss) ?/)
       ;; A /.../ regexp.
       (goto-char (nth 8 ppss))
-      (when (and (looking-at js--syntax-propertize-regexp-regexp)
-                 ;; Don't touch text after END.
-                 (<= (match-end 1) end))
-        (put-text-property (match-beginning 1) (match-end 1)
+      (when (looking-at js--syntax-propertize-regexp-regexp)
+        ;; Don't touch text after END.
+        (when (> end (match-end 1))
+          (setq end (match-end 1)))
+        (put-text-property (match-beginning 1) end
                            'syntax-table (string-to-syntax "\"/"))
-        (goto-char (match-end 0))))))
+        (goto-char end)))))
 
 (defun js-syntax-propertize (start end)
   ;; JavaScript allows immediate regular expression objects, written /.../.
diff --git a/lisp/progmodes/perl-mode.el b/lisp/progmodes/perl-mode.el
index a516f07e72f..b75f32ee200 100644
--- a/lisp/progmodes/perl-mode.el
+++ b/lisp/progmodes/perl-mode.el
@@ -255,9 +255,11 @@
       ;; format statements
       ("^[ \t]*format.*=[ \t]*\\(\n\\)"
        (1 (prog1 "\"" (perl-syntax-propertize-special-constructs end))))
-      ;; Funny things in `sub' arg-specs like `sub myfun ($)' or `sub ($)'.
-      ;; Be careful not to match "sub { (...) ... }".
-      ("\\<sub\\(?:[\s\t\n]+\\(?:\\sw\\|\\s_\\)+\\)?[\s\t\n]*(\\([^)]+\\))"
+      ;; Propertize perl prototype chars `$%&*;+@\[]' as punctuation
+      ;; in `sub' arg-specs like `sub myfun ($)' and `sub ($)'.  But
+      ;; don't match subroutine signatures like `sub add ($a, $b)', or
+      ;; anonymous subs like "sub { (...) ... }".
+      ("\\<sub\\(?:[\s\t\n]+\\(?:\\sw\\|\\s_\\)+\\)?[\s\t\n]*(\\([][$%&*;+@\\]+\\))"
        (1 "."))
       ;; Turn __DATA__ trailer into a comment.
       ("^\\(_\\)_\\(?:DATA\\|END\\)__[ \t]*\\(?:\\(\n\\)#.-\\*-.*perl.*-\\*-\\|\n.*\\)"
diff --git a/lisp/progmodes/python.el b/lisp/progmodes/python.el
index 228a4484616..2697f1a3107 100644
--- a/lisp/progmodes/python.el
+++ b/lisp/progmodes/python.el
@@ -1491,10 +1491,18 @@ Optional argument NOEND is internal and makes the logic to not
 jump to the end of line when moving forward searching for the end
 of the statement."
   (interactive "^")
-  (let (string-start bs-pos)
+  (let (string-start bs-pos (last-string-end 0))
     (while (and (or noend (goto-char (line-end-position)))
                 (not (eobp))
                 (cond ((setq string-start (python-syntax-context 'string))
+                       ;; The assertion can only fail if syntax table
+                       ;; text properties and the `syntax-ppss' cache
+                       ;; are somehow out of whack.  This has been
+                       ;; observed when using `syntax-ppss' during
+                       ;; narrowing.
+                       (cl-assert (> string-start last-string-end)
+                                  :show-args
+                                  "Overlapping strings detected")
                        (goto-char string-start)
                        (if (python-syntax-context 'paren)
                            ;; Ended up inside a paren, roll again.
@@ -1504,8 +1512,10 @@ of the statement."
                          (goto-char (+ (point)
                                        (python-syntax-count-quotes
                                         (char-after (point)) (point))))
-                         (or (re-search-forward (rx (syntax string-delimiter)) nil t)
-                             (goto-char (point-max)))))
+                         (setq last-string-end
+                               (or (re-search-forward
+                                    (rx (syntax string-delimiter)) nil t)
+                                   (goto-char (point-max))))))
                       ((python-syntax-context 'paren)
                        ;; The statement won't end before we've escaped
                        ;; at least one level of parenthesis.
diff --git a/lisp/replace.el b/lisp/replace.el
index 0841ba11b8b..a7b8ae6a347 100644
--- a/lisp/replace.el
+++ b/lisp/replace.el
@@ -848,7 +848,6 @@ called interactively by passing a non-nil INTERACTIVE argument.
 This function starts looking for the next match from the end of
 the previous match.  Hence, it ignores matches that overlap
 a previously found match."
-
   (interactive
    (progn
      (barf-if-buffer-read-only)
@@ -923,7 +922,6 @@ a non-nil INTERACTIVE argument.
 If a match is split across lines, all the lines it lies in are deleted.
 They are deleted _before_ looking for the next match.  Hence, a match
 starting on the same line at which another match ended is ignored."
-
   (interactive
    (progn
      (barf-if-buffer-read-only)
@@ -971,7 +969,6 @@ end of (the accessible portion of) the buffer.
 This function starts looking for the next match from the end of
 the previous match.  Hence, it ignores matches that overlap
 a previously found match."
-
   (interactive
    (keep-lines-read-args "How many matches for regexp"))
   (save-excursion
diff --git a/lisp/ses.el b/lisp/ses.el
index 76d4ca577d7..66fc0c5ebdf 100644
--- a/lisp/ses.el
+++ b/lisp/ses.el
@@ -1,4 +1,3 @@
-
 ;;; ses.el -- Simple Emacs Spreadsheet  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 2002-2017 Free Software Foundation, Inc.
@@ -2273,15 +2272,19 @@ print area if NONARROW is nil."
 ;; (defvar maxrow)
 ;; (defvar maxcol)
 
-(defun ses-recalculate-cell ()
+(defun ses-recalculate-cell (&optional ses--curcell)
   "Recalculate and reprint the current cell or range.
 
+If SES--CURCELL is non nil use it as current cell or range
+without any check, otherwise function (ses-check-curcell 'range)
+is called.
+
 For an individual cell, shows the error if the formula or printer
 signals one, or otherwise shows the cell's complete value.  For a range, the
 cells are recalculated in \"natural\" order, so cells that other cells refer
 to are recalculated first."
   (interactive "*")
-  (ses-check-curcell 'range)
+  (or ses--curcell (ses-check-curcell 'range))
   (ses-begin-change)
   (ses-initialize-Dijkstra-attempt)
   (let (sig cur-rowcol)
@@ -2334,7 +2337,7 @@ to are recalculated first."
   (let ((startcell    (ses--cell-at-pos (point)))
         (ses--curcell (cons 'A1 (ses-cell-symbol (1- ses--numrows)
                                                  (1- ses--numcols)))))
-    (ses-recalculate-cell)
+    (ses-recalculate-cell ses--curcell)
     (ses-jump-safe startcell)))
 
 (defun ses-truncate-cell ()
diff --git a/lisp/shell.el b/lisp/shell.el
index c8a8555d632..55a053295fa 100644
--- a/lisp/shell.el
+++ b/lisp/shell.el
@@ -711,36 +711,43 @@ Otherwise, one argument `-i' is passed to the shell.
                  ;; If the current buffer is a dead shell buffer, use it.
                  (current-buffer)))
 
-  ;; On remote hosts, the local `shell-file-name' might be useless.
-  (if (and (called-interactively-p 'any)
-           (file-remote-p default-directory)
-           (null explicit-shell-file-name)
-           (null (getenv "ESHELL")))
-      (with-current-buffer buffer
-        (set (make-local-variable 'explicit-shell-file-name)
-             (expand-file-name
-              (file-local-name
-               (read-file-name
-                "Remote shell path: " default-directory shell-file-name
-                t shell-file-name))))))
-
-  ;; The buffer's window must be correctly set when we call comint (so
-  ;; that comint sets the COLUMNS env var properly).
-  (pop-to-buffer buffer)
-  (unless (comint-check-proc buffer)
-    (let* ((prog (or explicit-shell-file-name
-                     (getenv "ESHELL") shell-file-name))
-           (name (file-name-nondirectory prog))
-           (startfile (concat "~/.emacs_" name))
-           (xargs-name (intern-soft (concat "explicit-" name "-args"))))
-      (unless (file-exists-p startfile)
-        (setq startfile (concat user-emacs-directory "init_" name ".sh")))
-      (apply 'make-comint-in-buffer "shell" buffer prog
-             (if (file-exists-p startfile) startfile)
-             (if (and xargs-name (boundp xargs-name))
-                 (symbol-value xargs-name)
-               '("-i")))
-      (shell-mode)))
+  (with-current-buffer buffer
+    (when (file-remote-p default-directory)
+      ;; Apply connection-local variables.
+      (hack-connection-local-variables-apply
+       `(:application 'tramp
+         :protocol ,(file-remote-p default-directory 'method)
+         :user ,(file-remote-p default-directory 'user)
+         :machine ,(file-remote-p default-directory 'host)))
+
+      ;; On remote hosts, the local `shell-file-name' might be useless.
+      (if (and (called-interactively-p 'any)
+               (null explicit-shell-file-name)
+               (null (getenv "ESHELL")))
+          (set (make-local-variable 'explicit-shell-file-name)
+               (expand-file-name
+                (file-local-name
+                 (read-file-name
+                  "Remote shell path: " default-directory shell-file-name
+                  t shell-file-name))))))
+
+    ;; The buffer's window must be correctly set when we call comint
+    ;; (so that comint sets the COLUMNS env var properly).
+    (pop-to-buffer buffer)
+    (unless (comint-check-proc buffer)
+      (let* ((prog (or explicit-shell-file-name
+                       (getenv "ESHELL") shell-file-name))
+             (name (file-name-nondirectory prog))
+             (startfile (concat "~/.emacs_" name))
+             (xargs-name (intern-soft (concat "explicit-" name "-args"))))
+        (unless (file-exists-p startfile)
+          (setq startfile (concat user-emacs-directory "init_" name ".sh")))
+        (apply 'make-comint-in-buffer "shell" buffer prog
+               (if (file-exists-p startfile) startfile)
+               (if (and xargs-name (boundp xargs-name))
+                   (symbol-value xargs-name)
+                 '("-i")))
+        (shell-mode))))
   buffer)
 
 ;;; Directory tracking
diff --git a/lisp/simple.el b/lisp/simple.el
index 369fbf71923..48c1a9b15d6 100644
--- a/lisp/simple.el
+++ b/lisp/simple.el
@@ -833,7 +833,7 @@ Leave one space or none, according to the context."
   (interactive "*")
   (save-excursion
     (delete-horizontal-space)
-    (if (or (looking-at "^\\|\\s)")
+    (if (or (looking-at "^\\|$\\|\\s)")
             (save-excursion (forward-char -1)
                             (looking-at "$\\|\\s(\\|\\s'")))
         nil
diff --git a/lisp/textmodes/css-mode.el b/lisp/textmodes/css-mode.el
index 91ebbf6f940..b1feca7ca6b 100644
--- a/lisp/textmodes/css-mode.el
+++ b/lisp/textmodes/css-mode.el
@@ -43,11 +43,13 @@
   :group 'languages)
 
 (defconst css-pseudo-class-ids
-  '("active" "checked" "disabled" "empty" "enabled" "first"
-    "first-child" "first-of-type" "focus" "hover" "indeterminate" "lang"
-    "last-child" "last-of-type" "left" "link" "not" "nth-child"
-    "nth-last-child" "nth-last-of-type" "nth-of-type" "only-child"
-    "only-of-type" "right" "root" "target" "visited")
+  '("active" "checked" "default" "disabled" "empty" "enabled" "first"
+    "first-child" "first-of-type" "focus" "focus-within" "hover"
+    "in-range" "indeterminate" "invalid" "lang" "last-child"
+    "last-of-type" "left" "link" "not" "nth-child" "nth-last-child"
+    "nth-last-of-type" "nth-of-type" "only-child" "only-of-type"
+    "optional" "out-of-range" "read-only" "read-write" "required"
+    "right" "root" "scope" "target" "valid" "visited")
   "Identifiers for pseudo-classes.")
 
 (defconst css-pseudo-element-ids
diff --git a/lisp/textmodes/ispell.el b/lisp/textmodes/ispell.el
index 9747bd6cc12..db733fe661b 100644
--- a/lisp/textmodes/ispell.el
+++ b/lisp/textmodes/ispell.el
@@ -1094,10 +1094,10 @@ in the list must have an affix file where Hunspell affix files are kept."
 
 (defun ispell-find-hunspell-dictionaries ()
   "Look for installed Hunspell dictionaries.
-Will initialize `ispell-hunspell-dictionary-alist' and
-`ispell-hunspell-dictionary-alist' after values found
-and remove `ispell-dicts-name2locale-equivs-alist'
-entries if a specific dictionary was found."
+Will initialize `ispell-hunspell-dictionary-alist' according
+to dictionaries found, and will remove aliases from the list
+in `ispell-dicts-name2locale-equivs-alist' if an explicit
+dictionary from that list was found."
   (let ((hunspell-found-dicts
          (split-string
           (with-temp-buffer
@@ -1110,18 +1110,27 @@ entries if a specific dictionary was found."
           "[\n\r]+"
           t))
         hunspell-default-dict
-        hunspell-default-dict-entry)
+        hunspell-default-dict-entry
+        hunspell-multi-dict)
     (dolist (dict hunspell-found-dicts)
       (let* ((full-name (file-name-nondirectory dict))
              (basename  (file-name-sans-extension full-name))
              (affix-file (concat dict ".aff")))
         (if (string-match "\\.aff$" dict)
             ;; Found default dictionary
-            (if hunspell-default-dict
-                (error "ispell-fhd: Default dict already defined as %s.  Not using %s.\n"
-                       hunspell-default-dict dict)
-              (setq affix-file dict)
-              (setq hunspell-default-dict (list basename affix-file)))
+            (progn
+              (if hunspell-default-dict
+                  (setq hunspell-multi-dict
+                        (concat (or hunspell-multi-dict
+                                    (car hunspell-default-dict))
+                                "," basename))
+                (setq affix-file dict)
+                ;; FIXME: The cdr of the list we cons below is never
+                ;; used.  Why do we need a list?
+                (setq hunspell-default-dict (list basename affix-file)))
+              (ispell-print-if-debug
+               "++ ispell-fhd: default dict-entry:%s name:%s basename:%s\n"
+               dict full-name basename))
           (if (and (not (assoc basename ispell-hunspell-dict-paths-alist))
                    (file-exists-p affix-file))
               ;; Entry has an associated .aff file and no previous value.
@@ -1161,7 +1170,8 @@ entries if a specific dictionary was found."
               (cl-pushnew (list dict-equiv-key affix-file)
                           ispell-hunspell-dict-paths-alist :test #'equal)))))
     ;; Parse and set values for default dictionary.
-    (setq hunspell-default-dict (car hunspell-default-dict))
+    (setq hunspell-default-dict (or hunspell-multi-dict
+                                    (car hunspell-default-dict)))
     (setq hunspell-default-dict-entry
           (ispell-parse-hunspell-affix-file hunspell-default-dict))
     ;; Create an alist of found dicts with only names, except for default dict.
diff --git a/lisp/url/url-auth.el b/lisp/url/url-auth.el
index 7b6cdd53790..2885d4e12e2 100644
--- a/lisp/url/url-auth.el
+++ b/lisp/url/url-auth.el
@@ -131,8 +131,8 @@ instead of the filename inheritance method."
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; Digest authorization code
 ;;; ------------------------
-;;; This implements the DIGEST authorization type.  See the internet draft
-;;; ftp://ds.internic.net/internet-drafts/draft-ietf-http-digest-aa-01.txt
+;;; This implements the DIGEST authorization type.  See RFC 2617
+;;; https://www.ietf.org/rfc/rfc2617.txt
 ;;; for the complete documentation on this type.
 ;;;
 ;;; This is very secure
@@ -143,107 +143,306 @@ Its value is an assoc list of assoc lists.  The first assoc list is
 keyed by the server name.  The cdr of this is an assoc list based
 on the \"directory\" specified by the url we are looking up.")
 
+(defsubst url-digest-auth-colonjoin (&rest args)
+  "Concatenate ARGS as strings with colon as a separator."
+  (mapconcat 'identity args ":"))
+
+(defsubst url-digest-auth-kd (data secret)
+  "Apply digest algorithm to DATA using SECRET and return the result."
+  (md5 (url-digest-auth-colonjoin secret data)))
+
+(defsubst url-digest-auth-make-ha1 (user realm password)
+  "Compute checksum out of strings USER, REALM, and PASSWORD."
+  (md5 (url-digest-auth-colonjoin user realm password)))
+
+(defsubst url-digest-auth-make-ha2 (method digest-uri)
+  "Compute checksum out of strings METHOD and DIGEST-URI."
+  (md5 (url-digest-auth-colonjoin method digest-uri)))
+
+(defsubst url-digest-auth-make-request-digest (ha1 ha2 nonce)
+  "Construct the request-digest from hash strings HA1, HA2, and NONCE.
+This is the value that server receives as a proof that user knows
+a password."
+  (url-digest-auth-kd (url-digest-auth-colonjoin nonce ha2) ha1))
+
+(defsubst url-digest-auth-make-request-digest-qop (qop ha1 ha2 nonce nc cnonce)
+  "Construct the request-digest with qop.
+QOP describes the \"quality of protection\" and algorithm to use.
+All of the strings QOP, HA1, HA2, NONCE, NC, and CNONCE are
+combined into a single hash value that proves to a server the
+user knows a password.  It's worth noting that HA2 already
+depends on value of QOP."
+  (url-digest-auth-kd (url-digest-auth-colonjoin
+                       nonce nc cnonce qop ha2) ha1))
+
+(defsubst url-digest-auth-directory-id (url realm)
+  "Make an identifier for selecting a key in key cache.
+The identifier is made either from URL or REALM.  It represents a
+protection space within a server so that one server can have
+multiple authorizations."
+  (or realm (or (url-file-directory (url-filename url)) "/")))
+
+(defsubst url-digest-auth-server-id (url)
+  "Make an identifier for selecting a server in key cache.
+The identifier is made from URL's host and port.  Together with
+`url-digest-auth-directory-id' these identify a single key in the
+key cache `url-digest-auth-storage'."
+  (format "%s:%d" (url-host url) (url-port url)))
+
+(defun url-digest-auth-make-cnonce ()
+  "Compute a new unique client nonce value."
+  (base64-encode-string
+   (apply 'format "%016x%04x%04x%05x%05x" (random) (current-time)) t))
+
+(defun url-digest-auth-nonce-count (nonce)
+  "The number requests sent to server with the given NONCE.
+This count includes the request we're preparing here.
+
+Currently, this is not implemented and will always return 1.
+
+Value returned is in string format with leading zeroes, such as
+\"00000001\"."
+  (format "%08x" 1))
+
+(defun url-digest-auth-name-value-string (pairs)
+  "Concatenate name-value pairs in association list PAIRS.
+
+Output is formatted as \"name1=\\\"value1\\\", name2=\\\"value2\\\", ...\""
+  (mapconcat (lambda (pair)
+               (format "%s=\"%s\""
+                       (symbol-name (car pair))
+                       (cdr pair)))
+             pairs ", "))
+
+(defun url-digest-auth-source-creds (url)
+  "Find credentials for URL object from the Emacs auth-source.
+Return value is a plist that has `:user' and `:secret' properties
+if credentials were found.  Otherwise nil."
+  (let ((server (url-digest-auth-server-id url))
+        (type (url-type url)))
+    (list :user (url-do-auth-source-search server type :user)
+          :secret (url-do-auth-source-search server type :secret))))
+
+(defun url-digest-prompt-creds (url realm &optional creds)
+  "Prompt credentials for URL and REALM, defaulting to CREDS.
+CREDS is a plist that may have properties `:user' and `:secret'."
+  ;; Set explicitly in case creds were nil.  This makes the second
+  ;; plist-put modify the same plist.
+  (setq creds
+        (plist-put creds :user
+                   (read-string (url-auth-user-prompt url realm)
+                                (or (plist-get creds :user)
+                                    (user-real-login-name)))))
+  (plist-put creds :secret
+             (read-passwd "Password: " nil (plist-get creds :secret))))
+
+(defun url-digest-auth-directory-id-assoc (dirkey keylist)
+  "Find the best match for DIRKEY in key alist KEYLIST.
+
+The string DIRKEY should be obtained using
+`url-digest-auth-directory-id'.  The key list to search through
+is the alist KEYLIST where car of each element may match DIRKEY.
+If DIRKEY represents a realm, the list is searched only for an
+exact match.  For directory names, an ancestor is sufficient for
+a match."
+  (or
+   ;; Check exact match first.
+   (assoc dirkey keylist)
+   ;; No exact match found.  Continue to look for partial match if
+   ;; dirkey is not a realm.
+   (and (string-match "/" dirkey)
+        (let (match)
+          (while (and (null match) keylist)
+            (if (or
+                 ;; Any realm candidate matches.  Why?
+                 (not (string-match "/" (caar keylist)))
+                 ;; Parent directory matches.
+                 (string-prefix-p (caar keylist) dirkey))
+                (setq match (car keylist))
+              (setq keylist (cdr keylist))))
+          match))))
+
+(defun url-digest-cached-key (url realm)
+  "Find best match for URL and REALM from `url-digest-auth-storage'.
+The return value is a list consisting of a realm (or a directory)
+a user name, and hashed authentication tokens HA1 and HA2.
+Modifying the contents of the returned list will modify the cache
+variable `url-digest-auth-storage' itself."
+  (url-digest-auth-directory-id-assoc
+   (url-digest-auth-directory-id url realm)
+   (cdr (assoc (url-digest-auth-server-id url) url-digest-auth-storage))))
+
+(defun url-digest-cache-key (key url)
+  "Add key to `url-digest-auth-storage'.
+KEY has the same format as returned by `url-digest-cached-key'.
+The key is added to cache hierarchy under server id, deduced from
+URL."
+  (let ((serverid (url-digest-auth-server-id url)))
+    (push (list serverid key) url-digest-auth-storage)))
+
 (defun url-digest-auth-create-key (username password realm method uri)
-  "Create a key for digest authentication method"
-  (let* ((info (if (stringp uri)
-                   (url-generic-parse-url uri)
-                 uri))
-         (a1 (md5 (concat username ":" realm ":" password)))
-         (a2 (md5 (concat method ":" (url-filename info)))))
-    (list a1 a2)))
-
-(defun url-digest-auth (url &optional prompt overwrite realm args)
-  "Get the username/password for the specified URL.
-If optional argument PROMPT is non-nil, ask for the username/password
-to use for the URL and its descendants.  If optional third argument
-OVERWRITE is non-nil, overwrite the old username/password pair if it
-is found in the assoc list.  If REALM is specified, use that as the realm
-instead of hostname:portnum."
-  (if args
-      (let* ((href (if (stringp url)
-                       (url-generic-parse-url url)
-                     url))
-             (server (url-host href))
-             (type (url-type href))
-             (port (url-port href))
-             (file (url-filename href))
-             (enable-recursive-minibuffers t)
-             user pass byserv retval data)
-        (setq file (cond
-                    (realm realm)
-                    ((string-match "/$" file) file)
-                    (t (url-file-directory file)))
-              server (format "%s:%d" server port)
-              byserv (cdr-safe (assoc server url-digest-auth-storage)))
-        (cond
-         ((and prompt (not byserv))
-          (setq user (or
-                      (url-do-auth-source-search server type :user)
-                      (read-string (url-auth-user-prompt url realm)
-                                   (user-real-login-name)))
-                pass (or
-                      (url-do-auth-source-search server type :secret)
-                      (read-passwd "Password: "))
-                url-digest-auth-storage
-                (cons (list server
-                            (cons file
-                                  (setq retval
-                                        (cons user
-                                              (url-digest-auth-create-key
-                                               user pass realm
-                                               (or url-request-method "GET")
-                                               url)))))
-                      url-digest-auth-storage)))
-         (byserv
-          (setq retval (cdr-safe (assoc file byserv)))
-          (if (and (not retval)         ; no exact match, check directories
-                   (string-match "/" file)) ; not looking for a realm
-              (while (and byserv (not retval))
-                (setq data (car (car byserv)))
-                (if (or (not (string-match "/" data))
-                        (and
-                         (>= (length file) (length data))
-                         (string= data (substring file 0 (length data)))))
-                    (setq retval (cdr (car byserv))))
-                (setq byserv (cdr byserv))))
-          (if overwrite
-              (if (and (not retval) prompt)
-                  (setq user (or
-                              (url-do-auth-source-search server type :user)
-                              (read-string (url-auth-user-prompt url realm)
-                                           (user-real-login-name)))
-                        pass (or
-                              (url-do-auth-source-search server type :secret)
-                              (read-passwd "Password: "))
-                        retval (setq retval
-                                     (cons user
-                                           (url-digest-auth-create-key
-                                            user pass realm
-                                            (or url-request-method "GET")
-                                            url)))
-                        byserv (assoc server url-digest-auth-storage))
-                (setcdr byserv
-                        (cons (cons file retval) (cdr byserv))))))
-         (t (setq retval nil)))
-        (if retval
-            (if (cdr-safe (assoc "opaque" args))
-                (let ((nonce (or (cdr-safe (assoc "nonce" args)) "nonegiven"))
-                      (opaque (cdr-safe (assoc "opaque" args))))
-                  (format
-                   (concat "Digest username=\"%s\", realm=\"%s\","
-                           "nonce=\"%s\", uri=\"%s\","
-                           "response=\"%s\", opaque=\"%s\"")
-                   (nth 0 retval) realm nonce (url-filename href)
-                   (md5 (concat (nth 1 retval) ":" nonce ":"
-                                (nth 2 retval))) opaque))
-              (let ((nonce (or (cdr-safe (assoc "nonce" args)) "nonegiven")))
-                (format
-                 (concat "Digest username=\"%s\", realm=\"%s\","
-                         "nonce=\"%s\", uri=\"%s\","
-                         "response=\"%s\"")
-                 (nth 0 retval) realm nonce (url-filename href)
-                 (md5 (concat (nth 1 retval) ":" nonce ":"
-                              (nth 2 retval))))))))))
+  "Create a key for digest authentication method.
+The USERNAME and PASSWORD are the credentials for REALM and are
+used in making a hashed value named HA1.  The HTTP METHOD and URI
+makes a second hashed value HA2.  These hashes are used in making
+the authentication key that can be stored without saving the
+password in plain text.  The return value is a list (HA1 HA2).
+
+For backward compatibility, URI is allowed to be a URL cl-struct
+object."
+  (and username password realm
+       (list (url-digest-auth-make-ha1 username realm password)
+             (url-digest-auth-make-ha2 method (cond ((stringp uri) uri)
+                                                    (t (url-filename uri)))))))
+
+(defun url-digest-auth-build-response (key url realm attrs)
+  "Compute authorization string for the given challenge using KEY.
+
+The string looks like 'Digest username=\"John\", realm=\"The
+Realm\", ...'
+
+Part of the challenge is already solved in a pre-computed KEY
+which is list of a realm (or a directory), user name, and hash
+tokens HA1 and HA2.
+
+Some fields are filled as is from the given URL, REALM, and
+using the contents of alist ATTRS.
+
+ATTRS is expected to contain at least the server's \"nonce\"
+value.  It also might contain the optional \"opaque\" value.
+Newer implementations conforming to RFC 2617 should also contain
+qop (Quality Of Protection) and related attributes.
+
+Restrictions on Quality of Protection scheme: The qop value
+\"auth-int\" or algorithm any other than \"MD5\" are not
+implemented."
+
+  (when key
+    (let ((user (nth 1 key))
+          (ha1 (nth 2 key))
+          (ha2 (nth 3 key))
+          (digest-uri (url-filename url))
+          (qop (cdr-safe (assoc "qop" attrs)))
+          (nonce (cdr-safe (assoc "nonce" attrs)))
+          (opaque (cdr-safe (assoc "opaque" attrs))))
+
+      (concat
+       "Digest "
+       (url-digest-auth-name-value-string
+        (append (list (cons 'username user)
+                      (cons 'realm realm)
+                      (cons 'nonce nonce)
+                      (cons 'uri digest-uri))
+
+                (cond
+                 ((null qop)
+                  (list (cons 'response (url-digest-auth-make-request-digest
+                                         ha1 ha2 nonce))))
+                 ((string= qop "auth")
+                  (let ((nc (url-digest-auth-nonce-count nonce))
+                        (cnonce (url-digest-auth-make-cnonce)))
+                    (list (cons 'qop qop)
+                          (cons 'nc nc)
+                          (cons 'cnonce cnonce)
+                          (cons 'response
+                                (url-digest-auth-make-request-digest-qop
+                                 qop ha1 ha2 nonce nc cnonce)))))
+                 (t (message "Quality of protection \"%s\" is not implemented." qop)
+                    nil))
+
+
+                (if opaque (list (cons 'opaque opaque)))))))))
+
+(defun url-digest-find-creds (url prompt &optional realm)
+  "Find or ask credentials for URL.
+
+Primary method for finding credentials is from Emacs auth-source.
+If password isn't found, and PROMPT is non-nil, query credentials
+via minibuffer.  Optional REALM may be used when prompting as a
+hint to the user.
+
+Return value is nil in case either user name or password wasn't
+found.  Otherwise, it's a plist containing `:user' and `:secret'.
+Additional `:source' property denotes the origin of the
+credentials and its value can be either symbol `authsource' or
+`interactive'."
+  (let ((creds (url-digest-auth-source-creds url)))
+
+    ;; If credentials weren't found and prompting is allowed, prompt
+    ;; the user.
+    (if (and prompt
+             (or (null creds)
+                 (null (plist-get creds :secret))))
+        (progn
+          (setq creds (url-digest-prompt-creds url realm creds))
+          (plist-put creds :source 'interactive))
+      (plist-put creds :source 'authsource))
+
+    (and (plist-get creds :user)
+         (plist-get creds :secret)
+         creds)))
+
+(defun url-digest-find-new-key (url realm prompt)
+  "Find credentials and create a new authorization key for given URL and REALM.
+
+Return value is the new key, or nil if credentials weren't found.
+\"New\" in this context means a key that's not yet found in cache
+variable `url-digest-auth-storage'.  You may use `url-digest-cache-key'
+to put it there.
+
+This function uses `url-digest-find-creds' to find the
+credentials.  It first looks in auth-source.  If not found, and
+PROMPT is non-nil, user is asked for credentials interactively
+via minibuffer."
+  (let (creds)
+    (unwind-protect
+        (if (setq creds (url-digest-find-creds url prompt realm))
+            (cons (url-digest-auth-directory-id url realm)
+                  (cons (plist-get creds :user)
+                        (url-digest-auth-create-key
+                         (plist-get creds :user)
+                         (plist-get creds :secret)
+                         realm
+                         (or url-request-method "GET")
+                         (url-filename url)))))
+      (if (and creds
+               ;; Don't clear secret for `authsource' since it will
+               ;; corrupt any future fetches for it.
+               (not (eq (plist-get creds :source) 'authsource)))
+          (clear-string (plist-get creds :secret))))))
+
+(defun url-digest-auth (url &optional prompt overwrite realm attrs)
+  "Get the HTTP Digest response string for the specified URL.
+
+If optional argument PROMPT is non-nil, ask for the username and
+password to use for the URL and its descendants but only if one
+cannot be found from cache.  Look also in Emacs auth-source.
+
+If optional third argument OVERWRITE is non-nil, overwrite the
+old credentials, if they're found in cache, with new ones from
+user prompt or from Emacs auth-source.
+
+If REALM is specified, use that instead of the URL descendant
+method to match cached credentials.
+
+Alist ATTRS contains additional attributes for the authentication
+challenge such as nonce and opaque."
+  (if attrs
+      (let* ((href (if (stringp url) (url-generic-parse-url url) url))
+             (enable-recursive-minibuffers t)
+             (key (url-digest-cached-key href realm)))
+
+        (if (or (null key) overwrite)
+            (let ((newkey (url-digest-find-new-key href realm (cond
+                                                               (key nil)
+                                                               (t prompt)))))
+              (if (and newkey key overwrite)
+                  (setcdr key (cdr newkey))
+                (if (and newkey (null key))
+                    (url-digest-cache-key (setq key newkey) href)))))
+
+        (if key
+            (url-digest-auth-build-response key href realm attrs)))))
 
 (defvar url-registered-auth-schemes nil
   "A list of the registered authorization schemes and various and sundry
diff --git a/lisp/url/url-domsuf.el b/lisp/url/url-domsuf.el
index 25a6a423eb4..b24f24531a6 100644
--- a/lisp/url/url-domsuf.el
+++ b/lisp/url/url-domsuf.el
@@ -89,7 +89,7 @@
 
 ;; Tests:
 
-;; TODO convert to a proper test/automated test.
+;; TODO convert to a proper test.
 ;; (url-domsuf-cookie-allowed-p "com") => nil
 ;; (url-domsuf-cookie-allowed-p "foo.bar.bd") => t
 ;; (url-domsuf-cookie-allowed-p "bar.bd") => nil
diff --git a/lisp/vc/diff-mode.el b/lisp/vc/diff-mode.el
index 31c33e6a720..aa8d77882ec 100644
--- a/lisp/vc/diff-mode.el
+++ b/lisp/vc/diff-mode.el
@@ -504,7 +504,7 @@ See http://lists.gnu.org/archive/html/emacs-devel/2007-11/msg01990.html")
 ;; "index ", "old mode", "new mode", "new file mode" and
 ;; "deleted file mode" are output by git-diff.
 (defconst diff-file-junk-re
-  (concat "Index: \\|=\\{20,\\}\\|" ; SVN
+  (concat "Index: \\|Prereq: \\|=\\{20,\\}\\|" ; SVN
           "diff \\|index \\|\\(?:deleted file\\|new\\(?: file\\)?\\|old\\) mode\\|=== modified file"))
 
 ;; If point is in a diff header, then return beginning
diff --git a/lisp/vc/ediff-ptch.el b/lisp/vc/ediff-ptch.el
index 9d2ec51b596..36aebf4aed1 100644
--- a/lisp/vc/ediff-ptch.el
+++ b/lisp/vc/ediff-ptch.el
@@ -25,6 +25,8 @@
 ;;; Code:
 
 
+(require 'diff-mode) ; For `diff-file-junk-re'.
+
 (provide 'ediff-ptch)
 
 (defgroup ediff-ptch nil
@@ -225,14 +227,11 @@ program."
                         (if (and beg2 end2)
                             (buffer-substring beg2 end2)
                           "/dev/null")))
-            ;; check for any `Index:' or `Prereq:' lines, but don't use them
-            (if (re-search-backward "^Index:" mark1-end 'noerror)
-                (move-marker mark2 (match-beginning 0)))
-            (if (re-search-backward "^Prereq:" mark1-end 'noerror)
-                (move-marker mark2 (match-beginning 0)))
-
+            ;; Remove file junk (Bug#26084).
+            (while (re-search-backward
+                    (concat "^" diff-file-junk-re) mark1-end t)
+                (move-marker mark2 (match-beginning 0)))
             (goto-char mark2-end)
-
             (if filenames
                 (setq patch-map
                       (cons (ediff-make-new-meta-list-element