26 files changed, 769 insertions, 218 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 5451abc2119..6b99c5719bb 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,118 @@
+2013-07-19  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * net/shr.el (shr-mouse-browse-url): New command and keystroke
+        (bug#14815).
+
+        * net/eww.el (eww-process-text-input): Allow inputting when the
+        point is at the start of the line, as the properties aren't
+        front-sticky.
+
+        * net/shr.el (shr-make-table-1): Ensure that we don't infloop on
+        degenerate widths.
+
+2013-07-19  Richard Stallman  <rms@gnu.org>
+
+        * epa.el (epa-popup-info-window): Doc fix.
+
+        * subr.el (split-string): New arg TRIM.
+
+2013-07-18  Juanma Barranquero  <lekktu@gmail.com>
+
+        * frame.el (blink-cursor-timer-function, blink-cursor-suspend):
+        Add check for W32 (followup to 2013-07-16T11:41:06Z!jan.h.d@swipnet.se).
+
+2013-07-18  Michael Albinus  <michael.albinus@gmx.de>
+
+        * filenotify.el (file-notify--library): Rename from
+        `file-notify-support'.  Do not autoload.  Adapt all uses.
+        (file-notify-supported-p): New defun.
+
+        * autorevert.el (auto-revert-use-notify):
+        Use `file-notify-supported-p' instead of `file-notify-support'.
+        Adapt docstring.
+        (auto-revert-notify-add-watch): Use `file-notify-supported-p'.
+
+        * net/tramp.el (tramp-file-name-for-operation):
+        Add `file-notify-supported-p'.
+
+        * net/tramp-sh.el (tramp-sh-handle-file-notify-supported-p):
+        New defun.
+        (tramp-sh-file-name-handler-alist): Add it as handler for
+        `file-notify-supported-p '.
+
+        * net/tramp-adb.el (tramp-adb-file-name-handler-alist):
+        * net/tramp-gvfs.el (tramp-gvfs-file-name-handler-alist):
+        * net/tramp-smb.el (tramp-smb-file-name-handler-alist):
+        Add `ignore' as handler for `file-notify-*' functions.
+
+2013-07-17  Eli Zaretskii  <eliz@gnu.org>
+
+        * simple.el (line-move-partial, line-move): Don't start vscroll or
+        scroll-up if the current line is not taller than the window.
+        (Bug#14881)
+
+2013-07-16  Dmitry Gutov  <dgutov@yandex.ru>
+
+        * progmodes/ruby-mode.el (ruby-font-lock-keywords): Do not
+        highlight question marks in the method names as strings.
+        (ruby-block-beg-keywords): Inline.
+        (ruby-font-lock-keyword-beg-re): Extract from
+        `ruby-font-lock-keywords'.
+
+2013-07-16  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * frame.el (blink-cursor-blinks): New defcustom.
+        (blink-cursor-blinks-done): New defvar.
+        (blink-cursor-start): Set blink-cursor-blinks-done to 1.
+        (blink-cursor-timer-function): Check if number of blinks has been
+        done on X and NS.
+        (blink-cursor-suspend, blink-cursor-check): New defuns.
+
+2013-07-15  Glenn Morris  <rgm@gnu.org>
+
+        * edmacro.el (edmacro-format-keys): Fix previous change.
+
+2013-07-15  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * shell.el (explicit-bash-args): Remove obsolete hack for Bash 1.x.
+        The hack didn't work outside English locales anyway.
+
+2013-07-15  Juanma Barranquero  <lekktu@gmail.com>
+
+        * simple.el (define-alternatives): Rename from alternatives-define,
+        per RMS' suggestion.
+
+2013-07-14  Juanma Barranquero  <lekktu@gmail.com>
+
+        * desktop.el (desktop-restore-frames): Change default to t.
+        (desktop-restore-in-current-display): Now offer more options.
+        (desktop-restoring-reuses-frames): New customization option.
+        (desktop--saved-states): Doc fix.
+        (desktop-filter-parameters-alist): New variable, renamed and expanded
+        from desktop--excluded-frame-parameters.
+        (desktop--target-display): New variable.
+        (desktop-switch-to-gui-p, desktop-switch-to-tty-p)
+        (desktop--filter-tty*, desktop--filter-*-color)
+        (desktop--filter-minibuffer, desktop--filter-restore-desktop-parm)
+        (desktop--filter-save-desktop-parm)
+        (desktop-restore-in-original-display-p): New functions.
+        (desktop--filter-frame-parms): Use new desktop-filter-parameters-alist.
+        (desktop--save-minibuffer-frames): New function, inspired by a similar
+        function from Martin Rudalics.
+        (desktop--save-frames): Call it; play nice with desktop-globals-to-save.
+        (desktop--restore-in-this-display-p): Remove.
+        (desktop--find-frame): Rename from desktop--find-frame-in-display
+        and add predicate argument.
+        (desktop--make-full-frame): Remove, integrated into desktop--make-frame.
+        (desktop--reuse-list): New variable.
+        (desktop--select-frame, desktop--make-frame, desktop--sort-states):
+        New functions.
+        (desktop--restore-frames): Add support for "minibuffer-special" frames.
+
+2013-07-14  Michael Albinus  <michael.albinus@gmx.de>
+
+        * net/tramp-sh.el (tramp-sh-handle-vc-registered): Use `ignore-error'.
+
 2013-07-13  Dmitry Gutov  <dgutov@yandex.ru>
 
         * progmodes/ruby-mode.el (ruby-font-lock-keywords): Highlight
@@ -3475,8 +3590,8 @@
         (prolog-char-quote-workaround):
         * progmodes/cperl-mode.el (cperl-under-as-char):
         * progmodes/vhdl-mode.el (vhdl-underscore-is-part-of-word):
-         Mark as obsolete.
-         (vhdl-mode-syntax-table, vhdl-mode-ext-syntax-table): Initialize in
+        Mark as obsolete.
+        (vhdl-mode-syntax-table, vhdl-mode-ext-syntax-table): Initialize in
         their declaration.
         (vhdl-mode-syntax-table-init): Remove.
 
diff --git a/lisp/autorevert.el b/lisp/autorevert.el
index 00e88fc4a3d..5c593e2ef71 100644
--- a/lisp/autorevert.el
+++ b/lisp/autorevert.el
@@ -271,21 +271,20 @@ This variable becomes buffer local when set in any fashion.")
   :type 'boolean
   :version "24.4")
 
-(defcustom auto-revert-use-notify (and file-notify-support t)
+(defcustom auto-revert-use-notify
+  ;; We use the support of the local filesystem as default.
+  (file-notify-supported-p temporary-file-directory)
   "If non-nil Auto Revert Mode uses file notification functions.
-This requires Emacs being compiled with file notification
-support (see `file-notify-support').  You should set this variable
-through Custom."
+You should set this variable through Custom."
   :group 'auto-revert
   :type 'boolean
   :set (lambda (variable value)
-         (set-default variable (and file-notify-support value))
+         (set-default variable value)
          (unless (symbol-value variable)
-           (when file-notify-support
-             (dolist (buf (buffer-list))
-               (with-current-buffer buf
-                 (when (symbol-value 'auto-revert-notify-watch-descriptor)
-                   (auto-revert-notify-rm-watch)))))))
+           (dolist (buf (buffer-list))
+             (with-current-buffer buf
+               (when (symbol-value 'auto-revert-notify-watch-descriptor)
+                 (auto-revert-notify-rm-watch))))))
   :initialize 'custom-initialize-default
   :version "24.4")
 
@@ -513,7 +512,8 @@ will use an up-to-date value of `auto-revert-interval'"
     (set (make-local-variable 'auto-revert-use-notify) nil))
 
   (when (and buffer-file-name auto-revert-use-notify
-             (not auto-revert-notify-watch-descriptor))
+             (not auto-revert-notify-watch-descriptor)
+             (file-notify-supported-p buffer-file-name))
     (setq auto-revert-notify-watch-descriptor
           (ignore-errors
             (file-notify-add-watch
diff --git a/lisp/cedet/semantic/bovine/el.el b/lisp/cedet/semantic/bovine/el.el
index 07e0e08bbaf..0bbe3c61d76 100644
--- a/lisp/cedet/semantic/bovine/el.el
+++ b/lisp/cedet/semantic/bovine/el.el
@@ -474,7 +474,7 @@ Return a bovination list to use."
        ((and name (file-exists-p (concat name ".el.gz")))
         ;; This is the linux distro case.
         (concat name ".el.gz"))
-       ;; source file does not exists
+       ;; Source file does not exist.
        (name
         (message "semantic: cannot find source file %s" (concat name ".el")))
        (t
diff --git a/lisp/desktop.el b/lisp/desktop.el
index fcd032a64d0..e62307d5959 100644
--- a/lisp/desktop.el
+++ b/lisp/desktop.el
@@ -33,6 +33,7 @@
 ;;              - the mark & mark-active
 ;;              - buffer-read-only
 ;;              - some local variables
+;;      - frame and window configuration
 
 ;; To use this, use customize to turn on desktop-save-mode or add the
 ;; following line somewhere in your init file:
@@ -127,7 +128,6 @@
 ;; ---------------------------------------------------------------------------
 ;; TODO:
 ;;
-;; Save window configuration.
 ;; Recognize more minor modes.
 ;; Save mark rings.
 
@@ -369,16 +369,29 @@ modes are restored automatically; they should not be listed here."
   :type '(repeat symbol)
   :group 'desktop)
 
-(defcustom desktop-restore-frames nil
+(defcustom desktop-restore-frames t
   "When non-nil, save window/frame configuration to desktop file."
   :type 'boolean
   :group 'desktop
   :version "24.4")
 
 (defcustom desktop-restore-in-current-display nil
-  "When non-nil, frames are restored in the current display.
-Otherwise they are restored, if possible, in their original displays."
-  :type 'boolean
+  "If t, frames are restored in the current display.
+If nil, frames are restored, if possible, in their original displays.
+If `delete', frames on other displays are deleted instead of restored."
+  :type '(choice (const :tag "Restore in current display" t)
+                 (const :tag "Restore in original display" nil)
+                 (const :tag "Delete frames in other displays" 'delete))
+  :group 'desktop
+  :version "24.4")
+
+(defcustom desktop-restoring-reuses-frames t
+  "If t, restoring frames reuses existing frames.
+If nil, existing frames are deleted.
+If `keep', existing frames are kept and not reused."
+  :type '(choice (const :tag "Reuse existing frames" t)
+                 (const :tag "Delete existing frames" nil)
+                 (const :tag "Keep existing frames" 'keep))
   :group 'desktop
   :version "24.4")
 
@@ -566,7 +579,7 @@ DIRNAME omitted or nil means use `desktop-dirname'."
 Used to avoid writing contents unchanged between auto-saves.")
 
 (defvar desktop--saved-states nil
-  "Internal use only.")
+  "Saved window/frame state.  Internal use only.")
 
 ;; ----------------------------------------------------------------------------
 ;; Desktop file conflict detection
@@ -869,30 +882,193 @@ DIRNAME must be the directory in which the desktop file will be saved."
 
 
 ;; ----------------------------------------------------------------------------
-(defconst desktop--excluded-frame-parameters
-  '(buffer-list
-    buffer-predicate
-    buried-buffer-list
-    explicit-name
-    font
-    font-backend
-    minibuffer
-    name
-    outer-window-id
-    parent-id
-    window-id
-    window-system)
-  "Frame parameters not saved or restored.")
-
-(defun desktop--filter-frame-parms (frame)
-  "Return frame parameters of FRAME.
-Parameters in `desktop--excluded-frame-parameters' are excluded.
+(defvar desktop-filter-parameters-alist
+  '((background-color   . desktop--filter-*-color)
+    (buffer-list        . t)
+    (buffer-predicate   . t)
+    (buried-buffer-list . t)
+    (desktop-font       . desktop--filter-restore-desktop-parm)
+    (desktop-fullscreen . desktop--filter-restore-desktop-parm)
+    (desktop-height     . desktop--filter-restore-desktop-parm)
+    (desktop-width      . desktop--filter-restore-desktop-parm)
+    (font               . desktop--filter-save-desktop-parm)
+    (font-backend       . t)
+    (foreground-color   . desktop--filter-*-color)
+    (fullscreen         . desktop--filter-save-desktop-parm)
+    (height             . desktop--filter-save-desktop-parm)
+    (minibuffer         . desktop--filter-minibuffer)
+    (name               . t)
+    (outer-window-id    . t)
+    (parent-id          . t)
+    (tty                . desktop--filter-tty*)
+    (tty-type           . desktop--filter-tty*)
+    (width              . desktop--filter-save-desktop-parm)
+    (window-id          . t)
+    (window-system      . t))
+  "Alist of frame parameters and filtering functions.
+
+Each element is a cons (PARAM . FILTER), where PARAM is a parameter
+name (a symbol identifying a frame parameter), and FILTER can be t
+\(meaning the parameter is removed from the parameter list on saving
+and restoring), or a function that will be called with three args:
+
+ CURRENT     a cons (PARAM . VALUE), where PARAM is the one being
+             filtered and VALUE is its current value
+ PARAMETERS  the complete alist of parameters being filtered
+ SAVING      non-nil if filtering before saving state, nil otherwise
+
+The FILTER function must return:
+ nil                  CURRENT is removed from the list
+ t                    CURRENT is left as is
+ (PARAM' . VALUE')    replace CURRENT with this
+
+Frame parameters not on this list are passed intact.")
+
+(defvar desktop--target-display nil
+  "Either (minibuffer . VALUE) or nil.
+This refers to the current frame config being processed inside
+`frame--restore-frames' and its auxiliary functions (like filtering).
+If nil, there is no need to change the display.
+If non-nil, display parameter to use when creating the frame.
+Internal use only.")
+
+(defun desktop-switch-to-gui-p (parameters)
+  "True when switching to a graphic display.
+Return t if PARAMETERS describes a text-only terminal and
+the target is a graphic display; otherwise return nil.
+Only meaningful when called from a filtering function in
+`desktop-filter-parameters-alist'."
+  (and desktop--target-display                 ; we're switching
+       (null (cdr (assq 'display parameters))) ; from a tty
+       (cdr desktop--target-display)))         ; to a GUI display
+
+(defun desktop-switch-to-tty-p (parameters)
+  "True when switching to a text-only terminal.
+Return t if PARAMETERS describes a graphic display and
+the target is a text-only terminal; otherwise return nil.
+Only meaningful when called from a filtering function in
+`desktop-filter-parameters-alist'."
+  (and desktop--target-display                 ; we're switching
+       (cdr (assq 'display parameters))        ; from a GUI display
+       (null (cdr desktop--target-display))))  ; to a tty
+
+(defun desktop--filter-tty* (_current parameters saving)
+  ;; Remove tty and tty-type parameters when switching
+  ;; to a GUI frame.
+  (or saving
+      (not (desktop-switch-to-gui-p parameters))))
+
+(defun desktop--filter-*-color (current parameters saving)
+  ;; Remove (foreground|background)-color parameters
+  ;; when switching to a GUI frame if they denote an
+  ;; "unspecified" color.
+  (or saving
+      (not (desktop-switch-to-gui-p parameters))
+      (not (stringp (cdr current)))
+      (not (string-match-p "^unspecified-[fb]g$" (cdr current)))))
+
+(defun desktop--filter-minibuffer (current _parameters saving)
+  ;; When minibuffer is a window, save it as minibuffer . t
+  (or (not saving)
+      (if (windowp (cdr current))
+          '(minibuffer . t)
+        t)))
+
+(defun desktop--filter-restore-desktop-parm (current parameters saving)
+  ;; When switching to a GUI frame, convert desktop-XXX parameter to XXX
+  (or saving
+      (not (desktop-switch-to-gui-p parameters))
+      (let ((val (cdr current)))
+        (if (eq val :desktop-processed)
+            nil
+          (cons (intern (substring (symbol-name (car current))
+                                   8)) ;; (length "desktop-")
+                val)))))
+
+(defun desktop--filter-save-desktop-parm (current parameters saving)
+  ;; When switching to a tty frame, save parameter XXX as desktop-XXX so it
+  ;; can be restored in a subsequent GUI session, unless it already exists.
+  (cond (saving t)
+        ((desktop-switch-to-tty-p parameters)
+         (let ((sym (intern (format "desktop-%s" (car current)))))
+           (if (assq sym parameters)
+               nil
+             (cons sym (cdr current)))))
+        ((desktop-switch-to-gui-p parameters)
+         (let* ((dtp (assq (intern (format "desktop-%s" (car current)))
+                           parameters))
+                (val (cdr dtp)))
+           (if (eq val :desktop-processed)
+               nil
+             (setcdr dtp :desktop-processed)
+             (cons (car current) val))))
+        (t t)))
+
+(defun desktop-restore-in-original-display-p ()
+  "True if saved frames' displays should be honored."
+  (cond ((daemonp) t)
+        ((eq system-type 'windows-nt) nil)
+        (t (null desktop-restore-in-current-display))))
+
+(defun desktop--filter-frame-parms (parameters saving)
+  "Filter frame parameters and return filtered list.
+PARAMETERS is a parameter alist as returned by `frame-parameters'.
+If SAVING is non-nil, filtering is happening before saving frame state;
+otherwise, filtering is being done before restoring frame state.
+Parameters are filtered according to the setting of
+`desktop-filter-parameters-alist' (which see).
 Internal use only."
-  (let (params)
-    (dolist (param (frame-parameters frame))
-      (unless (memq (car param) desktop--excluded-frame-parameters)
-        (push param params)))
-    params))
+  (let ((filtered nil))
+    (dolist (param parameters)
+      (let ((filter (cdr (assq (car param) desktop-filter-parameters-alist)))
+            this)
+        (cond (;; no filter: pass param
+               (null filter)
+               (push param filtered))
+              (;; filter = t; skip param
+               (eq filter t))
+              (;; filter func returns nil: skip param
+               (null (setq this (funcall filter param parameters saving))))
+              (;; filter func returns t: pass param
+               (eq this t)
+               (push param filtered))
+              (;; filter func returns a new param: use it
+               t
+               (push this filtered)))))
+    ;; Set the display parameter after filtering, so that filter functions
+    ;; have access to its original value.
+    (when desktop--target-display
+      (let ((display (assq 'display filtered)))
+        (if display
+            (setcdr display (cdr desktop--target-display))
+          (push desktop--target-display filtered))))
+    filtered))
+
+(defun desktop--save-minibuffer-frames ()
+  ;; Adds a desktop-mini parameter to frames
+  ;; desktop-mini is a list (MINIBUFFER NUMBER DEFAULT?) where
+  ;; MINIBUFFER  t if the frame (including minibuffer-only) owns a minibuffer
+  ;; NUMBER      if MINIBUFFER = t, an ID for the frame; if nil, the ID of
+  ;;             the frame containing the minibuffer used by this frame
+  ;; DEFAULT?    if t, this frame is the value of default-minibuffer-frame
+  ;;             FIXME: What happens with multi-terminal sessions?
+  (let ((frames (frame-list))
+        (count 0))
+    ;; Reset desktop-mini for all frames
+    (dolist (frame frames)
+      (set-frame-parameter frame 'desktop-mini nil))
+    ;; Number all frames with its own minibuffer
+    (dolist (frame (minibuffer-frame-list))
+      (set-frame-parameter frame 'desktop-mini
+                           (list t
+                                 (setq count (1+ count))
+                                 (eq frame default-minibuffer-frame))))
+    ;; Now link minibufferless frames with their minibuffer frames
+    (dolist (frame frames)
+      (unless (frame-parameter frame 'desktop-mini)
+        (let* ((mb-frame (window-frame (minibuffer-window frame)))
+               (this (cadr (frame-parameter mb-frame 'desktop-mini))))
+          (set-frame-parameter frame 'desktop-mini (list nil this nil)))))))
 
 (defun desktop--save-frames ()
   "Save window/frame state, as a global variable.
@@ -900,12 +1076,14 @@ Intended to be called from `desktop-save'.
 Internal use only."
   (setq desktop--saved-states
         (and desktop-restore-frames
-             (mapcar (lambda (frame)
-                       (cons (desktop--filter-frame-parms frame)
-                             (window-state-get (frame-root-window frame) t)))
-                     (cons (selected-frame)
-                           (delq (selected-frame) (frame-list))))))
-  (desktop-outvar 'desktop--saved-states))
+             (progn
+               (desktop--save-minibuffer-frames)
+               (mapcar (lambda (frame)
+                         (cons (desktop--filter-frame-parms (frame-parameters frame) t)
+                               (window-state-get (frame-root-window frame) t)))
+                       (frame-list)))))
+  (unless (memq 'desktop--saved-states desktop-globals-to-save)
+    (desktop-outvar 'desktop--saved-states)))
 
 ;;;###autoload
 (defun desktop-save (dirname &optional release auto-save)
@@ -1006,71 +1184,220 @@ This function also sets `desktop-dirname' to nil."
 (defvar desktop-lazy-timer nil)
 
 ;; ----------------------------------------------------------------------------
-(defun desktop--restore-in-this-display-p ()
-  (or desktop-restore-in-current-display
-      (and (eq system-type 'windows-nt) (not (display-graphic-p)))))
-
-(defun desktop--find-frame-in-display (frames display)
-  (let (result)
-    (while (and frames (not result))
-      (if (equal display (frame-parameter (car frames) 'display))
-          (setq result (car frames))
-        (setq frames (cdr frames))))
-    result))
-
-(defun desktop--make-full-frame (full display config)
-  (let ((width (and (eq full 'fullheight) (cdr (assq 'width config))))
-        (height (and (eq full 'fullwidth) (cdr (assq 'height config))))
-        (params '((visibility)))
+(defvar desktop--reuse-list nil
+  "Internal use only.")
+
+(defun desktop--find-frame (predicate display &rest args)
+  "Find a suitable frame in `desktop--reuse-list'.
+Look through frames whose display property matches DISPLAY and
+return the first one for which (PREDICATE frame ARGS) returns t.
+If PREDICATE is nil, it is always satisfied.  Internal use only.
+This is an auxiliary function for `desktop--select-frame'."
+  (catch :found
+    (dolist (frame desktop--reuse-list)
+      (when (and (equal (frame-parameter frame 'display) display)
+                 (or (null predicate)
+                     (apply predicate frame args)))
+        (throw :found frame)))
+    nil))
+
+(defun desktop--select-frame (display frame-cfg)
+  "Look for an existing frame to reuse.
+DISPLAY is the display where the frame will be shown, and FRAME-CFG
+is the parameter list of the frame being restored.  Internal use only."
+  (if (eq desktop-restoring-reuses-frames t)
+      (let ((frame nil)
+            mini)
+        ;; There are no fancy heuristics there.  We could implement some
+        ;; based on frame size and/or position, etc., but it is not clear
+        ;; that any "gain" (in the sense of reduced flickering, etc.) is
+        ;; worth the added complexity.  In fact, the code below mainly
+        ;; tries to work nicely when M-x desktop-read is used after a desktop
+        ;; session has already been loaded.  The other main use case, which
+        ;; is the initial desktop-read upon starting Emacs, should usually
+        ;; only have one, or very few, frame(s) to reuse.
+        (cond (;; When the target is tty, every existing frame is reusable.
+               (null display)
+               (setq frame (desktop--find-frame nil display)))
+              (;; If the frame has its own minibuffer, let's see whether
+               ;; that frame has already been loaded (which can happen after
+               ;; M-x desktop-read).
+               (car (setq mini (cdr (assq 'desktop-mini frame-cfg))))
+               (setq frame (or (desktop--find-frame
+                                (lambda (f m)
+                                  (equal (frame-parameter f 'desktop-mini) m))
+                                display mini))))
+              (;; For minibufferless frames, check whether they already exist,
+               ;; and that they are linked to the right minibuffer frame.
+               mini
+               (setq frame (desktop--find-frame
+                            (lambda (f n)
+                              (let ((m (frame-parameter f 'desktop-mini)))
+                                (and m
+                                     (null (car m))
+                                     (= (cadr m) n)
+                                     (equal (cadr (frame-parameter
+                                                   (window-frame (minibuffer-window f))
+                                                   'desktop-mini))
+                                            n))))
+                            display (cadr mini))))
+              (;; Default to just finding a frame in the same display.
+               t
+               (setq frame (desktop--find-frame nil display))))
+        ;; If found, remove from the list.
+        (when frame
+          (setq desktop--reuse-list (delq frame desktop--reuse-list)))
         frame)
-    (when width
-      (setq params (append `((user-size . t) (width . ,width)) params)
-            config (assq-delete-all 'height config)))
-    (when height
-      (setq params (append `((user-size . t) (height . ,height)) params)
-            config (assq-delete-all 'width config)))
-    (setq frame (make-frame-on-display display params))
-    (modify-frame-parameters frame config)
+    nil))
+
+(defun desktop--make-frame (frame-cfg window-cfg)
+  "Set up a frame according to its saved state.
+That means either creating a new frame or reusing an existing one.
+FRAME-CFG is the parameter list of the new frame; WINDOW-CFG is
+its window state.  Internal use only."
+  (let* ((fullscreen (cdr (assq 'fullscreen frame-cfg)))
+         (lines (assq 'tool-bar-lines frame-cfg))
+         (filtered-cfg (desktop--filter-frame-parms frame-cfg nil))
+         (display (cdr (assq 'display filtered-cfg))) ;; post-filtering
+         alt-cfg frame)
+
+    ;; This works around bug#14795 (or feature#14795, if not a bug :-)
+    (setq filtered-cfg (assq-delete-all 'tool-bar-lines filtered-cfg))
+    (push '(tool-bar-lines . 0) filtered-cfg)
+
+    (when fullscreen
+      ;; Currently Emacs has the limitation that it does not record the size
+      ;; and position of a frame before maximizing it, so we cannot save &
+      ;; restore that info.  Instead, when restoring, we resort to creating
+      ;; invisible "fullscreen" frames of default size and then maximizing them
+      ;; (and making them visible) which at least is somewhat user-friendly
+      ;; when these frames are later de-maximized.
+      (let ((width (and (eq fullscreen 'fullheight) (cdr (assq 'width filtered-cfg))))
+            (height (and (eq fullscreen 'fullwidth) (cdr (assq 'height filtered-cfg))))
+            (visible (assq 'visibility filtered-cfg)))
+        (dolist (parameter '(visibility fullscreen width height))
+          (setq filtered-cfg (assq-delete-all parameter filtered-cfg)))
+        (when width
+          (setq filtered-cfg (append `((user-size . t) (width . ,width))
+                                       filtered-cfg)))
+        (when height
+          (setq filtered-cfg (append `((user-size . t) (height . ,height))
+                                     filtered-cfg)))
+        ;; These are parameters to apply after creating/setting the frame.
+        (push visible alt-cfg)
+        (push (cons 'fullscreen fullscreen) alt-cfg)))
+
+    ;; Time to select or create a frame an apply the big bunch of parameters
+    (if (setq frame (desktop--select-frame display filtered-cfg))
+        (modify-frame-parameters frame filtered-cfg)
+      (setq frame (make-frame-on-display display filtered-cfg)))
+
+    ;; Let's give the finishing touches (visibility, tool-bar, maximization).
+    (when lines (push lines alt-cfg))
+    (when alt-cfg (modify-frame-parameters frame alt-cfg))
+    ;; Now restore window state.
+    (window-state-put window-cfg (frame-root-window frame) 'safe)
     frame))
 
+(defun desktop--sort-states (state1 state2)
+  ;; Order: default minibuffer frame
+  ;;        other frames with minibuffer, ascending ID
+  ;;        minibufferless frames, ascending ID
+  (let ((dm1 (cdr (assq 'desktop-mini (car state1))))
+        (dm2 (cdr (assq 'desktop-mini (car state2)))))
+    (cond ((nth 2 dm1) t)
+          ((nth 2 dm2) nil)
+          ((null (car dm2)) t)
+          ((null (car dm1)) nil)
+          (t (< (cadr dm1) (cadr dm2))))))
+
 (defun desktop--restore-frames ()
   "Restore window/frame configuration.
 Internal use only."
   (when (and desktop-restore-frames desktop--saved-states)
-    (let ((frames (frame-list))
-          (current (frame-parameter nil 'display))
-          (selected nil))
+    (let* ((frame-mb-map nil) ;; Alist of frames with their own minibuffer
+           (visible nil)
+           (delete-saved (eq desktop-restore-in-current-display 'delete))
+           (forcing (not (desktop-restore-in-original-display-p)))
+           (target (and forcing (cons 'display (frame-parameter nil 'display)))))
+
+      ;; Sorting saved states allows us to easily restore minibuffer-owning frames
+      ;; before minibufferless ones.
+      (setq desktop--saved-states (sort desktop--saved-states #'desktop--sort-states))
+      ;; Potentially all existing frames are reusable.  Later we will decide which ones
+      ;; to reuse, and how to deal with any leftover.
+      (setq desktop--reuse-list (frame-list))
+
       (dolist (state desktop--saved-states)
         (condition-case err
-            (let* ((config (car state))
-                   (display (if (desktop--restore-in-this-display-p)
-                                (setcdr (assq 'display config) current)
-                              (cdr (assq 'display config))))
-                   (full (cdr (assq 'fullscreen config)))
-                   (frame (and (not full)
-                               (desktop--find-frame-in-display frames display))))
-              (cond (full
-                     ;; treat fullscreen/maximized frames specially
-                     (setq frame (desktop--make-full-frame full display config)))
-                    (frame
-                     ;; found a frame in the right display -- reuse
-                     (setq frames (delq frame frames))
-                     (modify-frame-parameters frame config))
-                    (t
-                     ;; no frames in the display -- make a new one
-                     (setq frame (make-frame-on-display display config))))
-              ;; restore windows
-              (window-state-put (cdr state) (frame-root-window frame) 'safe)
-              (unless selected (setq selected frame)))
+            (let* ((frame-cfg (car state))
+                   (window-cfg (cdr state))
+                   (d-mini (cdr (assq 'desktop-mini frame-cfg)))
+                   num frame to-tty)
+              ;; Only set target if forcing displays and the target display is different.
+              (if (or (not forcing)
+                      (equal target (or (assq 'display frame-cfg) '(display . nil))))
+                  (setq desktop--target-display nil)
+                (setq desktop--target-display target
+                      to-tty (null (cdr target))))
+              ;; Time to restore frames and set up their minibuffers as they were.
+              ;; We only skip a frame (thus deleting it) if either:
+              ;; - we're switching displays, and the user chose the option to delete, or
+              ;; - we're switching to tty, and the frame to restore is minibuffer-only.
+              (unless (and desktop--target-display
+                           (or delete-saved
+                               (and to-tty
+                                    (eq (cdr (assq 'minibuffer frame-cfg)) 'only))))
+
+                ;; Restore minibuffers.  Some of this stuff could be done in a filter
+                ;; function, but it would be messy because restoring minibuffers affects
+                ;; global state; it's best to do it here than add a bunch of global
+                ;; variables to pass info back-and-forth to/from the filter function.
+                (cond
+                 ((null d-mini)) ;; No desktop-mini.  Process as normal frame.
+                 (to-tty) ;; Ignore minibuffer stuff and process as normal frame.
+                 ((car d-mini) ;; Frame has its own minibuffer (or it is minibuffer-only).
+                  (setq num (cadr d-mini))
+                  (when (eq (cdr (assq 'minibuffer frame-cfg)) 'only)
+                    (setq frame-cfg (append '((tool-bar-lines . 0) (menu-bar-lines . 0))
+                                            frame-cfg))))
+                 (t ;; Frame depends on other frame's minibufer window.
+                  (let ((mb-frame (cdr (assq (cadr d-mini) frame-mb-map))))
+                    (unless (frame-live-p mb-frame)
+                      (error "Minibuffer frame %s not found" (cadr d-mini)))
+                    (let ((mb-param (assq 'minibuffer frame-cfg))
+                          (mb-window (minibuffer-window mb-frame)))
+                      (unless (and (window-live-p mb-window)
+                                   (window-minibuffer-p mb-window))
+                        (error "Not a minibuffer window %s" mb-window))
+                      (if mb-param
+                          (setcdr mb-param mb-window)
+                        (push (cons 'minibuffer mb-window) frame-cfg))))))
+                ;; OK, we're ready at last to create (or reuse) a frame and
+                ;; restore the window config.
+                (setq frame (desktop--make-frame frame-cfg window-cfg))
+                ;; Set default-minibuffer if required.
+                (when (nth 2 d-mini) (setq default-minibuffer-frame frame))
+                ;; Store frame/NUM to assign to minibufferless frames.
+                (when num (push (cons num frame) frame-mb-map))
+                ;; Try to locate at least one visible frame.
+                (when (and (not visible) (frame-visible-p frame))
+                  (setq visible frame))))
           (error
-           (message "Error restoring frame: %S" (error-message-string err)))))
-      (when selected
-        ;; make sure the original selected frame is visible and selected
-        (unless (or (frame-parameter selected 'visibility) (daemonp))
-          (modify-frame-parameters selected '((visibility . t))))
-        (select-frame-set-input-focus selected)
-        ;; delete any remaining frames
-        (mapc #'delete-frame frames)))))
+           (delay-warning 'desktop (error-message-string err) :error))))
+
+      ;; Delete remaining frames, but do not fail if some resist being deleted.
+      (unless (eq desktop-restoring-reuses-frames 'keep)
+        (dolist (frame desktop--reuse-list)
+          (ignore-errors (delete-frame frame))))
+      (setq desktop--reuse-list nil)
+      ;; Make sure there's at least one visible frame, and select it.
+      (unless (or visible (daemonp))
+        (setq visible (if (frame-live-p default-minibuffer-frame)
+                          default-minibuffer-frame
+                        (car (frame-list))))
+        (make-frame-visible visible)
+        (select-frame-set-input-focus visible)))))
 
 ;;;###autoload
 (defun desktop-read (&optional dirname)
diff --git a/lisp/edmacro.el b/lisp/edmacro.el
index 67992d16527..73662951188 100644
--- a/lisp/edmacro.el
+++ b/lisp/edmacro.el
@@ -562,7 +562,8 @@ doubt, use whitespace."
         (unless (string-match " " desc)
           (let ((times 1) (pos bind-len))
             (while (not (cl-mismatch rest-mac rest-mac
-                                          0 bind-len pos (+ bind-len pos)))
+                                     :start1 0 :end1 bind-len
+                                     :start2 pos :end2 (+ bind-len pos)))
               (cl-incf times)
               (cl-incf pos bind-len))
             (when (> times 1)
diff --git a/lisp/epa.el b/lisp/epa.el
index 14f8879c1c6..68e7a18fe17 100644
--- a/lisp/epa.el
+++ b/lisp/epa.el
@@ -34,8 +34,7 @@
   :group 'epg)
 
 (defcustom epa-popup-info-window t
-  "If non-nil, status information from epa commands is displayed on
-the separate window."
+  "If non-nil, display status information from epa commands in another window."
   :type 'boolean
   :group 'epa)
 
diff --git a/lisp/filenotify.el b/lisp/filenotify.el
index e170db2dd5f..c9a7e106faa 100644
--- a/lisp/filenotify.el
+++ b/lisp/filenotify.el
@@ -27,8 +27,7 @@
 
 ;;; Code:
 
-;;;###autoload
-(defconst file-notify-support
+(defconst file-notify--library
   (cond
    ((featurep 'gfilenotify) 'gfilenotify)
    ((featurep 'inotify) 'inotify)
@@ -191,6 +190,17 @@ car of that event, which is the symbol `file-notify'."
             (funcall callback (list desc action file file1))
           (funcall callback (list desc action file)))))))
 
+(defun file-notify-supported-p (file)
+  "Returns non-nil if filesystem pertaining to FILE could be watched."
+  (unless (stringp file)
+    (signal 'wrong-type-argument (list file)))
+  (setq file (expand-file-name file))
+
+  (let ((handler (find-file-name-handler file 'file-notify-supported-p)))
+    (if handler
+        (funcall handler 'file-notify-supported-p file)
+      (and file-notify--library t))))
+
 (defun file-notify-add-watch (file flags callback)
   "Add a watch for filesystem events pertaining to FILE.
 This arranges for filesystem events pertaining to FILE to be reported
@@ -238,7 +248,7 @@ FILE is the name of the file whose event is being reported."
 
   (let* ((handler (find-file-name-handler file 'file-notify-add-watch))
          (dir (directory-file-name
-               (if (or (and (not handler) (eq file-notify-support 'w32notify))
+               (if (or (and (not handler) (eq file-notify--library 'w32notify))
                        (file-directory-p file))
                    file
                  (file-name-directory file))))
@@ -259,32 +269,32 @@ FILE is the name of the file whose event is being reported."
 
         ;; Check, whether Emacs has been compiled with file
         ;; notification support.
-        (unless file-notify-support
+        (unless file-notify--library
           (signal 'file-notify-error
                   '("No file notification package available")))
 
         ;; Determine low-level function to be called.
         (setq func (cond
-                    ((eq file-notify-support 'gfilenotify) 'gfile-add-watch)
-                    ((eq file-notify-support 'inotify) 'inotify-add-watch)
-                    ((eq file-notify-support 'w32notify) 'w32notify-add-watch)))
+                    ((eq file-notify--library 'gfilenotify) 'gfile-add-watch)
+                    ((eq file-notify--library 'inotify) 'inotify-add-watch)
+                    ((eq file-notify--library 'w32notify) 'w32notify-add-watch)))
 
         ;; Determine respective flags.
-        (if (eq file-notify-support 'gfilenotify)
+        (if (eq file-notify--library 'gfilenotify)
             (setq l-flags '(watch-mounts send-moved))
           (when (memq 'change flags)
             (setq
              l-flags
              (cond
-              ((eq file-notify-support 'inotify) '(create modify move delete))
-              ((eq file-notify-support 'w32notify)
+              ((eq file-notify--library 'inotify) '(create modify move delete))
+              ((eq file-notify--library 'w32notify)
                '(file-name directory-name size last-write-time)))))
           (when (memq 'attribute-change flags)
             (add-to-list
              'l-flags
              (cond
-              ((eq file-notify-support 'inotify) 'attrib)
-              ((eq file-notify-support 'w32notify) 'attributes)))))
+              ((eq file-notify--library 'inotify) 'attrib)
+              ((eq file-notify--library 'w32notify) 'attributes)))))
 
         ;; Call low-level function.
         (setq desc (funcall func dir l-flags 'file-notify-callback))))
@@ -311,9 +321,9 @@ DESCRIPTOR should be an object returned by `file-notify-add-watch'."
           (funcall handler 'file-notify-rm-watch descriptor)
         (funcall
          (cond
-          ((eq file-notify-support 'gfilenotify) 'gfile-rm-watch)
-          ((eq file-notify-support 'inotify) 'inotify-rm-watch)
-          ((eq file-notify-support 'w32notify) 'w32notify-rm-watch))
+          ((eq file-notify--library 'gfilenotify) 'gfile-rm-watch)
+          ((eq file-notify--library 'inotify) 'inotify-rm-watch)
+          ((eq file-notify--library 'w32notify) 'w32notify-rm-watch))
          descriptor)))
 
     (remhash descriptor file-notify-descriptors)))
diff --git a/lisp/frame.el b/lisp/frame.el
index 3ac24a509a0..ed47afa4b94 100644
--- a/lisp/frame.el
+++ b/lisp/frame.el
@@ -1671,6 +1671,16 @@ left untouched.  FRAME nil or omitted means use the selected frame."
   :type 'number
   :group 'cursor)
 
+(defcustom blink-cursor-blinks 10
+  "How many times to blink before using a solid cursor on NS and X.
+Use 0 or negative value to blink forever."
+  :version "24.4"
+  :type 'integer
+  :group 'cursor)
+
+(defvar blink-cursor-blinks-done 1
+  "Number of blinks done since we started blinking on NS and X")
+
 (defvar blink-cursor-idle-timer nil
   "Timer started after `blink-cursor-delay' seconds of Emacs idle time.
 The function `blink-cursor-start' is called when the timer fires.")
@@ -1688,6 +1698,7 @@ command starts, by installing a pre-command hook."
   (when (null blink-cursor-timer)
     ;; Set up the timer first, so that if this signals an error,
     ;; blink-cursor-end is not added to pre-command-hook.
+    (setq blink-cursor-blinks-done 1)
     (setq blink-cursor-timer
           (run-with-timer blink-cursor-interval blink-cursor-interval
                           'blink-cursor-timer-function))
@@ -1696,7 +1707,15 @@ command starts, by installing a pre-command hook."
 
 (defun blink-cursor-timer-function ()
   "Timer function of timer `blink-cursor-timer'."
-  (internal-show-cursor nil (not (internal-show-cursor-p))))
+  (internal-show-cursor nil (not (internal-show-cursor-p)))
+  ;; Each blink is two calls to this function.
+  (when (memq window-system '(x ns w32))
+    (setq blink-cursor-blinks-done (1+ blink-cursor-blinks-done))
+    (when (and (> blink-cursor-blinks 0)
+               (<= (* 2 blink-cursor-blinks) blink-cursor-blinks-done))
+      (blink-cursor-suspend)
+      (add-hook 'post-command-hook 'blink-cursor-check))))
+
 
 (defun blink-cursor-end ()
   "Stop cursor blinking.
@@ -1709,6 +1728,29 @@ itself as a pre-command hook."
     (cancel-timer blink-cursor-timer)
     (setq blink-cursor-timer nil)))
 
+(defun blink-cursor-suspend ()
+  "Suspend cursor blinking on NS, X and W32.
+This is called when no frame has focus and timers can be suspended.
+Timers are restarted by `blink-cursor-check', which is called when a
+frame receives focus."
+  (when (memq window-system '(x ns w32))
+    (blink-cursor-end)
+    (when blink-cursor-idle-timer
+      (cancel-timer blink-cursor-idle-timer)
+      (setq blink-cursor-idle-timer nil))))
+
+(defun blink-cursor-check ()
+  "Check if cursot blinking shall be restarted.
+This is done when a frame gets focus.  Blink timers may be stopped by
+`blink-cursor-suspend'."
+  (when (and blink-cursor-mode
+             (not blink-cursor-idle-timer))
+    (remove-hook 'post-command-hook 'blink-cursor-check)
+    (setq blink-cursor-idle-timer
+          (run-with-idle-timer blink-cursor-delay
+                               blink-cursor-delay
+                               'blink-cursor-start))))
+
 (define-obsolete-variable-alias 'blink-cursor 'blink-cursor-mode "22.1")
 
 (define-minor-mode blink-cursor-mode
diff --git a/lisp/gnus/ChangeLog b/lisp/gnus/ChangeLog
index eade6273e95..4b2892ae4b0 100644
--- a/lisp/gnus/ChangeLog
+++ b/lisp/gnus/ChangeLog
@@ -1,3 +1,18 @@
+2013-07-19  Geoff Kuenning  <geoff@cs.hmc.edu>  (tiny change)
+
+        * gnus-art.el (gnus-treat-predicate): Allow functions as predicates
+        (bug#13384).
+
+2013-07-18  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * gnus-start.el (gnus-clean-old-newsrc): Remove the newsrc cleanups
+        that were only relevant in a development version a long time ago.
+
+2013-07-18  Katsumi Yamaoka  <yamaoka@jpl.org>
+
+        * gnus-art.el (gnus-shr-put-image): Make it work as well for shr.el's
+        that the old Emacs 24s bundle.
+
 2013-07-10  David Engster  <deng@randomsample.de>
 
         * gnus-start.el (gnus-clean-old-newsrc): Always remove 'unexist' marks
diff --git a/lisp/gnus/gnus-art.el b/lisp/gnus/gnus-art.el
index b41ff9c0550..31a108a3c98 100644
--- a/lisp/gnus/gnus-art.el
+++ b/lisp/gnus/gnus-art.el
@@ -6197,9 +6197,14 @@ Provided for backwards compatibility."
 
 (defun gnus-shr-put-image (data alt &optional flags)
   "Put image DATA with a string ALT.  Enable image to be deleted."
-  (let ((image (shr-put-image data (propertize (or alt "*")
-                                               'gnus-image-category 'shr)
-                              flags)))
+  (let ((image (if flags
+                   (shr-put-image data (propertize (or alt "*")
+                                                   'gnus-image-category 'shr)
+                                  flags)
+                 ;; Old `shr-put-image' doesn't take the optional `flags'
+                 ;; argument.
+                 (shr-put-image data (propertize (or alt "*")
+                                                 'gnus-image-category 'shr)))))
     (when image
       (gnus-add-image 'shr image))))
 
@@ -8414,6 +8419,8 @@ For example:
         (not (gnus-treat-predicate (car val))))
        ((eq pred 'typep)
         (equal (car val) gnus-treat-type))
+       ((functionp pred)
+        (funcall pred))
        (t
         (error "%S is not a valid predicate" pred)))))
    ((eq val t)
diff --git a/lisp/gnus/gnus-start.el b/lisp/gnus/gnus-start.el
index 94803800e0b..05cf290cac9 100644
--- a/lisp/gnus/gnus-start.el
+++ b/lisp/gnus/gnus-start.el
@@ -2305,24 +2305,8 @@ If FORCE is non-nil, the .newsrc file is read."
       (gnus-clean-old-newsrc))))
 
 (defun gnus-clean-old-newsrc (&optional force)
-  (when gnus-newsrc-file-version
-    ;; Remove totally bogus `unexists' entries.  The name is
-    ;; `unexist'.
-    (dolist (info (cdr gnus-newsrc-alist))
-      (let ((exist (assoc 'unexists (gnus-info-marks info))))
-        (when exist
-          (gnus-info-set-marks
-           info (delete exist (gnus-info-marks info))))))
-    (when (or force
-              (not (string= gnus-newsrc-file-version gnus-version)))
-      (message (concat "Removing unexist marks because newsrc "
-                       "version does not match Gnus version."))
-      ;; Remove old `exist' marks from old nnimap groups.
-      (dolist (info (cdr gnus-newsrc-alist))
-        (let ((exist (assoc 'unexist (gnus-info-marks info))))
-          (when exist
-            (gnus-info-set-marks
-             info (delete exist (gnus-info-marks info)))))))))
+  ;; Currently no cleanups.
+  )
 
 (defun gnus-convert-old-newsrc ()
   "Convert old newsrc formats into the current format, if needed."
diff --git a/lisp/gnus/registry.el b/lisp/gnus/registry.el
index 37fe6440743..b056ac5e7f3 100644
--- a/lisp/gnus/registry.el
+++ b/lisp/gnus/registry.el
@@ -228,7 +228,7 @@ With assert non-nil, errors out if the key does not exist already."
       (let ((entry (gethash key data)))
         (when assert
           (assert entry nil
-                  "Key %s does not exists in database" key))
+                  "Key %s does not exist in database" key))
         ;; clean entry from the secondary indices
         (dolist (tr tracked)
           ;; is this tracked symbol indexed?
diff --git a/lisp/mail/mailalias.el b/lisp/mail/mailalias.el
index c5f1e3921fa..4d9b24e0043 100644
--- a/lisp/mail/mailalias.el
+++ b/lisp/mail/mailalias.el
@@ -209,7 +209,9 @@ removed from alias expansions."
             (if (re-search-forward "[ \t]*[\n,][ \t]*" end1 t)
                 (setq epos (match-beginning 0)
                       seplen (- (point) epos))
-              (setq epos (marker-position end1) seplen 0))
+              ;; Handle the last name in this header field.
+              ;; We already moved END1 back across whitespace after it.
+              (setq epos (marker-position end1) seplen 0))
             (let ((string (buffer-substring-no-properties pos epos))
                   translation)
               (if (and (not (assoc string disabled-aliases))
diff --git a/lisp/net/eww.el b/lisp/net/eww.el
index d832aa7ef3e..d65932ae7c9 100644
--- a/lisp/net/eww.el
+++ b/lisp/net/eww.el
@@ -603,7 +603,7 @@ appears in a <link> or <a> tag."
     (insert " ")))
 
 (defun eww-process-text-input (beg end length)
-  (let* ((form (get-text-property end 'eww-form))
+  (let* ((form (get-text-property (min (1+ end) (point-max)) 'eww-form))
          (properties (text-properties-at end))
          (type (plist-get form :type)))
     (when (and form
diff --git a/lisp/net/shr.el b/lisp/net/shr.el
index 4506ede8722..6ddf8d2af90 100644
--- a/lisp/net/shr.el
+++ b/lisp/net/shr.el
@@ -143,6 +143,7 @@ cid: URL as the argument.")
     (define-key map [tab] 'shr-next-link)
     (define-key map [backtab] 'shr-previous-link)
     (define-key map [follow-link] 'mouse-face)
+    (define-key map [mouse-2] 'shr-mouse-browse-url)
     (define-key map "I" 'shr-insert-image)
     (define-key map "w" 'shr-copy-url)
     (define-key map "u" 'shr-copy-url)
@@ -657,6 +658,12 @@ size, and full-buffer size."
             (forward-line 1)
           (goto-char end))))))
 
+(defun shr-mouse-browse-url (ev)
+  "Browse the URL under the mouse cursor."
+  (interactive "e")
+  (mouse-set-point ev)
+  (shr-browse-url))
+
 (defun shr-browse-url (&optional external)
   "Browse the URL under point.
 If EXTERNAL, browse the URL using `shr-external-browser'."
@@ -1476,9 +1483,6 @@ ones, in case fg and bg are nil."
                     (if column
                         (aref widths width-column)
                       10))
-              ;; Sanity check for degenerate tables.
-              (when (zerop width)
-                (setq width 10))
               (when (and fill
                          (setq colspan (cdr (assq :colspan (cdr column)))))
                 (setq colspan (string-to-number colspan))
@@ -1491,6 +1495,9 @@ ones, in case fg and bg are nil."
                 (setq width-column (+ width-column (1- colspan))))
               (when (or column
                         (not fill))
+                ;; Sanity check for degenerate tables.
+                (when (zerop width)
+                  (setq width 10))
                 (push (shr-render-td (cdr column) width fill)
                       tds))
               (setq i (1+ i)
@@ -1499,6 +1506,7 @@ ones, in case fg and bg are nil."
     (nreverse trs)))
 
 (defun shr-render-td (cont width fill)
+  (when (= width 0) (debug))
   (with-temp-buffer
     (let ((bgcolor (cdr (assq :bgcolor cont)))
           (fgcolor (cdr (assq :fgcolor cont)))
diff --git a/lisp/net/tramp-adb.el b/lisp/net/tramp-adb.el
index 14fb8575fff..56c0ee2dc2d 100644
--- a/lisp/net/tramp-adb.el
+++ b/lisp/net/tramp-adb.el
@@ -108,6 +108,9 @@
     (file-writable-p . tramp-adb-handle-file-writable-p)
     (file-local-copy . tramp-adb-handle-file-local-copy)
     (file-modes . tramp-handle-file-modes)
+    (file-notify-add-watch . ignore)
+    (file-notify-rm-watch . ignore)
+    (file-notify-supported-p .  ignore)
     (expand-file-name . tramp-adb-handle-expand-file-name)
     (find-backup-file-name . tramp-handle-find-backup-file-name)
     (directory-files . tramp-handle-directory-files)
diff --git a/lisp/net/tramp-compat.el b/lisp/net/tramp-compat.el
index d4115352b34..2b0ea74c492 100644
--- a/lisp/net/tramp-compat.el
+++ b/lisp/net/tramp-compat.el
@@ -184,7 +184,7 @@
         'file-expand-wildcards 'around 'tramp-advice-file-expand-wildcards)
        (ad-activate 'file-expand-wildcards)))))
 
-;; `with-temp-message' does not exists in XEmacs.
+;; `with-temp-message' does not exist in XEmacs.
 (if (fboundp 'with-temp-message)
     (defalias 'tramp-compat-with-temp-message 'with-temp-message)
   (defmacro tramp-compat-with-temp-message (message &rest body)
@@ -292,7 +292,7 @@ Not actually used.  Use `(format \"%o\" i)' instead?"
       (error "Non-octal junk in string `%s'" x))
     (string-to-number ostr 8)))
 
-;; ID-FORMAT does not exists in XEmacs.
+;; ID-FORMAT does not exist in XEmacs.
 (defun tramp-compat-file-attributes (filename &optional id-format)
   "Like `file-attributes' for Tramp files (compat function)."
   (cond
diff --git a/lisp/net/tramp-gvfs.el b/lisp/net/tramp-gvfs.el
index c2fdc0491b6..526408140c2 100644
--- a/lisp/net/tramp-gvfs.el
+++ b/lisp/net/tramp-gvfs.el
@@ -435,6 +435,9 @@ Every entry is a list (NAME ADDRESS).")
     (file-name-nondirectory . tramp-handle-file-name-nondirectory)
     ;; `file-name-sans-versions' performed by default handler.
     (file-newer-than-file-p . tramp-handle-file-newer-than-file-p)
+    (file-notify-add-watch . ignore)
+    (file-notify-rm-watch . ignore)
+    (file-notify-supported-p .  ignore)
     (file-ownership-preserved-p . ignore)
     (file-readable-p . tramp-gvfs-handle-file-readable-p)
     (file-regular-p . tramp-handle-file-regular-p)
diff --git a/lisp/net/tramp-sh.el b/lisp/net/tramp-sh.el
index 281f497692d..d2fc1b9979e 100644
--- a/lisp/net/tramp-sh.el
+++ b/lisp/net/tramp-sh.el
@@ -867,7 +867,8 @@ of command line.")
     (set-file-acl . tramp-sh-handle-set-file-acl)
     (vc-registered . tramp-sh-handle-vc-registered)
     (file-notify-add-watch . tramp-sh-handle-file-notify-add-watch)
-    (file-notify-rm-watch . tramp-sh-handle-file-notify-rm-watch))
+    (file-notify-rm-watch . tramp-sh-handle-file-notify-rm-watch)
+    (file-notify-supported-p . tramp-sh-handle-file-notify-supported-p))
   "Alist of handler functions.
 Operations not mentioned here will be handled by the normal Emacs functions.")
 
@@ -3334,7 +3335,8 @@ Returns a file name in `tramp-auto-save-directory' for autosaving this file."
         ;; `process-file-side-effects' in order to keep the cache when
         ;; `process-file' calls appear.
         (let (process-file-side-effects)
-          (tramp-run-real-handler 'vc-registered (list file)))))))
+          (ignore-errors
+            (tramp-run-real-handler 'vc-registered (list file))))))))
 
 ;;;###tramp-autoload
 (defun tramp-sh-file-name-handler (operation &rest args)
@@ -3497,6 +3499,13 @@ Fall back to normal file name handler if no Tramp handler exists."
   (tramp-message proc 6 (format "Kill %S" proc))
   (kill-process proc))
 
+(defun tramp-sh-handle-file-notify-supported-p (file-name)
+  "Like `file-notify-supported-p' for Tramp files."
+  (with-parsed-tramp-file-name (expand-file-name file-name) nil
+    (and (or (tramp-get-remote-gvfs-monitor-dir v)
+             (tramp-get-remote-inotifywait v))
+         t)))
+
 ;;; Internal Functions:
 
 (defun tramp-maybe-send-script (vec script name)
diff --git a/lisp/net/tramp-smb.el b/lisp/net/tramp-smb.el
index 65c52ae4f3c..d9bb5057e7a 100644
--- a/lisp/net/tramp-smb.el
+++ b/lisp/net/tramp-smb.el
@@ -209,6 +209,9 @@ See `tramp-actions-before-shell' for more info.")
     (file-name-nondirectory . tramp-handle-file-name-nondirectory)
     ;; `file-name-sans-versions' performed by default handler.
     (file-newer-than-file-p . tramp-handle-file-newer-than-file-p)
+    (file-notify-add-watch . ignore)
+    (file-notify-rm-watch . ignore)
+    (file-notify-supported-p .  ignore)
     (file-ownership-preserved-p . ignore)
     (file-readable-p . tramp-handle-file-exists-p)
     (file-regular-p . tramp-handle-file-regular-p)
diff --git a/lisp/net/tramp.el b/lisp/net/tramp.el
index 3513701d20e..fd5435bd3d4 100644
--- a/lisp/net/tramp.el
+++ b/lisp/net/tramp.el
@@ -1980,8 +1980,8 @@ ARGS are the arguments OPERATION has been called with."
                   ;; Emacs 22+ only.
                   'set-file-times
                   ;; Emacs 24+ only.
-                  'file-acl 'file-notify-add-watch 'file-selinux-context
-                  'set-file-acl 'set-file-selinux-context
+                  'file-acl 'file-notify-add-watch 'file-notify-supported-p
+                  'file-selinux-context 'set-file-acl 'set-file-selinux-context
                   ;; XEmacs only.
                   'abbreviate-file-name 'create-file-buffer
                   'dired-file-modtime 'dired-make-compressed-filename
diff --git a/lisp/org/org-freemind.el b/lisp/org/org-freemind.el
index 3b1c6863f54..2ee58501ca1 100644
--- a/lisp/org/org-freemind.el
+++ b/lisp/org/org-freemind.el
@@ -598,7 +598,7 @@ DRAWERS-REGEXP are converted to freemind notes."
 
 (defun org-freemind-check-overwrite (file interactively)
   "Check if file FILE already exists.
-If FILE does not exists return t.
+If FILE does not exist return t.
 
 If INTERACTIVELY is non-nil ask if the file should be replaced
 and return t/nil if it should/should not be replaced.
diff --git a/lisp/progmodes/ruby-mode.el b/lisp/progmodes/ruby-mode.el
index 0b83921504b..c8fae7ba1e6 100644
--- a/lisp/progmodes/ruby-mode.el
+++ b/lisp/progmodes/ruby-mode.el
@@ -46,11 +46,6 @@
   :prefix "ruby-"
   :group 'languages)
 
-(defconst ruby-keyword-end-re
-  (if (string-match "\\_>" "ruby")
-      "\\_>"
-    "\\>"))
-
 (defconst ruby-block-beg-keywords
   '("class" "module" "def" "if" "unless" "case" "while" "until" "for" "begin" "do")
   "Keywords at the beginning of blocks.")
@@ -60,7 +55,7 @@
   "Regexp to match the beginning of blocks.")
 
 (defconst ruby-non-block-do-re
-  (concat (regexp-opt '("while" "until" "for" "rescue") t) ruby-keyword-end-re)
+  (regexp-opt '("while" "until" "for" "rescue") 'symbols)
   "Regexp to match keywords that nest without blocks.")
 
 (defconst ruby-indent-beg-re
@@ -696,7 +691,7 @@ Can be one of `heredoc', `modifier', `expr-qstr', `expr-re'."
        ((looking-at (concat "\\_<\\(" ruby-block-beg-re "\\)\\_>"))
         (and
          (save-match-data
-           (or (not (looking-at (concat "do" ruby-keyword-end-re)))
+           (or (not (looking-at "do\\_>"))
                (save-excursion
                  (back-to-indentation)
                  (not (looking-at ruby-non-block-do-re)))))
@@ -1718,14 +1713,16 @@ See the definition of `ruby-font-lock-syntactic-keywords'."
   "The syntax table to use for fontifying Ruby mode buffers.
 See `font-lock-syntax-table'.")
 
+(defconst ruby-font-lock-keyword-beg-re "\\(?:^\\|[^.@$]\\|\\.\\.\\)")
+
 (defconst ruby-font-lock-keywords
   (list
    ;; functions
    '("^\\s *def\\s +\\(?:[^( \t\n.]*\\.\\)?\\([^( \t\n]+\\)"
      1 font-lock-function-name-face)
+   ;; keywords
    (list (concat
-          "\\(^\\|[^.@$]\\|\\.\\.\\)\\("
-          ;; keywords
+          ruby-font-lock-keyword-beg-re
           (regexp-opt
            '("alias"
              "and"
@@ -1760,11 +1757,14 @@ See `font-lock-syntax-table'.")
              "when"
              "while"
              "yield")
-           'symbols)
-          "\\|"
+           'symbols))
+         1 'font-lock-keyword-face)
+   ;; some core methods
+   (list (concat
+          ruby-font-lock-keyword-beg-re
           (regexp-opt
-           ;; built-in methods on Kernel
-           '("__callee__"
+           '(;; built-in methods on Kernel
+             "__callee__"
              "__dir__"
              "__method__"
              "abort"
@@ -1823,20 +1823,17 @@ See `font-lock-syntax-table'.")
              "public"
              "refine"
              "using")
-           'symbols)
-          "\\)")
-         2
-         '(if (match-beginning 4)
-              font-lock-builtin-face
-            font-lock-keyword-face))
+           'symbols))
+         1 'font-lock-builtin-face)
    ;; Perl-ish keywords
    "\\_<\\(?:BEGIN\\|END\\)\\_>\\|^__END__$"
    ;; here-doc beginnings
    `(,ruby-here-doc-beg-re 0 (unless (ruby-singleton-class-p (match-beginning 0))
                                'font-lock-string-face))
    ;; variables
-   '("\\(^\\|[^.@$]\\|\\.\\.\\)\\_<\\(nil\\|self\\|true\\|false\\)\\>"
-     2 font-lock-variable-name-face)
+   `(,(concat ruby-font-lock-keyword-beg-re
+              "\\_<\\(nil\\|self\\|true\\|false\\)\\>")
+     1 font-lock-variable-name-face)
    ;; keywords that evaluate to certain values
    '("\\_<__\\(?:LINE\\|ENCODING\\|FILE\\)__\\_>" 0 font-lock-variable-name-face)
    ;; symbols
@@ -1852,7 +1849,7 @@ See `font-lock-syntax-table'.")
      1 (unless (eq ?\( (char-after)) font-lock-type-face))
    '("\\(^\\s *\\|[\[\{\(,]\\s *\\|\\sw\\s +\\)\\(\\(\\sw\\|_\\)+\\):[^:]" 2 font-lock-constant-face)
    ;; conversion methods on Kernel
-   (list (concat "\\(?:^\\|[^.@$]\\|\\.\\.\\)"
+   (list (concat ruby-font-lock-keyword-beg-re
                  (regexp-opt '("Array" "Complex" "Float" "Hash"
                                "Integer" "Rational" "String") 'symbols))
          1 font-lock-builtin-face)
@@ -1864,7 +1861,7 @@ See `font-lock-syntax-table'.")
      1 font-lock-negation-char-face)
    ;; character literals
    ;; FIXME: Support longer escape sequences.
-   '("\\?\\\\?\\S " 0 font-lock-string-face)
+   '("\\_<\\?\\\\?\\S " 0 font-lock-string-face)
    )
   "Additional expressions to highlight in Ruby mode.")
 
diff --git a/lisp/shell.el b/lisp/shell.el
index 51a0ffc4fe8..a78ab7f81ab 100644
--- a/lisp/shell.el
+++ b/lisp/shell.el
@@ -284,21 +284,9 @@ Value is a list of strings, which may be nil."
 ;; Note: There are no explicit references to the variable `explicit-bash-args'.
 ;; It is used implicitly by M-x shell when the interactive shell is `bash'.
 (defcustom explicit-bash-args
-  (let* ((prog (or (and (boundp 'explicit-shell-file-name) explicit-shell-file-name)
-                   (getenv "ESHELL") shell-file-name))
-         (name (file-name-nondirectory prog)))
-    ;; Tell bash not to use readline, except for bash 1.x which
-    ;; doesn't grok --noediting.  Bash 1.x has -nolineediting, but
-    ;; process-send-eof cannot terminate bash if we use it.
-    (if (and (not purify-flag)
-             (equal name "bash")
-             (file-executable-p prog)
-             (string-match "bad option"
-                           (shell-command-to-string
-                            (concat (shell-quote-argument prog)
-                                    " --noediting"))))
-        '("-i")
-      '("--noediting" "-i")))
+  ;; Tell bash not to use readline.  It's safe to assume --noediting now,
+  ;; as it was introduced in 1996 in Bash version 2.
+  '("--noediting" "-i")
   "Args passed to inferior shell by \\[shell], if the shell is bash.
 Value is a list of strings, which may be nil."
   :type '(repeat (string :tag "Argument"))
diff --git a/lisp/simple.el b/lisp/simple.el
index 3e3ff485c5e..4b158d31f36 100644
--- a/lisp/simple.el
+++ b/lisp/simple.el
@@ -4800,6 +4800,8 @@ The value is a floating-point number."
            (this-ypos (nth 2 this-lh))
            (dlh (default-line-height))
            (wslines (window-screen-lines))
+           (edges (window-inside-pixel-edges))
+           (winh (- (nth 3 edges) (nth 1 edges) 1))
            py vs last-line)
       (if (> (mod wslines 1.0) 0.0)
           (setq wslines (round (+ wslines 0.5))))
@@ -4848,7 +4850,7 @@ The value is a floating-point number."
           nil)
          ;; If cursor is not in the bottom scroll margin, and the
          ;; current line is is not too tall, move forward.
-         ((and (or (null this-height) (<= this-height dlh))
+         ((and (or (null this-height) (<= this-height winh))
                vpos
                (> vpos 0)
                (< py last-line))
@@ -4865,7 +4867,7 @@ The value is a floating-point number."
                (> vpos 0)
                (= py last-line))
           ;; Don't vscroll if the partially-visible line at window
-          ;; bottom has the default height (a.k.a. "just one more text
+          ;; bottom is not too tall (a.k.a. "just one more text
           ;; line"): in that case, we do want redisplay to behave
           ;; normally, i.e. recenter or whatever.
           ;;
@@ -4874,7 +4876,7 @@ The value is a floating-point number."
           ;; partially-visible glyph row at the end of the window.  As
           ;; we are dealing with floats, we disregard sub-pixel
           ;; discrepancies between that and DLH.
-          (if (and rowh rbot (>= (- (+ rowh rbot) dlh) 1))
+          (if (and rowh rbot (>= (- (+ rowh rbot) winh) 1))
               (set-window-vscroll nil dlh t))
           (line-move-1 arg noerror to-end)
           t)
@@ -4918,10 +4920,13 @@ The value is a floating-point number."
             ;; If we moved into a tall line, set vscroll to make
             ;; scrolling through tall images more smooth.
             (let ((lh (line-pixel-height))
-                  (dlh (default-line-height)))
+                  (edges (window-inside-pixel-edges))
+                  (dlh (default-line-height))
+                  winh)
+              (setq winh (- (nth 3 edges) (nth 1 edges) 1))
               (if (and (< arg 0)
                        (< (point) (window-start))
-                       (> lh dlh))
+                       (> lh winh))
                   (set-window-vscroll
                    nil
                    (- lh dlh) t))))
@@ -7437,19 +7442,19 @@ warning using STRING as the message.")
 
 ;;; Generic dispatcher commands
 
-;; Macro `alternatives-define' is used to create generic commands.
+;; Macro `define-alternatives' is used to create generic commands.
 ;; Generic commands are these (like web, mail, news, encrypt, irc, etc.)
 ;; that can have different alternative implementations where choosing
 ;; among them is exclusively a matter of user preference.
 
-;; (alternatives-define COMMAND) creates a new interactive command
+;; (define-alternatives COMMAND) creates a new interactive command
 ;; M-x COMMAND and a customizable variable COMMAND-alternatives.
 ;; Typically, the user will not need to customize this variable; packages
 ;; wanting to add alternative implementations should use
 ;;
 ;; ;;;###autoload (push '("My impl name" . my-impl-symbol) COMMAND-alternatives
 
-(defmacro alternatives-define (command &rest customizations)
+(defmacro define-alternatives (command &rest customizations)
   "Define new command `COMMAND'.
 The variable `COMMAND-alternatives' will contain alternative
 implementations of COMMAND, so that running `C-u M-x COMMAND'
diff --git a/lisp/subr.el b/lisp/subr.el
index b6ee96f879e..75c6b3a0620 100644
--- a/lisp/subr.el
+++ b/lisp/subr.el
@@ -3529,7 +3529,7 @@ likely to have undesired semantics.")
 ;; defaulted, OMIT-NULLS should be treated as t.  Simplifying the logical
 ;; expression leads to the equivalent implementation that if SEPARATORS
 ;; is defaulted, OMIT-NULLS is treated as t.
-(defun split-string (string &optional separators omit-nulls)
+(defun split-string (string &optional separators omit-nulls trim)
   "Split STRING into substrings bounded by matches for SEPARATORS.
 
 The beginning and end of STRING, and each match for SEPARATORS, are
@@ -3547,17 +3547,50 @@ that for the default value of SEPARATORS leading and trailing whitespace
 are effectively trimmed).  If nil, all zero-length substrings are retained,
 which correctly parses CSV format, for example.
 
+If TRIM is non-nil, it should be a regular expression to match
+text to trim from the beginning and end of each substring.  If trimming
+makes the substring empty, it is treated as null.
+
+If you want to trim whitespace from the substrings, the reliably correct
+way is using TRIM.  Making SEPARATORS match that whitespace gives incorrect
+results when there is whitespace at the start or end of STRING.  If you
+see such calls to `split-string', please fix them.
+
 Note that the effect of `(split-string STRING)' is the same as
 `(split-string STRING split-string-default-separators t)'.  In the rare
 case that you wish to retain zero-length substrings when splitting on
 whitespace, use `(split-string STRING split-string-default-separators)'.
 
 Modifies the match data; use `save-match-data' if necessary."
-  (let ((keep-nulls (not (if separators omit-nulls t)))
-        (rexp (or separators split-string-default-separators))
-        (start 0)
-        notfirst
-        (list nil))
+  (let* ((keep-nulls (not (if separators omit-nulls t)))
+         (rexp (or separators split-string-default-separators))
+         (start 0)
+         this-start this-end
+         notfirst
+         (list nil)
+         (push-one
+          ;; Push the substring in range THIS-START to THIS-END
+          ;; onto LIST, trimming it and perhaps discarding it.
+          (lambda ()
+            (when trim
+              ;; Discard the trim from start of this substring.
+              (let ((tem (string-match trim string this-start)))
+                (and (eq tem this-start)
+                     (setq this-start (match-end 0)))))
+
+            (when (or keep-nulls (< this-start this-end))
+              (let ((this (substring string this-start this-end)))
+
+                ;; Discard the trim from end of this substring.
+                (when trim
+                  (let ((tem (string-match (concat trim "\\'") this 0)))
+                    (and tem (< tem (length this))
+                         (setq this (substring this 0 tem)))))
+
+                ;; Trimming could make it empty; check again.
+                (when (or keep-nulls (> (length this) 0))
+                  (push this list)))))))
+
     (while (and (string-match rexp string
                               (if (and notfirst
                                        (= start (match-beginning 0))
@@ -3565,15 +3598,15 @@ Modifies the match data; use `save-match-data' if necessary."
                                   (1+ start) start))
                 (< start (length string)))
       (setq notfirst t)
-      (if (or keep-nulls (< start (match-beginning 0)))
-          (setq list
-                (cons (substring string start (match-beginning 0))
-                      list)))
-      (setq start (match-end 0)))
-    (if (or keep-nulls (< start (length string)))
-        (setq list
-              (cons (substring string start)
-                    list)))
+      (setq this-start start this-end (match-beginning 0)
+            start (match-end 0))
+
+      (funcall push-one))
+
+    ;; Handle the substring at the end of STRING.
+    (setq this-start start this-end (length string))
+    (funcall push-one)
+
     (nreverse list)))
 
 (defun combine-and-quote-strings (strings &optional separator)