merge trunk

20 files changed, 813 insertions, 314 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 4296280b22e..3dd2b7b1272 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,101 @@
+2012-08-28  Juri Linkov  <juri@jurta.org>
+
+        * info.el (Info-fontify-node): Hide empty lines at the end of
+        the node.  (Bug#12272)
+
+2012-08-27  Drew Adams  <drew.adams@oracle.com>
+
+        * dired.el (dired-pop-to-buffer): Make window start at beginning
+        of buffer (Bug#12281).
+
+2012-08-26  Chong Yidong  <cyd@gnu.org>
+
+        * window.el (special-display-regexps, special-display-frame-alist)
+        (special-display-buffer-names, special-display-function)
+        (display-buffer-reuse-frames): Mark as obsolete.
+
+        * progmodes/compile.el: Don't use display-buffer-reuse-frames.
+
+        * help.el (help-print-return-message): Don't treat
+        display-buffer-reuse-frames specially.
+
+2012-08-26  Chong Yidong  <cyd@gnu.org>
+
+        * progmodes/gdb-mi.el (gdb-display-buffer-other-frame-action): New
+        variable, replacing gdb-frame-parameters.
+        (gdb-frame-io-buffer, gdb-frame-breakpoints-buffer)
+        (gdb-frame-threads-buffer, gdb-frame-memory-buffer)
+        (gdb-frame-disassembly-buffer, gdb-frame-stack-buffer)
+        (gdb-frame-locals-buffer, gdb-frame-registers-buffer): Use it.
+        (def-gdb-frame-for-buffer): Macro deleted.  It is easier to define
+        the functions directly with gdb-display-buffer-other-frame-action.
+        (gdb-display-breakpoints-buffer, gdb-display-threads-buffer)
+        (gdb-display-memory-buffer, gdb-display-disassembly-buffer)
+        (gdb-display-stack-buffer, gdb-display-locals-buffer)
+        (gdb-display-registers-buffer): Define directly.
+        (def-gdb-display-buffer): Macro deleted.
+        (gdb-display-buffer): Remove second and third args, callers don't
+        use them.  Defer to the default display-buffer behavior, apart
+        from making windows dedicated.
+        (gdb-setup-windows): Don't call display-buffer unnecessarily.
+
+        * progmodes/gud.el (gud-display-line): Just use display-buffer.
+
+        * window.el (display-buffer-pop-up-frame): Handle a
+        pop-up-frame-parameters alist entry.
+        (display-buffer): Document it.
+
+2012-08-26  Chong Yidong  <cyd@gnu.org>
+
+        * isearch.el (search-whitespace-regexp): Make string and nil
+        values apply to both ordinary and regexp search.  Allow a cons
+        cell value to distinguish between the two.
+        (isearch-whitespace-regexp, isearch-search-forward)
+        (isearch-search-backward): New functions.
+        (isearch-occur, isearch-search-fun-default, isearch-search)
+        (isearch-lazy-highlight-new-loop): Use them.
+        (isearch-forward, isearch-forward-regexp): Doc fix.
+
+2012-08-26  Chong Yidong  <cyd@gnu.org>
+
+        * faces.el (help-argument-name): Always inherit from italic
+        (Bug#12213).
+
+2012-08-25  Martin Rudalics  <rudalics@gmx.at>
+
+        * window.el (window--even-window-heights): Even heights when
+        WINDOW and the selected window form a vertical combination.
+        (display-buffer-use-some-window): Provide that window used gets
+        sized back by quit-window.  (Bug#11880) and (Bug#12091)
+
+2012-08-24  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix file time stamp problem with bzr and CVS (Bug#12001).
+        * vc/vc-cvs.el (vc-cvs-parse-entry): Ignore subsecond information
+        in the file's time stamp, since the version control system loses
+        that information.
+
+2012-08-22  Juri Linkov  <juri@jurta.org>
+
+        * info.el (Info-fontify-node): Hide the suffix of the
+        Info file name in the header line.  (Bug#12187)
+
+2012-08-22  Glenn Morris  <rgm@gnu.org>
+
+        * calendar/cal-tex.el (cal-tex-weekly-common):
+        Restore leading blank page.
+
+2012-08-22  Le Wang  <l26wang@gmail.com>  (tiny change)
+
+        * misc.el (forward-to-word, backward-to-word): Activate or extend
+        the region under `shift-select-mode'.  (Bug#12231)
+
+2012-08-22  Bastien Guerry  <bzg@gnu.org>
+
+        * progmodes/executable.el (executable-prefix): Set to "#!" instead
+        of "#! ".  http://www.in-ulm.de/~mascheck/various/shebang/#details
+        gives details on why the space is never needed.
+
 2012-08-22  Martin Rudalics  <rudalics@gmx.at>
 
         * window.el (walk-window-tree, window-with-parameter): New
@@ -7,6 +105,15 @@
         (window-in-direction): Simplify and rewrite doc-string.
         (window--size-ignore): Rename to window--size-ignore-p.  Update
         callers.
+        (display-buffer-in-atom-window, window--major-non-side-window)
+        (window--major-side-window, display-buffer-in-major-side-window)
+        (delete-side-window, display-buffer-in-side-window): New
+        functions.
+        (window--side-check, window-deletable-p, delete-window)
+        (delete-other-windows, split-window): Handle side windows and
+        atomic windows appropriately.
+        (window--display-buffer): Call display-buffer-record-window also
+        when the window buffer did not change.
 
 2012-08-22  Christopher Schmidt  <christopher@ch.ristopher.com>
 
@@ -391,7 +498,7 @@
 
 2012-08-13  Bastien Guerry  <bzg@gnu.org>
 
-        * window.el (special-display-popup-frame): Small docstring
+        * window.el (special-display-popup-frame): Minor docstring
         enhancement.  (Bug#12172)
 
 2012-08-13  Andreas Schwab  <schwab@linux-m68k.org>
diff --git a/lisp/calc/calccomp.el b/lisp/calc/calccomp.el
index 51ea8e7b7a3..2f1c95b7668 100644
--- a/lisp/calc/calccomp.el
+++ b/lisp/calc/calccomp.el
@@ -86,7 +86,7 @@
           (setq sn (math-to-underscores sn)))
       sn)))
 
-;;; Give multiplication precendence when composing to avoid
+;;; Give multiplication precedence when composing to avoid
 ;;; writing a*(b c) instead of a b c
 (defun math-compose-expr (a prec &optional div)
   (let ((calc-multiplication-has-precedence t)
diff --git a/lisp/calendar/cal-tex.el b/lisp/calendar/cal-tex.el
index d8d2a09c871..9c01ab40c0c 100644
--- a/lisp/calendar/cal-tex.el
+++ b/lisp/calendar/cal-tex.el
@@ -1080,8 +1080,8 @@ shown are hard-coded to 8-12, 13-17."
           (cal-tex-longday "weekend" "0.8in")
           (insert cal-tex-lefthead)
           (cal-tex-longday "leftday" "1.85in"))
-    (cal-tex-preamble "twoside,12pt")
-    (insert "\\textwidth 7in
+      (cal-tex-preamble "twoside,12pt")
+      (insert "\\textwidth 7in
 \\textheight 10.5in
 \\oddsidemargin 0in
 \\evensidemargin 0in
@@ -1090,13 +1090,19 @@ shown are hard-coded to 8-12, 13-17."
 \\headsep 0.125in
 \\footskip .125in
 ")
-    (insert cal-tex-righthead)
-    (cal-tex-longday "rightday" "2.75in")
-    (cal-tex-longday "weekend" "1.8in")
-    (insert cal-tex-lefthead)
-    (cal-tex-longday "leftday" "2.75in"))
+      (insert cal-tex-righthead)
+      (cal-tex-longday "rightday" "2.75in")
+      (cal-tex-longday "weekend" "1.8in")
+      (insert cal-tex-lefthead)
+      (cal-tex-longday "leftday" "2.75in"))
     (cal-tex-b-document)
     (cal-tex-cmd "\\pagestyle" "empty")
+    ;; Let's assume this is something to with twopage documents.
+    ;; It has the downside that we start with a blank page.
+    ;; It doesn't make obvious sense when oddside and evenside margins
+    ;; are the same (non-filofax), but consider the left and right
+    ;; versions of various functions as applicable to even and odd pages.
+    (cal-tex-newpage)
     (dotimes (i n)
       (insert "\\lefthead")
       (cal-tex-arg
diff --git a/lisp/dired.el b/lisp/dired.el
index 6182e133726..b82b7781e39 100644
--- a/lisp/dired.el
+++ b/lisp/dired.el
@@ -2950,6 +2950,8 @@ or \"* [3 files]\"."
                (split-window-sensibly window))))
         pop-up-frames)
     (pop-to-buffer (get-buffer-create buf)))
+  ;; See Bug#12281.
+  (set-window-start nil (point-min))
   ;; If dired-shrink-to-fit is t, make its window fit its contents.
   (when dired-shrink-to-fit
     ;; Try to not delete window when we want to display less than
diff --git a/lisp/faces.el b/lisp/faces.el
index 2e1ba7798e9..6a477e172e1 100644
--- a/lisp/faces.el
+++ b/lisp/faces.el
@@ -2444,7 +2444,7 @@ Note: Other faces cannot inherit from the cursor face."
   :group 'menu
   :group 'basic-faces)
 
-(defface help-argument-name '((((supports :slant italic)) :inherit italic))
+(defface help-argument-name '((t :inherit italic))
   "Face to highlight argument names in *Help* buffers."
   :group 'help)
 
diff --git a/lisp/gnus/ChangeLog b/lisp/gnus/ChangeLog
index 7592c405076..4b56d351ac2 100644
--- a/lisp/gnus/ChangeLog
+++ b/lisp/gnus/ChangeLog
@@ -1,3 +1,18 @@
+2012-08-28  Katsumi Yamaoka  <yamaoka@jpl.org>
+
+        * gnus-sum.el (gnus-summary-enter-digest-group): Decode content
+        transfer encoding first; bind gnus-newsgroup-charset to the charset
+        that the article specifies (Bug#12209).
+
+2012-08-22  Katsumi Yamaoka  <yamaoka@jpl.org>
+
+        * gnus-cus.el (gnus-group-customize): Decode values posting-style holds.
+        (gnus-group-customize-done): Encode values posting-style holds.
+
+        * gnus-msg.el (gnus-summary-resend-message)
+        (gnus-configure-posting-styles): Decode values posting-style group
+        parameter holds.
+
 2012-08-21  Katsumi Yamaoka  <yamaoka@jpl.org>
 
         * gnus-msg.el (gnus-summary-resend-message): Honor posting-style for
diff --git a/lisp/gnus/gnus-cus.el b/lisp/gnus/gnus-cus.el
index 234d0f7ae56..3440e6310af 100644
--- a/lisp/gnus/gnus-cus.el
+++ b/lisp/gnus/gnus-cus.el
@@ -417,6 +417,11 @@ category."))
             (delq elem tmp))
           (setq tmp (cdr tmp))))
 
+      ;; Decode values posting-style holds.
+      (dolist (style (cdr (assq 'posting-style values)))
+        (when (stringp (cadr style))
+          (setcdr style (list (mm-decode-coding-string (cadr style) 'utf-8)))))
+
       (setq gnus-custom-params
             (apply 'widget-create 'group
                    :value values
@@ -487,14 +492,17 @@ form, but who cares?"
 (defun gnus-group-customize-done (&rest ignore)
   "Apply changes and bury the buffer."
   (interactive)
-  (if gnus-custom-topic
-      (gnus-topic-set-parameters gnus-custom-topic
-                                 (widget-value gnus-custom-params))
-    (gnus-group-edit-group-done 'params gnus-custom-group
-                                (widget-value gnus-custom-params))
-    (gnus-group-edit-group-done 'method gnus-custom-group
-                                (widget-value gnus-custom-method)))
-  (bury-buffer))
+  (let ((params (widget-value gnus-custom-params)))
+    ;; Encode values posting-style holds.
+    (dolist (style (cdr (assq 'posting-style params)))
+      (when (stringp (cadr style))
+        (setcdr style (list (mm-encode-coding-string (cadr style) 'utf-8)))))
+    (if gnus-custom-topic
+        (gnus-topic-set-parameters gnus-custom-topic params)
+      (gnus-group-edit-group-done 'params gnus-custom-group params)
+      (gnus-group-edit-group-done 'method gnus-custom-group
+                                  (widget-value gnus-custom-method)))
+    (bury-buffer)))
 
 ;;; Score Customization:
 
diff --git a/lisp/gnus/gnus-msg.el b/lisp/gnus/gnus-msg.el
index 07748bebb81..c2f79e70d1e 100644
--- a/lisp/gnus/gnus-msg.el
+++ b/lisp/gnus/gnus-msg.el
@@ -1376,6 +1376,9 @@ For the \"inline\" alternatives, also see the variable
         (user-full-name user-full-name)
         (user-mail-address user-mail-address)
         tem)
+    (dolist (style styles)
+      (when (stringp (cadr style))
+        (setcdr style (list (mm-decode-coding-string (cadr style) 'utf-8)))))
     (dolist (style (if styles
                        (append gnus-posting-styles (list (cons ".*" styles)))
                      gnus-posting-styles))
@@ -1807,6 +1810,10 @@ this is a reply."
       (when gnus-newsgroup-name
         (let ((tmp-style (gnus-group-find-parameter group 'posting-style t)))
           (when tmp-style
+            (dolist (style tmp-style)
+              (when (stringp (cadr style))
+                (setcdr style (list (mm-decode-coding-string (cadr style)
+                                                             'utf-8)))))
             (setq styles (append styles (list (cons ".*" tmp-style)))))))
       ;; Go through all styles and look for matches.
       (dolist (style styles)
diff --git a/lisp/gnus/gnus-sum.el b/lisp/gnus/gnus-sum.el
index 06f17bcf646..b44b953bec6 100644
--- a/lisp/gnus/gnus-sum.el
+++ b/lisp/gnus/gnus-sum.el
@@ -9137,7 +9137,7 @@ To control what happens when you exit the group, see the
                            (list (cons 'save-article-group ogroup))))
            (case-fold-search t)
            (buf (current-buffer))
-           dig to-address)
+           dig to-address charset)
       (with-current-buffer gnus-original-article-buffer
         ;; Have the digest group inherit the main mail address of
         ;; the parent article.
@@ -9150,16 +9150,32 @@ To control what happens when you exit the group, see the
                                       to-address))))))
         (setq dig (nnheader-set-temp-buffer " *gnus digest buffer*"))
         (insert-buffer-substring gnus-original-article-buffer)
-        ;; Remove lines that may lead nndoc to misinterpret the
-        ;; document type.
         (narrow-to-region
          (goto-char (point-min))
          (or (search-forward "\n\n" nil t) (point)))
+        ;; Remove lines that may lead nndoc to misinterpret the
+        ;; document type.
         (goto-char (point-min))
         (delete-matching-lines "^Path:\\|^From ")
+        ;; Parse charset, and decode content transfer encoding.
+        (setq charset (mail-content-type-get
+                       (mail-header-parse-content-type
+                        (or (gnus-fetch-field "content-type") ""))
+                       'charset))
+        (let ((encoding (gnus-fetch-field "content-transfer-encoding")))
+          (when encoding
+            (message-remove-header "content-transfer-encoding")
+            (goto-char (point-max))
+            (widen)
+            (narrow-to-region (point) (point-max))
+            (mm-decode-content-transfer-encoding
+             (intern (downcase (mail-header-strip encoding))))))
         (widen))
       (unwind-protect
-          (if (let ((gnus-newsgroup-ephemeral-charset gnus-newsgroup-charset)
+          (if (let ((gnus-newsgroup-ephemeral-charset
+                     (if charset
+                         (intern (downcase (gnus-strip-whitespace charset)))
+                       gnus-newsgroup-charset))
                     (gnus-newsgroup-ephemeral-ignored-charsets
                      gnus-newsgroup-ignored-charsets))
                 (gnus-group-read-ephemeral-group
diff --git a/lisp/help.el b/lisp/help.el
index 19cb811bcf5..19db7c255d1 100644
--- a/lisp/help.el
+++ b/lisp/help.el
@@ -145,10 +145,6 @@ specifies what to do when the user exits the help buffer."
                      ;; Secondly, the buffer has not been displayed yet,
                      ;; so we don't know whether its frame will be selected.
                      nil)
-                    (display-buffer-reuse-frames
-                     (setq help-return-method (cons (selected-window)
-                                                    'quit-window))
-                     nil)
                     ((not (one-window-p t))
                      (setq help-return-method
                            (cons (selected-window) 'quit-window))
diff --git a/lisp/info.el b/lisp/info.el
index 15478f9063c..fe4afd72163 100644
--- a/lisp/info.el
+++ b/lisp/info.el
@@ -4527,7 +4527,17 @@ first line or header line, and for breadcrumb links.")
              ((not (bobp))
               ;; Hide the punctuation at the end, too.
               (skip-chars-backward " \t,")
-              (put-text-property (point) header-end 'invisible t))))))
+              (put-text-property (point) header-end 'invisible t)
+              ;; Hide the suffix of the Info file name.
+              (beginning-of-line)
+              (if (re-search-forward
+                   (format "File: %s\\([^,\n\t]+\\),"
+                           (if (stringp Info-current-file)
+                               (file-name-nondirectory Info-current-file)
+                             Info-current-file))
+                   header-end t)
+                  (put-text-property (match-beginning 1) (match-end 1)
+                                     'invisible t)))))))
 
       ;; Fontify titles
       (goto-char (point-min))
@@ -4815,6 +4825,12 @@ first line or header line, and for breadcrumb links.")
                                  mouse-face highlight
                                  help-echo "mouse-2: go to this URL"))))
 
+      ;; Hide empty lines at the end of the node.
+      (goto-char (point-max))
+      (skip-chars-backward "\n")
+      (when (< (1+ (point)) (point-max))
+        (put-text-property (1+ (point)) (point-max) 'invisible t))
+
       (set-buffer-modified-p nil))))
 
 ;;; Speedbar support:
diff --git a/lisp/isearch.el b/lisp/isearch.el
index 9271ce32484..6ea8d86336a 100644
--- a/lisp/isearch.el
+++ b/lisp/isearch.el
@@ -111,17 +111,32 @@ string, and RET terminates editing and does a nonincremental search."
 
 (defcustom search-whitespace-regexp (purecopy "\\s-+")
   "If non-nil, regular expression to match a sequence of whitespace chars.
-This applies to regular expression incremental search.
-When you put a space or spaces in the incremental regexp, it stands for
-this, unless it is inside of a regexp construct such as [...] or *, + or ?.
+When you enter a space or spaces in the incremental search, it
+will match any sequence matched by this regexp.  As an exception,
+spaces are treated normally in regexp incremental search if they
+occur in a regexp construct like [...] or *, + or ?.
+
+If the value is a string, it applies to both ordinary and regexp
+incremental search.  If the value is nil, each space you type
+matches literally, against one space.
+
+The value can also be a cons cell (REGEXP-1 . REGEXP-2).  In that
+case, REGEXP-1 is used as the value for ordinary incremental
+search, and REGEXP-2 is used for regexp incremental search.
+
 You might want to use something like \"[ \\t\\r\\n]+\" instead.
 In the Customization buffer, that is `[' followed by a space,
-a tab, a carriage return (control-M), a newline, and `]+'.
-
-When this is nil, each space you type matches literally, against one space."
-  :type '(choice (const :tag "Find Spaces Literally" nil)
+a tab, a carriage return (control-M), a newline, and `]+'."
+  :type '(choice (const :tag "Treat Spaces Literally" nil)
+                 (cons (choice :tag "For Ordinary Isearch"
+                               regexp
+                               (const :tag "Treat Spaces Literally" nil))
+                       (choice :tag "For Regexp Isearch"
+                               regexp
+                               (const :tag "Treat Spaces Literally" nil)))
                  regexp)
-  :group 'isearch)
+  :group 'isearch
+  :version "24.3")
 
 (defcustom search-invisible 'open
   "If t incremental search can match hidden text.
@@ -687,6 +702,9 @@ Type \\[isearch-describe-bindings] to display all Isearch key bindings.
 Type \\[isearch-describe-key] to display documentation of Isearch key.
 Type \\[isearch-describe-mode] to display documentation of Isearch mode.
 
+In incremental searches, a space or spaces normally matches any
+whitespace; see the variable `search-whitespace-regexp'.
+
 If an input method is turned on in the current buffer, that input
 method is also active while you are typing characters to search.
 To toggle the input method, type \\[isearch-toggle-input-method].  \
@@ -710,22 +728,19 @@ the calling function until the search is done."
   (isearch-mode t (not (null regexp-p)) nil (not no-recursive-edit)))
 
 (defun isearch-forward-regexp (&optional not-regexp no-recursive-edit)
-  "\
-Do incremental search forward for regular expression.
+  "Do incremental search forward for regular expression.
 With a prefix argument, do a regular string search instead.
 Like ordinary incremental search except that your input is treated
 as a regexp.  See the command `isearch-forward' for more information.
 
-In regexp incremental searches, a space or spaces normally matches
-any whitespace (the variable `search-whitespace-regexp' controls
-precisely what that means).  If you want to search for a literal space
-and nothing else, enter C-q SPC."
+In incremental searches, a space or spaces normally matches any
+whitespace; see the variable `search-whitespace-regexp'.  To
+search for a literal space and nothing else, enter C-q SPC."
   (interactive "P\np")
   (isearch-mode t (null not-regexp) nil (not no-recursive-edit)))
 
 (defun isearch-forward-word (&optional not-word no-recursive-edit)
-  "\
-Do incremental search forward for a sequence of words.
+  "Do incremental search forward for a sequence of words.
 With a prefix argument, do a regular string search instead.
 Like ordinary incremental search except that your input is treated
 as a sequence of words without regard to how the words are separated.
@@ -734,8 +749,7 @@ See the command `isearch-forward' for more information."
   (isearch-mode t nil nil (not no-recursive-edit) (null not-word)))
 
 (defun isearch-forward-symbol (&optional not-symbol no-recursive-edit)
-  "\
-Do incremental search forward for a symbol.
+  "Do incremental search forward for a symbol.
 The prefix argument is currently unused.
 Like ordinary incremental search except that your input is treated
 as a symbol surrounded by symbol boundary constructs \\_< and \\_>.
@@ -744,16 +758,14 @@ See the command `isearch-forward' for more information."
   (isearch-mode t nil nil (not no-recursive-edit) 'isearch-symbol-regexp))
 
 (defun isearch-backward (&optional regexp-p no-recursive-edit)
-  "\
-Do incremental search backward.
+  "Do incremental search backward.
 With a prefix argument, do a regular expression search instead.
 See the command `isearch-forward' for more information."
   (interactive "P\np")
   (isearch-mode nil (not (null regexp-p)) nil (not no-recursive-edit)))
 
 (defun isearch-backward-regexp (&optional not-regexp no-recursive-edit)
-  "\
-Do incremental search backward for regular expression.
+  "Do incremental search backward for regular expression.
 With a prefix argument, do a regular string search instead.
 Like ordinary incremental search except that your input is treated
 as a regexp.  See the command `isearch-forward' for more information."
@@ -895,8 +907,7 @@ The last thing it does is to run `isearch-update-post-hook'."
             (if (< isearch-other-end (point)) ; isearch-forward?
                 (isearch-highlight isearch-other-end (point))
               (isearch-highlight (point) isearch-other-end))
-          (isearch-dehighlight))
-        ))
+          (isearch-dehighlight))))
   (setq ;; quit-flag nil  not for isearch-mode
    isearch-adjusted nil
    isearch-yank-flag nil)
@@ -1547,6 +1558,15 @@ See `isearch-query-replace' for more information."
    (list current-prefix-arg))
   (isearch-query-replace delimited t))
 
+(defun isearch-whitespace-regexp ()
+  "Return the value of `search-whitespace-regexp' for the current search."
+  (cond ((not (consp search-whitespace-regexp))
+         search-whitespace-regexp)
+        (isearch-regexp
+         (cdr search-whitespace-regexp))
+        (t
+         (car search-whitespace-regexp))))
+
 (defun isearch-occur (regexp &optional nlines)
   "Run `occur' using the last search string as the regexp.
 Interactively, REGEXP is constructed using the search string from the
@@ -1586,7 +1606,7 @@ characters in that string."
         ;; Set `search-upper-case' to nil to not call
         ;; `isearch-no-upper-case-p' in `occur-1'.
         (search-upper-case nil)
-        (search-spaces-regexp (if isearch-regexp search-whitespace-regexp)))
+        (search-spaces-regexp (isearch-whitespace-regexp)))
     (occur regexp nlines)))
 
 (declare-function hi-lock-read-face-name "hi-lock" ())
@@ -2426,7 +2446,13 @@ Can be changed via `isearch-search-fun-function' for special needs."
    (isearch-regexp
     (if isearch-forward 're-search-forward 're-search-backward))
    (t
-    (if isearch-forward 'search-forward 'search-backward))))
+    (if isearch-forward 'isearch-search-forward 'isearch-search-backward))))
+
+(defun isearch-search-forward (string &optional bound noerror count)
+  (re-search-forward (regexp-quote string) bound noerror count))
+
+(defun isearch-search-backward (string &optional bound noerror count)
+  (re-search-backward (regexp-quote string) bound noerror count))
 
 (defun isearch-search-string (string bound noerror)
   "Search for the first occurrence of STRING or its translation.
@@ -2487,7 +2513,7 @@ update the match data, and return point."
                   search-invisible))
             (inhibit-quit nil)
             (case-fold-search isearch-case-fold-search)
-            (search-spaces-regexp search-whitespace-regexp)
+            (search-spaces-regexp (isearch-whitespace-regexp))
             (retry t))
         (setq isearch-error nil)
         (while retry
@@ -2847,7 +2873,7 @@ by other Emacs features."
           isearch-lazy-highlight-last-string  isearch-string
           isearch-lazy-highlight-case-fold-search isearch-case-fold-search
           isearch-lazy-highlight-regexp       isearch-regexp
-          isearch-lazy-highlight-space-regexp search-whitespace-regexp
+          isearch-lazy-highlight-space-regexp (isearch-whitespace-regexp)
           isearch-lazy-highlight-word         isearch-word
           isearch-lazy-highlight-forward      isearch-forward)
       (unless (equal isearch-string "")
diff --git a/lisp/misc.el b/lisp/misc.el
index cb52ecbd36e..96b739dc2b7 100644
--- a/lisp/misc.el
+++ b/lisp/misc.el
@@ -99,14 +99,14 @@ Ignores CHAR at point."
 (defun forward-to-word (arg)
   "Move forward until encountering the beginning of a word.
 With argument, do this that many times."
-  (interactive "p")
+  (interactive "^p")
   (or (re-search-forward (if (> arg 0) "\\W\\b" "\\b\\W") nil t arg)
       (goto-char (if (> arg 0) (point-max) (point-min)))))
 
 (defun backward-to-word (arg)
   "Move backward until encountering the end of a word.
 With argument, do this that many times."
-  (interactive "p")
+  (interactive "^p")
   (forward-to-word (- arg)))
 
 ;;;###autoload
diff --git a/lisp/progmodes/compile.el b/lisp/progmodes/compile.el
index 21a323d8b45..eb966e8a90d 100644
--- a/lisp/progmodes/compile.el
+++ b/lisp/progmodes/compile.el
@@ -2461,10 +2461,7 @@ and overlay is highlighted between MK and END-MK."
                 ;; the error location if the two buffers are in two
                 ;; different frames.  So don't do it if it's not necessary.
                 pre-existing
-              (let ((display-buffer-reuse-frames t)
-                    (pop-up-windows t))
-                ;; Pop up a window.
-                (display-buffer (marker-buffer msg)))))
+              (display-buffer (marker-buffer msg))))
          (highlight-regexp (with-current-buffer (marker-buffer msg)
                              ;; also do this while we change buffer
                              (compilation-set-window w msg)
diff --git a/lisp/progmodes/executable.el b/lisp/progmodes/executable.el
index e5142571972..092e1a4d578 100644
--- a/lisp/progmodes/executable.el
+++ b/lisp/progmodes/executable.el
@@ -84,8 +84,9 @@ When this is `function', only ask when called non-interactively."
   :group 'executable)
 
 
-(defcustom executable-prefix "#! "
+(defcustom executable-prefix "#!"
   "Interpreter magic number prefix inserted when there was no magic number."
+  :version "24.3"                       ; "#! " -> "#!"
   :type 'string
   :group 'executable)
 
diff --git a/lisp/progmodes/gdb-mi.el b/lisp/progmodes/gdb-mi.el
index 0a99c2f5c24..59c419abfc3 100644
--- a/lisp/progmodes/gdb-mi.el
+++ b/lisp/progmodes/gdb-mi.el
@@ -1413,29 +1413,6 @@ this trigger is subscribed to `gdb-buf-publisher' and called with
      (with-current-buffer ,buffer
        (apply ',expr args))))
 
-;; Used to define all gdb-frame-*-buffer functions except
-;; `gdb-frame-io-buffer'
-(defmacro def-gdb-frame-for-buffer (name buffer &optional doc)
-  "Define a function NAME which shows gdb BUFFER in a separate frame.
-
-DOC is an optional documentation string."
-  `(defun ,name (&optional thread)
-     ,(when doc doc)
-     (interactive)
-     (let ((special-display-regexps (append special-display-regexps '(".*")))
-           (special-display-frame-alist gdb-frame-parameters))
-       (display-buffer (gdb-get-buffer-create ,buffer thread)))))
-
-(defmacro def-gdb-display-buffer (name buffer &optional doc)
-  "Define a function NAME which shows gdb BUFFER.
-
-DOC is an optional documentation string."
-  `(defun ,name (&optional thread)
-     ,(when doc doc)
-     (interactive)
-     (gdb-display-buffer
-      (gdb-get-buffer-create ,buffer thread) t)))
-
 ;; Used to display windows with thread-bound buffers
 (defmacro def-gdb-preempt-display-buffer (name buffer &optional doc
                                                split-horizontal)
@@ -1511,8 +1488,7 @@ DOC is an optional documentation string."
 (defun gdb-display-io-buffer ()
   "Display IO of debugged program in a separate window."
   (interactive)
-  (gdb-display-buffer
-   (gdb-get-buffer-create 'gdb-inferior-io) t))
+  (gdb-display-buffer (gdb-get-buffer-create 'gdb-inferior-io)))
 
 (defun gdb-inferior-io--init-proc (proc)
   ;; Set up inferior I/O.  Needs GDB 6.4 onwards.
@@ -1540,19 +1516,24 @@ DOC is an optional documentation string."
         (comint-exec io-buffer "gdb-inferior" nil nil nil)
         (gdb-inferior-io--init-proc (get-buffer-process io-buffer))))))
 
-(defconst gdb-frame-parameters
-  '((height . 14) (width . 80)
-    (unsplittable . t)
-    (tool-bar-lines . nil)
-    (menu-bar-lines . nil)
-    (minibuffer . nil)))
+(defvar gdb-display-buffer-other-frame-action
+  `((display-buffer-reuse-window display-buffer-pop-up-frame)
+    (reusable-frames . 0)
+    (inhibit-same-window . t)
+    (pop-up-frame-parameters (height . 14)
+                             (width . 80)
+                             (unsplittable . t)
+                             (tool-bar-lines . nil)
+                             (menu-bar-lines . nil)
+                             (minibuffer . nil)))
+  "A `display-buffer' action for displaying GDB utility frames.")
+(put 'gdb-display-buffer-other-frame-action 'risky-local-variable t)
 
 (defun gdb-frame-io-buffer ()
-  "Display IO of debugged program in a new frame."
+  "Display IO of debugged program in another frame."
   (interactive)
-  (let ((special-display-regexps (append special-display-regexps '(".*")))
-        (special-display-frame-alist gdb-frame-parameters))
-    (display-buffer (gdb-get-buffer-create 'gdb-inferior-io))))
+  (display-buffer (gdb-get-buffer-create 'gdb-inferior-io)
+                  gdb-display-buffer-other-frame-action))
 
 (defvar gdb-inferior-io-mode-map
   (let ((map (make-sparse-keymap)))
@@ -1571,7 +1552,7 @@ DOC is an optional documentation string."
 
 (defun gdb-inferior-filter (proc string)
   (unless (string-equal string "")
-    (gdb-display-buffer (gdb-get-buffer-create 'gdb-inferior-io) t))
+    (gdb-display-buffer (gdb-get-buffer-create 'gdb-inferior-io)))
   (with-current-buffer (gdb-get-buffer-create 'gdb-inferior-io)
     (comint-output-filter proc string)))
 
@@ -2615,15 +2596,16 @@ If not in a source or disassembly buffer just set point."
 (defun gdb-breakpoints-buffer-name ()
   (concat "*breakpoints of " (gdb-get-target-string) "*"))
 
-(def-gdb-display-buffer
-  gdb-display-breakpoints-buffer
-  'gdb-breakpoints-buffer
-  "Display status of user-settable breakpoints.")
+(defun gdb-display-breakpoints-buffer (&optional thread)
+  "Display GDB breakpoints."
+  (interactive)
+  (gdb-display-buffer (gdb-get-buffer-create 'gdb-breakpoints-buffer thread)))
 
-(def-gdb-frame-for-buffer
-  gdb-frame-breakpoints-buffer
-  'gdb-breakpoints-buffer
-  "Display status of user-settable breakpoints in a new frame.")
+(defun gdb-frame-breakpoints-buffer (&optional thread)
+  "Display GDB breakpoints in another frame."
+  (interactive)
+  (display-buffer (gdb-get-buffer-create 'gdb-breakpoints-buffer thread)
+                  gdb-display-buffer-other-frame-action))
 
 (defvar gdb-breakpoints-mode-map
   (let ((map (make-sparse-keymap))
@@ -2684,15 +2666,16 @@ corresponding to the mode line clicked."
 (defun gdb-threads-buffer-name ()
   (concat "*threads of " (gdb-get-target-string) "*"))
 
-(def-gdb-display-buffer
-  gdb-display-threads-buffer
-  'gdb-threads-buffer
-  "Display GDB threads.")
+(defun gdb-display-threads-buffer (&optional thread)
+  "Display GDB threads."
+  (interactive)
+  (gdb-display-buffer (gdb-get-buffer-create 'gdb-threads-buffer thread)))
 
-(def-gdb-frame-for-buffer
-  gdb-frame-threads-buffer
-  'gdb-threads-buffer
-  "Display GDB threads in a new frame.")
+(defun gdb-frame-threads-buffer (&optional thread)
+  "Display GDB threads in another frame."
+  (interactive)
+  (display-buffer (gdb-get-buffer-create 'gdb-threads-buffer thread)
+                  gdb-display-buffer-other-frame-action))
 
 (def-gdb-trigger-and-handler
   gdb-invalidate-threads (gdb-current-context-command "-thread-info")
@@ -2868,26 +2851,22 @@ on the current line."
 (def-gdb-thread-buffer-simple-command
   gdb-frame-stack-for-thread
   gdb-frame-stack-buffer
-  "Display a new frame with stack buffer for the thread at
-current line.")
+  "Display another frame with stack buffer for thread at current line.")
 
 (def-gdb-thread-buffer-simple-command
   gdb-frame-locals-for-thread
   gdb-frame-locals-buffer
-  "Display a new frame with locals buffer for the thread at
-current line.")
+  "Display another frame with locals buffer for thread at current line.")
 
 (def-gdb-thread-buffer-simple-command
   gdb-frame-registers-for-thread
   gdb-frame-registers-buffer
-  "Display a new frame with registers buffer for the thread at
-current line.")
+  "Display another frame with registers buffer for the thread at current line.")
 
 (def-gdb-thread-buffer-simple-command
   gdb-frame-disassembly-for-thread
   gdb-frame-disassembly-buffer
-  "Display a new frame with disassembly buffer for the thread at
-current line.")
+  "Display another frame with disassembly buffer for the thread at current line.")
 
 (defmacro def-gdb-thread-buffer-gud-command (name gud-command &optional doc)
   "Define a NAME which will execute GUD-COMMAND with
@@ -3290,21 +3269,16 @@ DOC is an optional documentation string."
 (defun gdb-memory-buffer-name ()
   (concat "*memory of " (gdb-get-target-string) "*"))
 
-(def-gdb-display-buffer
-  gdb-display-memory-buffer
-  'gdb-memory-buffer
-  "Display memory contents.")
+(defun gdb-display-memory-buffer (&optional thread)
+  "Display GDB memory contents."
+  (interactive)
+  (gdb-display-buffer (gdb-get-buffer-create 'gdb-memory-buffer thread)))
 
 (defun gdb-frame-memory-buffer ()
-  "Display memory contents in a new frame."
+  "Display memory contents in another frame."
   (interactive)
-  (let* ((special-display-regexps (append special-display-regexps '(".*")))
-         (special-display-frame-alist
-          `((left-fringe . 0)
-            (right-fringe . 0)
-            (width . 83)
-            ,@gdb-frame-parameters)))
-    (display-buffer (gdb-get-buffer-create 'gdb-memory-buffer))))
+  (display-buffer (gdb-get-buffer-create 'gdb-memory-buffer)
+                  gdb-display-buffer-other-frame-action))
 
 
 ;;; Disassembly view
@@ -3313,19 +3287,20 @@ DOC is an optional documentation string."
   (gdb-current-context-buffer-name
    (concat "disassembly of " (gdb-get-target-string))))
 
-(def-gdb-display-buffer
-  gdb-display-disassembly-buffer
-  'gdb-disassembly-buffer
-  "Display disassembly for current stack frame.")
+(defun gdb-display-disassembly-buffer (&optional thread)
+  "Display GDB disassembly information."
+  (interactive)
+  (gdb-display-buffer (gdb-get-buffer-create 'gdb-disassembly-buffer thread)))
 
 (def-gdb-preempt-display-buffer
   gdb-preemptively-display-disassembly-buffer
   'gdb-disassembly-buffer)
 
-(def-gdb-frame-for-buffer
-  gdb-frame-disassembly-buffer
-  'gdb-disassembly-buffer
-  "Display disassembly in a new frame.")
+(defun gdb-frame-disassembly-buffer (&optional thread)
+  "Display GDB disassembly information in another frame."
+  (interactive)
+  (display-buffer (gdb-get-buffer-create 'gdb-disassembly-buffer thread)
+                  gdb-display-buffer-other-frame-action))
 
 (def-gdb-auto-update-trigger gdb-invalidate-disassembly
   (let* ((frame (gdb-current-buffer-frame))
@@ -3560,19 +3535,20 @@ member."
   (gdb-current-context-buffer-name
    (concat "stack frames of " (gdb-get-target-string))))
 
-(def-gdb-display-buffer
-  gdb-display-stack-buffer
-  'gdb-stack-buffer
-  "Display backtrace of current stack.")
+(defun gdb-display-stack-buffer (&optional thread)
+  "Display GDB backtrace for current stack."
+  (interactive)
+  (gdb-display-buffer (gdb-get-buffer-create 'gdb-stack-buffer thread)))
 
 (def-gdb-preempt-display-buffer
   gdb-preemptively-display-stack-buffer
   'gdb-stack-buffer nil t)
 
-(def-gdb-frame-for-buffer
-  gdb-frame-stack-buffer
-  'gdb-stack-buffer
-  "Display backtrace of current stack in a new frame.")
+(defun gdb-frame-stack-buffer (&optional thread)
+  "Display GDB backtrace for current stack in another frame."
+  (interactive)
+  (display-buffer (gdb-get-buffer-create 'gdb-stack-buffer thread)
+                  gdb-display-buffer-other-frame-action))
 
 (defvar gdb-frames-mode-map
   (let ((map (make-sparse-keymap)))
@@ -3719,19 +3695,20 @@ member."
   (gdb-current-context-buffer-name
    (concat "locals of " (gdb-get-target-string))))
 
-(def-gdb-display-buffer
-  gdb-display-locals-buffer
-  'gdb-locals-buffer
-  "Display local variables of current stack and their values.")
+(defun gdb-display-locals-buffer (&optional thread)
+  "Display the local variables of current GDB stack."
+  (interactive)
+  (gdb-display-buffer (gdb-get-buffer-create 'gdb-locals-buffer thread)))
 
 (def-gdb-preempt-display-buffer
   gdb-preemptively-display-locals-buffer
   'gdb-locals-buffer nil t)
 
-(def-gdb-frame-for-buffer
-  gdb-frame-locals-buffer
-  'gdb-locals-buffer
-  "Display local variables of current stack and their values in a new frame.")
+(defun gdb-frame-locals-buffer (&optional thread)
+  "Display the local variables of the current GDB stack in another frame."
+  (interactive)
+  (display-buffer (gdb-get-buffer-create 'gdb-locals-buffer thread)
+                  gdb-display-buffer-other-frame-action))
 
 
 ;; Registers buffer.
@@ -3818,19 +3795,20 @@ member."
   (gdb-current-context-buffer-name
    (concat "registers of " (gdb-get-target-string))))
 
-(def-gdb-display-buffer
-  gdb-display-registers-buffer
-  'gdb-registers-buffer
-  "Display integer register contents.")
+(defun gdb-display-registers-buffer (&optional thread)
+  "Display GDB register contents."
+  (interactive)
+  (gdb-display-buffer (gdb-get-buffer-create 'gdb-registers-buffer thread)))
 
 (def-gdb-preempt-display-buffer
   gdb-preemptively-display-registers-buffer
   'gdb-registers-buffer nil t)
 
-(def-gdb-frame-for-buffer
-  gdb-frame-registers-buffer
-  'gdb-registers-buffer
-  "Display integer register contents in a new frame.")
+(defun gdb-frame-registers-buffer (&optional thread)
+  "Display GDB register contents in another frame."
+  (interactive)
+  (display-buffer (gdb-get-buffer-create 'gdb-registers-buffer thread)
+                  gdb-display-buffer-other-frame-action))
 
 ;; Needs GDB 6.4 onwards (used to fail with no stack).
 (defun gdb-get-changed-registers ()
@@ -3917,26 +3895,26 @@ overlay arrow in source buffer."
   (setq gdb-filter-output (concat gdb-filter-output gdb-prompt-name)))
 
 ;;;; Window management
-(defun gdb-display-buffer (buf dedicated &optional frame)
-  "Show buffer BUF.
-
-If BUF is already displayed in some window, show it, deiconifying
-the frame if necessary. Otherwise, find least recently used
-window and show BUF there, if the window is not used for GDB
-already, in which case that window is split first."
-  (let ((answer (get-buffer-window buf (or frame 0))))
-    (if answer
-        (display-buffer buf nil (or frame 0)) ;Deiconify frame if necessary.
-      (let ((window (get-lru-window)))
-        (if (eq (buffer-local-value 'gud-minor-mode (window-buffer window))
-                'gdbmi)
-            (let ((largest (get-largest-window)))
-              (setq answer (split-window largest))
-              (set-window-buffer answer buf)
-              (set-window-dedicated-p answer dedicated)
-              answer)
-          (set-window-buffer window buf)
-          window)))))
+(defun gdb-display-buffer (buf)
+  "Show buffer BUF, and make that window dedicated."
+  (let ((window (display-buffer buf)))
+    (set-window-dedicated-p window t)
+    window))
+
+  ;; (let ((answer (get-buffer-window buf 0)))
+  ;;   (if answer
+  ;;    (display-buffer buf nil 0) ;Deiconify frame if necessary.
+  ;;     (let ((window (get-lru-window)))
+  ;;    (if (eq (buffer-local-value 'gud-minor-mode (window-buffer window))
+  ;;               'gdbmi)
+  ;;        (let ((largest (get-largest-window)))
+  ;;          (setq answer (split-window largest))
+  ;;          (set-window-buffer answer buf)
+  ;;          (set-window-dedicated-p answer t)
+  ;;          answer)
+  ;;      (set-window-buffer window buf)
+  ;;      window)))))
+
 
 (defun gdb-preempt-existing-or-display-buffer (buf &optional split-horizontal)
   "Find window displaying a buffer with the same
@@ -3963,7 +3941,7 @@ SPLIT-HORIZONTAL and show BUF in the new window."
               (if dedicated-window
                   (set-window-buffer
                    (split-window dedicated-window nil split-horizontal) buf)
-                (gdb-display-buffer buf t))))))
+                (gdb-display-buffer buf))))))
     (error "Null buffer")))
 
 ;;; Shared keymap initialization:
@@ -4067,7 +4045,7 @@ SPLIT-HORIZONTAL and show BUF in the new window."
   'all-threads)
 
 (defun gdb-frame-gdb-buffer ()
-  "Display GUD buffer in a new frame."
+  "Display GUD buffer in another frame."
   (interactive)
   (display-buffer-other-frame gud-comint-buffer))
 
@@ -4089,13 +4067,12 @@ window is dedicated."
 
 (defun gdb-setup-windows ()
   "Layout the window pattern for `gdb-many-windows'."
-  (gdb-display-locals-buffer)
-  (gdb-display-stack-buffer)
-  (delete-other-windows)
-  (gdb-display-breakpoints-buffer)
-  (delete-other-windows)
-  ;; Don't dedicate.
+  (gdb-get-buffer-create 'gdb-locals-buffer)
+  (gdb-get-buffer-create 'gdb-stack-buffer)
+  (gdb-get-buffer-create 'gdb-breakpoints-buffer)
+  (set-window-dedicated-p (selected-window) nil)
   (switch-to-buffer gud-comint-buffer)
+  (delete-other-windows)
   (let ((win0 (selected-window))
         (win1 (split-window nil ( / ( * (window-height) 3) 4)))
         (win2 (split-window nil ( / (window-height) 3)))
diff --git a/lisp/progmodes/gud.el b/lisp/progmodes/gud.el
index 5946e93f34d..2e3858b2cc5 100644
--- a/lisp/progmodes/gud.el
+++ b/lisp/progmodes/gud.el
@@ -2685,7 +2685,6 @@ Obeying it means displaying in another window the specified file and line."
 (declare-function global-hl-line-highlight  "hl-line" ())
 (declare-function hl-line-highlight         "hl-line" ())
 (declare-function gdb-display-source-buffer "gdb-mi"  (buffer))
-(declare-function gdb-display-buffer "gdb-mi" (buf dedicated &optional size))
 
 ;; Make sure the file named TRUE-FILE is in a buffer that appears on the screen
 ;; and that its line LINE is visible.
@@ -2702,10 +2701,7 @@ Obeying it means displaying in another window the specified file and line."
          (window (and buffer
                       (or (get-buffer-window buffer)
                           (if (eq gud-minor-mode 'gdbmi)
-                              (or (if (get-buffer-window buffer 'visible)
-                                      (display-buffer buffer nil 'visible))
-                                  (unless (gdb-display-source-buffer buffer)
-                                    (gdb-display-buffer buffer nil 'visible))))
+                              (display-buffer buffer nil 'visible))
                           (display-buffer buffer))))
          (pos))
     (if buffer
diff --git a/lisp/vc/vc-cvs.el b/lisp/vc/vc-cvs.el
index 2a672623c01..c1c4b750267 100644
--- a/lisp/vc/vc-cvs.el
+++ b/lisp/vc/vc-cvs.el
@@ -1178,7 +1178,11 @@ is non-nil."
                                (parse-time-string (concat time " +0000")))))
       (cond ((and (not (string-match "\\+" time))
                   (car parsed-time)
-                  (equal mtime (apply 'encode-time parsed-time)))
+                  ;; Compare just the seconds part of the file time,
+                  ;; since CVS file time stamp resolution is just 1 second.
+                  (let ((ptime (apply 'encode-time parsed-time)))
+                    (and (eq (car mtime) (car ptime))
+                         (eq (cadr mtime) (cadr ptime)))))
              (vc-file-setprop file 'vc-checkout-time mtime)
              (if set-state (vc-file-setprop file 'vc-state 'up-to-date)))
             (t
diff --git a/lisp/window.el b/lisp/window.el
index ab90d8a4bde..3599ff5527f 100644
--- a/lisp/window.el
+++ b/lisp/window.el
@@ -357,6 +357,45 @@ WINDOW must be an internal window.  Return WINDOW."
      window t)
     window))
 
+(defun display-buffer-in-atom-window (buffer alist)
+  "Display BUFFER in an atomic window.
+This function displays BUFFER in a new window that will be
+combined with an existing window to form an atomic window.  If
+the existing window is already part of an atomic window, add the
+new window to that atomic window.  Operations like `split-window'
+or `delete-window', when applied to a constituent of an atomic
+window, are applied atomically to the root of that atomic window.
+
+ALIST is an association list of symbols and values.  The
+following symbols can be used.
+
+`window' specifies the existing window the new window shall be
+  combined with.  Use `window-atom-root' to make the new window a
+  sibling of an atomic window's root.  If an internal window is
+  specified here, all children of that window become part of the
+  atomic window too.  If no window is specified, the new window
+  becomes a sibling of the selected window.
+
+`side' denotes the side of the existing window where the new
+  window shall be located.  Valid values are `below', `right',
+  `above' and `left'.  The default is `below'.
+
+The return value is the new window, nil when creating that window
+failed."
+  (let ((ignore-window-parameters t)
+        (window-combination-limit t)
+        (window (cdr (assq 'window alist)))
+        (side (cdr (assq 'side alist)))
+        new)
+    (setq window (window-normalize-window window))
+    ;; Split off new window
+    (when (setq new (split-window window nil side))
+      ;; Make sure we have a valid atomic window.
+      (window-make-atom (window-parent window))
+      ;; Display BUFFER in NEW and return NEW.
+      (window--display-buffer
+       buffer new 'window display-buffer-mark-dedicated))))
+
 (defun window--atom-check-1 (window)
   "Subroutine of `window--atom-check'."
   (when window
@@ -446,23 +485,273 @@ number of slots on that side."
      (integer :tag "Number" :value 3 :size 5)))
   :group 'windows)
 
+(defun window--major-non-side-window (&optional frame)
+  "Return the major non-side window of frame FRAME.
+The optional argument FRAME must be a live frame and defaults to
+the selected one.
+
+If FRAME has at least one side window, the major non-side window
+is either an internal non-side window such that all other
+non-side windows on FRAME descend from it, or the single live
+non-side window of FRAME.  If FRAME has no side windows, return
+its root window."
+  (let ((frame (window-normalize-frame frame))
+        major sibling)
+    ;; Set major to the _last_ window found by `walk-window-tree' that
+    ;; is not a side window but has a side window as its sibling.
+    (walk-window-tree
+     (lambda (window)
+       (and (not (window-parameter window 'window-side))
+            (or (and (setq sibling (window-prev-sibling window))
+                     (window-parameter sibling 'window-side))
+                (and (setq sibling (window-next-sibling window))
+                     (window-parameter sibling 'window-side)))
+            (setq major window)))
+     frame t)
+    (or major (frame-root-window frame))))
+
+(defun window--major-side-window (side)
+  "Return major side window on SIDE.
+SIDE must be one of the symbols `left', `top', `right' or
+`bottom'.  Return nil if no such window exists."
+  (let ((root (frame-root-window))
+        window)
+    ;; (1) If a window on the opposite side exists, return that window's
+    ;;     sibling.
+    ;; (2) If the new window shall span the entire side, return the
+    ;;     frame's root window.
+    ;; (3) If a window on an orthogonal side exists, return that
+    ;;     window's sibling.
+    ;; (4) Otherwise return the frame's root window.
+    (cond
+     ((or (and (eq side 'left)
+               (setq window (window-with-parameter 'window-side 'right nil t)))
+          (and (eq side 'top)
+               (setq window (window-with-parameter 'window-side 'bottom nil t))))
+      (window-prev-sibling window))
+     ((or (and (eq side 'right)
+               (setq window (window-with-parameter 'window-side 'left nil t)))
+          (and (eq side 'bottom)
+               (setq window (window-with-parameter 'window-side 'top nil t))))
+      (window-next-sibling window))
+     ((memq side '(left right))
+      (cond
+       (window-sides-vertical
+        root)
+       ((setq window (window-with-parameter 'window-side 'top nil t))
+        (window-next-sibling window))
+       ((setq window (window-with-parameter 'window-side 'bottom nil t))
+        (window-prev-sibling window))
+       (t root)))
+     ((memq side '(top bottom))
+      (cond
+       ((not window-sides-vertical)
+        root)
+       ((setq window (window-with-parameter 'window-side 'left nil t))
+        (window-next-sibling window))
+       ((setq window (window-with-parameter 'window-side 'right nil t))
+        (window-prev-sibling window))
+       (t root))))))
+
+(defun display-buffer-in-major-side-window (buffer side slot &optional alist)
+  "Display BUFFER in a new window on SIDE of the selected frame.
+SIDE must be one of `left', `top', `right' or `bottom'.  SLOT
+specifies the slot to use.  ALIST is an association list of
+symbols and values as passed to `display-buffer-in-side-window'.
+This function may be called only if no window on SIDE exists yet.
+The new window automatically becomes the \"major\" side window on
+SIDE.  Return the new window, nil if its creation window failed."
+  (let* ((root (frame-root-window))
+         (left-or-right (memq side '(left right)))
+         (size (or (assq 'size alist)
+                   (/ (window-total-size (frame-root-window) left-or-right)
+                      ;; By default use a fourth of the size of the
+                      ;; frame's root window.  This has to be made
+                      ;; customizable via ALIST.
+                      4)))
+         (major (window--major-side-window side))
+         (selected-window (selected-window))
+         (on-side (cond
+                   ((eq side 'top) 'above)
+                   ((eq side 'bottom) 'below)
+                   (t side)))
+         ;; The following two bindings will tell `split-window' to take
+         ;; the space for the new window from `major' and not make a new
+         ;; parent window unless needed.
+         (window-combination-resize 'side)
+         (window-combination-limit nil)
+         (new (split-window major (- size) on-side))
+         fun)
+    (when new
+      ;; Initialize `window-side' parameter of new window to SIDE.
+      (set-window-parameter new 'window-side side)
+      ;; Install `window-slot' parameter of new window.
+      (set-window-parameter new 'window-slot slot)
+      ;; Install `delete-window' parameter thus making sure that when
+      ;; the new window is deleted, a side window on the opposite side
+      ;; does not get resized.
+      (set-window-parameter new 'delete-window 'delete-side-window)
+      ;; Install BUFFER in new window and return NEW.
+      (window--display-buffer buffer new 'window 'side))))
+
+(defun delete-side-window (window)
+  "Delete side window WINDOW."
+  (let ((window-combination-resize
+         (window-parameter (window-parent window) 'window-side))
+        (ignore-window-parameters t))
+    (delete-window window)))
+
+(defun display-buffer-in-side-window (buffer alist)
+  "Display BUFFER in a window on side SIDE of the selected frame.
+ALIST is an association list of symbols and values.  The
+following symbols can be used:
+
+`side' denotes the side of the existing window where the new
+  window shall be located.  Valid values are `bottom', `right',
+  `top' and `left'.  The default is `bottom'.
+
+`slot' if non-nil, specifies the window slot where to display
+  BUFFER.  A value of zero or nil means use the middle slot on
+  the specified side.  A negative value means use a slot
+  preceding (that is, above or on the left of) the middle slot.
+  A positive value means use a slot following (that is, below or
+  on the right of) the middle slot.  The default is zero."
+  (let ((side (or (cdr (assq 'side alist)) 'bottom))
+        (slot (or (cdr (assq 'slot alist)) 0))
+        new)
+    (cond
+     ((not (memq side '(top bottom left right)))
+      (error "Invalid side %s specified" side))
+     ((not (numberp slot))
+      (error "Invalid slot %s specified" slot)))
+
+    (let* ((major (window-with-parameter 'window-side side nil t))
+           ;; `major' is the major window on SIDE, `windows' the list of
+           ;; life windows on SIDE.
+           (windows
+            (when major
+              (let (windows)
+                (walk-window-tree
+                 (lambda (window)
+                   (when (eq (window-parameter window 'window-side) side)
+                     (setq windows (cons window windows)))))
+                (nreverse windows))))
+           (slots (when major (max 1 (window-child-count major))))
+           (max-slots
+            (nth (cond
+                  ((eq side 'left) 0)
+                  ((eq side 'top) 1)
+                  ((eq side 'right) 2)
+                  ((eq side 'bottom) 3))
+                 window-sides-slots))
+           (selected-window (selected-window))
+           window this-window this-slot prev-window next-window
+           best-window best-slot abs-slot new-window)
+
+      (cond
+       ((and (numberp max-slots) (<= max-slots 0))
+        ;; No side-slots available on this side.  Don't create an error,
+        ;; just return nil.
+        nil)
+       ((not windows)
+        ;; No major window exists on this side, make one.
+        (display-buffer-in-major-side-window buffer side slot alist))
+       (t
+        ;; Scan windows on SIDE.
+        (catch 'found
+          (dolist (window windows)
+            (setq this-slot (window-parameter window 'window-slot))
+            (cond
+             ;; The following should not happen and probably be checked
+             ;; by window--side-check.
+             ((not (numberp this-slot)))
+             ((= this-slot slot)
+              ;; A window with a matching slot has been found.
+              (setq this-window window)
+              (throw 'found t))
+             (t
+              ;; Check if this window has a better slot value wrt the
+              ;; slot of the window we want.
+              (setq abs-slot
+                    (if (or (and (> this-slot 0) (> slot 0))
+                            (and (< this-slot 0) (< slot 0)))
+                        (abs (- slot this-slot))
+                      (+ (abs slot) (abs this-slot))))
+              (unless (and best-slot (<= best-slot abs-slot))
+                (setq best-window window)
+                (setq best-slot abs-slot))
+              (cond
+               ((<= this-slot slot)
+                (setq prev-window window))
+               ((not next-window)
+                (setq next-window window)))))))
+
+        ;; `this-window' is the first window with the same SLOT.
+        ;; `prev-window' is the window with the largest slot < SLOT.  A new
+        ;; window will be created after it.
+        ;; `next-window' is the window with the smallest slot > SLOT.  A new
+        ;; window will be created before it.
+        ;; `best-window' is the window with the smallest absolute difference
+        ;; of its slot and SLOT.
+
+        ;; Note: We dedicate the window used softly to its buffer to
+        ;; avoid that "other" (non-side) buffer display functions steal
+        ;; it from us.  This must eventually become customizable via
+        ;; ALIST (or, better, avoided in the "other" functions).
+        (or (and this-window
+                 ;; Reuse `this-window'.
+                 (window--display-buffer buffer this-window 'reuse 'side))
+            (and (or (not max-slots) (< slots max-slots))
+                 (or (and next-window
+                          ;; Make new window before `next-window'.
+                          (let ((next-side
+                                 (if (memq side '(left right)) 'above 'left))
+                                (window-combination-resize 'side))
+                            (setq window (split-window next-window nil next-side))
+                            ;; When the new window is deleted, its space
+                            ;; is returned to other side windows.
+                            (set-window-parameter
+                             window 'delete-window 'delete-side-window)
+                            window))
+                     (and prev-window
+                          ;; Make new window after `prev-window'.
+                          (let ((prev-side
+                                 (if (memq side '(left right)) 'below 'right))
+                                (window-combination-resize 'side))
+                            (setq window (split-window prev-window nil prev-side))
+                            ;; When the new window is deleted, its space
+                            ;; is returned to other side windows.
+                            (set-window-parameter
+                             window 'delete-window 'delete-side-window)
+                            window)))
+                   (set-window-parameter window 'window-slot slot)
+                   (window--display-buffer buffer window 'window 'side))
+            (and best-window
+                 ;; Reuse `best-window'.
+                 (progn
+                   ;; Give best-window the new slot value.
+                   (set-window-parameter best-window 'window-slot slot)
+                   (window--display-buffer buffer best-window 'reuse 'side)))))))))
+
 (defun window--side-check (&optional frame)
-  "Check the window-side parameter of all windows on FRAME.
-FRAME defaults to the selected frame.  If the configuration is
-invalid, reset all window-side parameters to nil.
-
-A valid configuration has to preserve the following invariant:
-
-- If a window has a non-nil window-side parameter, it must have a
-  parent window and the parent window's window-side parameter
-  must be either nil or the same as for window.
-
-- If windows with non-nil window-side parameters exist, there
-  must be at most one window of each side and non-side with a
-  parent whose window-side parameter is nil and there must be no
-  leaf window whose window-side parameter is nil."
-  (let (normal none left top right bottom
-        side parent parent-side)
+  "Check the side window configuration of FRAME.
+FRAME defaults to the selected frame.
+
+A valid side window configuration preserves the following two
+invariants:
+
+- If there exists a window whose window-side parameter is
+  non-nil, there must exist at least one live window whose
+  window-side parameter is nil.
+
+- If a window W has a non-nil window-side parameter (i) it must
+  have a parent window and that parent's window-side parameter
+  must be either nil or the same as for W, and (ii) any child
+  window of W must have the same window-side parameter as W.
+
+If the configuration is invalid, reset the window-side parameters
+of all windows on FRAME to nil."
+  (let (left top right bottom none side parent parent-side)
     (when (or (catch 'reset
                 (walk-window-tree
                  (lambda (window)
@@ -478,40 +767,34 @@ A valid configuration has to preserve the following invariant:
                        ;; A parent whose window-side is non-nil must
                        ;; have a child with the same window-side.
                        (throw 'reset t)))
-                    ;; Now check that there's more than one main window
-                    ;; for any of none, left, top, right and bottom.
-                    ((eq side 'none)
-                     (if none
-                         (throw 'reset t)
+                    ((not side)
+                     (when (window-buffer window)
+                       ;; Record that we have at least one non-side,
+                       ;; live window.
                        (setq none t)))
+                    ((if (memq side '(left top))
+                         (window-prev-sibling window)
+                       (window-next-sibling window))
+                     ;; Left and top major side windows must not have a
+                     ;; previous sibling, right and bottom major side
+                     ;; windows must not have a next sibling.
+                     (throw 'reset t))
+                    ;; Now check that there's no more than one major
+                    ;; window for any of left, top, right and bottom.
                     ((eq side 'left)
-                     (if left
-                         (throw 'reset t)
-                       (setq left t)))
+                     (if left (throw 'reset t) (setq left t)))
                     ((eq side 'top)
-                     (if top
-                         (throw 'reset t)
-                       (setq top t)))
+                     (if top (throw 'reset t) (setq top t)))
                     ((eq side 'right)
-                     (if right
-                         (throw 'reset t)
-                       (setq right t)))
+                     (if right (throw 'reset t) (setq right t)))
                     ((eq side 'bottom)
-                     (if bottom
-                         (throw 'reset t)
-                       (setq bottom t)))
-                    ((window-buffer window)
-                     ;; A leaf window without window-side parameter,
-                     ;; record its existence.
-                     (setq normal t))))
+                     (if bottom (throw 'reset t) (setq bottom t)))
+                    (t 
+                     (throw 'reset t))))
                  frame t))
-              (if none
-                  ;; At least one non-side window exists, so there must
-                  ;; be at least one side-window and no normal window.
-                  (or (not (or left top right bottom)) normal)
-                ;; No non-side window exists, so there must be no side
-                ;; window either.
-                (or left top right bottom)))
+              ;; If there's a side window, there must be at least one
+              ;; non-side window.
+              (and (or left top right bottom) (not none)))
       (walk-window-tree
        (lambda (window)
          (set-window-parameter window 'window-side nil))
@@ -2393,8 +2676,7 @@ Return `frame' if deleting WINDOW should also delete its frame."
     (when (window-parameter window 'window-atom)
       (setq window (window-atom-root window))))
 
-  (let ((parent (window-parent window))
-        (frame (window-frame window)))
+  (let ((frame (window-frame window)))
     (cond
      ((frame-root-window-p window)
       ;; WINDOW's frame can be deleted only if there are other frames
@@ -2405,10 +2687,9 @@ Return `frame' if deleting WINDOW should also delete its frame."
                     (and minibuf (eq frame (window-frame minibuf)))))
         'frame))
      ((or ignore-window-parameters
-          (not (eq (window-parameter window 'window-side) 'none))
-          (and parent (eq (window-parameter parent 'window-side) 'none)))
-      ;; WINDOW can be deleted unless it is the main window of its
-      ;; frame.
+          (not (eq window (window--major-non-side-window frame))))
+      ;; WINDOW can be deleted unless it is the major non-side window of
+      ;; its frame.
       t))))
 
 (defun window--in-subtree-p (window root)
@@ -2459,13 +2740,13 @@ that is its frame's root window."
        ((and (window-parameter window 'window-atom)
              (setq atom-root (window-atom-root window))
              (not (eq atom-root window)))
-        (throw 'done (delete-window atom-root)))
-       ((and (eq (window-parameter window 'window-side) 'none)
-             (or (not parent)
-                 (not (eq (window-parameter parent 'window-side) 'none))))
-        (error "Attempt to delete last non-side window"))
+        (if (eq atom-root (frame-root-window frame))
+            (error "Root of atomic window is root window of its frame")
+          (throw 'done (delete-window atom-root))))
        ((not parent)
-        (error "Attempt to delete minibuffer or sole ordinary window")))
+        (error "Attempt to delete minibuffer or sole ordinary window"))
+       ((eq window (window--major-non-side-window frame))
+        (error "Attempt to delete last non-side window")))
 
       (let* ((horizontal (window-left-child parent))
              (size (window-total-size window horizontal))
@@ -2539,13 +2820,19 @@ window signal an error."
        ((and (window-parameter window 'window-atom)
              (setq atom-root (window-atom-root window))
              (not (eq atom-root window)))
-        (throw 'done (delete-other-windows atom-root)))
-       ((eq window-side 'none)
-        ;; Set side-main to the major non-side window.
-        (setq side-main (window-with-parameter 'window-side 'none frame t)))
+        (if (eq atom-root (frame-root-window frame))
+            (error "Root of atomic window is root window of its frame")
+          (throw 'done (delete-other-windows atom-root))))
        ((memq window-side window-sides)
-        (error "Cannot make side window the only window")))
-      ;; If WINDOW is the main non-side window, do nothing.
+        (error "Cannot make side window the only window"))
+       ((and (window-minibuffer-p window)
+             (not (eq window (frame-root-window window))))
+        (error "Can't expand minibuffer to full frame")))
+
+      ;; If WINDOW is the major non-side window, do nothing.
+      (if (window-with-parameter 'window-side)
+          (setq side-main (window--major-non-side-window frame))
+        (setq side-main (frame-root-window frame)))
       (unless (eq window side-main)
         (delete-other-windows-internal window side-main)
         (run-window-configuration-change-hook frame)
@@ -3204,14 +3491,16 @@ frame.  The selected window is not changed by this function."
                 ((not side) 'below)
                 ((memq side '(below above right left)) side)
                 (t 'right)))
-         (horizontal (not (memq side '(nil below above))))
+         (horizontal (not (memq side '(below above))))
          (frame (window-frame window))
          (parent (window-parent window))
          (function (window-parameter window 'split-window))
          (window-side (window-parameter window 'window-side))
-         ;; Rebind `window-combination-limit' since in some cases we may
-         ;; have to override its value.
+         ;; Rebind `window-combination-limit' and
+         ;; `window-combination-resize' since in some cases we may have
+         ;; to override their value.
          (window-combination-limit window-combination-limit)
+         (window-combination-resize window-combination-resize)
          atom-root)
 
     (window--check frame)
@@ -3229,20 +3518,32 @@ frame.  The selected window is not changed by this function."
        ((and (window-parameter window 'window-atom)
              (setq atom-root (window-atom-root window))
              (not (eq atom-root window)))
-        (throw 'done (split-window atom-root size side))))
-
-      (when (and window-side
-                 (or (not parent)
-                     (not (window-parameter parent 'window-side))))
-        ;; WINDOW is a side root window.  To make sure that a new parent
-        ;; window gets created set `window-combination-limit' to t.
-        (setq window-combination-limit t))
-
-      (when (and window-combination-resize size (> size 0))
-        ;; If `window-combination-resize' is non-nil and SIZE is a
-        ;; non-negative integer, we cannot reasonably resize other
-        ;; windows.  Rather bind `window-combination-limit' to t to make
-        ;; sure that subsequent window deletions are handled correctly.
+        (throw 'done (split-window atom-root size side)))
+       ;; If WINDOW is a side window or its first or last child is a
+       ;; side window, throw an error unless `window-combination-resize'
+       ;; equals 'side.
+       ((and (not (eq window-combination-resize 'side))
+             (or (window-parameter window 'window-side)
+                 (and (window-child window)
+                      (or (window-parameter
+                           (window-child window) 'window-side)
+                          (window-parameter
+                           (window-last-child window) 'window-side)))))
+        (error "Cannot split side window or parent of side window"))
+       ;; If `window-combination-resize' is 'side and window has a side
+       ;; window sibling, bind `window-combination-limit' to t.
+       ((and (not (eq window-combination-resize 'side))
+             (or (and (window-prev-sibling window)
+                      (window-parameter
+                       (window-prev-sibling window) 'window-side))
+                 (and (window-next-sibling window)
+                      (window-parameter
+                       (window-next-sibling window) 'window-side))))
+        (setq window-combination-limit t)))
+
+      ;; If `window-combination-resize' is t and SIZE is non-negative,
+      ;; bind `window-combination-limit' to t.
+      (when (and (eq window-combination-resize t) size (> size 0))
         (setq window-combination-limit t))
 
       (let* ((parent-size
@@ -3252,7 +3553,10 @@ frame.  The selected window is not changed by this function."
              ;; `resize' non-nil means we are supposed to resize other
              ;; windows in WINDOW's combination.
              (resize
-              (and window-combination-resize (not window-combination-limit)
+              (and window-combination-resize
+                   (or (window-parameter window 'window-side)
+                       (not (eq window-combination-resize 'side)))
+                   (not window-combination-limit)
                    ;; Resize makes sense in iso-combinations only.
                    (window-combined-p window horizontal)))
              ;; `old-size' is the current size of WINDOW.
@@ -3363,10 +3667,21 @@ frame.  The selected window is not changed by this function."
                      new-normal)))
 
         (let* ((new (split-window-internal window new-size side new-normal)))
-          ;; Inherit window-side parameters, if any.
-          (when (and window-side new-parent)
-            (set-window-parameter (window-parent new) 'window-side window-side)
-            (set-window-parameter new 'window-side window-side))
+          ;; Assign window-side parameters, if any.
+          (when (eq window-combination-resize 'side)
+            (let ((window-side
+                   (cond
+                    (window-side window-side)
+                    ((eq side 'above) 'top)
+                    ((eq side 'below) 'bottom)
+                    (t side))))
+              ;; We made a new side window.
+              (set-window-parameter new 'window-side window-side)
+              (when (and new-parent (window-parameter window 'window-side))
+                ;; We've been splitting a side root window.  Give the
+                ;; new parent the same window-side parameter.
+                (set-window-parameter
+                 (window-parent new) 'window-side window-side))))
 
           (run-window-configuration-change-hook frame)
           (window--check frame)
@@ -4054,12 +4369,11 @@ of the window used."
           (function :tag "function"))
   :group 'windows)
 
+;; Eventually, we want to turn this into a defvar; instead of
+;; customizing this, the user should use a `pop-up-frame-parameters'
+;; alist entry in `display-buffer-base-action'.
 (defcustom pop-up-frame-alist nil
   "Alist of parameters for automatically generated new frames.
-You can set this in your init file; for example,
-
-  (setq pop-up-frame-alist '((width . 80) (height . 20)))
-
 If non-nil, the value you specify here is used by the default
 `pop-up-frame-function' for the creation of new frames.
 
@@ -4146,8 +4460,7 @@ See also `special-display-regexps'."
                         (repeat :tag "Arguments" (sexp)))))
   :group 'windows
   :group 'frames)
-
-;;;###autoload
+(make-obsolete-variable 'special-display-buffer-names 'display-buffer-alist "24.3")
 (put 'special-display-buffer-names 'risky-local-variable t)
 
 (defcustom special-display-regexps nil
@@ -4214,6 +4527,8 @@ See also `special-display-buffer-names'."
                         (repeat :tag "Arguments" (sexp)))))
   :group 'windows
   :group 'frames)
+(make-obsolete-variable 'special-display-regexps 'display-buffer-alist "24.3")
+(put 'special-display-regexps 'risky-local-variable t)
 
 (defun special-display-p (buffer-name)
   "Return non-nil if a buffer named BUFFER-NAME gets a special frame.
@@ -4255,6 +4570,7 @@ These supersede the values given in `default-frame-alist'."
                          (symbol :tag "Parameter")
                          (sexp :tag "Value")))
   :group 'frames)
+(make-obsolete-variable 'special-display-frame-alist 'display-buffer-alist "24.3")
 
 (defun special-display-popup-frame (buffer &optional args)
   "Pop up a frame displaying BUFFER and return its window.
@@ -4321,6 +4637,7 @@ with corresponding arguments to set up the quit-restore parameter
 of the window used."
   :type 'function
   :group 'frames)
+(make-obsolete-variable 'special-display-function 'display-buffer-alist "24.3")
 
 (defcustom same-window-buffer-names nil
   "List of names of buffers that should appear in the \"same\" window.
@@ -4393,6 +4710,7 @@ that frame."
   :type 'boolean
   :version "21.1"
   :group 'windows)
+(make-obsolete-variable 'display-buffer-reuse-frames 'display-buffer-alist "24.3")
 
 (defcustom pop-up-windows t
   "Non-nil means `display-buffer' should make a new window."
@@ -4596,23 +4914,19 @@ Do this only if these windows are vertically adjacent to each
 other, `even-window-heights' is non-nil, and the selected window
 is higher than WINDOW."
   (when (and even-window-heights
-             (not (eq window (selected-window)))
-             ;; Don't resize minibuffer windows.
-             (not (window-minibuffer-p (selected-window)))
-             (> (window-height (selected-window)) (window-height window))
-             (eq (window-frame window) (window-frame (selected-window)))
-             (let ((sel-edges (window-edges (selected-window)))
-                   (win-edges (window-edges window)))
-               (and (= (nth 0 sel-edges) (nth 0 win-edges))
-                    (= (nth 2 sel-edges) (nth 2 win-edges))
-                    (or (= (nth 1 sel-edges) (nth 3 win-edges))
-                        (= (nth 3 sel-edges) (nth 1 win-edges))))))
-    (let ((window-min-height 1))
-      ;; Don't throw an error if we can't even window heights for
-      ;; whatever reason.
-      (condition-case nil
-          (enlarge-window (/ (- (window-height window) (window-height)) 2))
-        (error nil)))))
+             ;; Even iff WINDOW forms a vertical combination with the
+             ;; selected window, and WINDOW's height exceeds that of the
+             ;; selected window, see also bug#11880.
+             (window-combined-p window)
+             (= (window-child-count (window-parent window)) 2)
+             (eq (window-parent) (window-parent window))
+             (> (window-total-height) (window-total-height window)))
+    ;; Don't throw an error if we can't even window heights for
+    ;; whatever reason.
+    (condition-case nil
+        (enlarge-window
+         (/ (- (window-total-height window) (window-total-height)) 2))
+      (error nil))))
 
 (defun window--display-buffer (buffer window type &optional dedicated)
   "Display BUFFER in WINDOW and make its frame visible.
@@ -4621,9 +4935,9 @@ is passed unaltered to `display-buffer-record-window'. Set
 `window-dedicated-p' to DEDICATED if non-nil.  Return WINDOW if
 BUFFER and WINDOW are live."
   (when (and (buffer-live-p buffer) (window-live-p window))
+    (display-buffer-record-window type window buffer)
     (unless (eq buffer (window-buffer window))
       (set-window-dedicated-p window nil)
-      (display-buffer-record-window type window buffer)
       (set-window-buffer window buffer)
       (when dedicated
         (set-window-dedicated-p window dedicated))
@@ -4797,6 +5111,10 @@ Recognized alist entries include:
                       window that already displays the buffer.
                       See `display-buffer-reuse-window'.
 
+ `pop-up-frame-parameters' -- Value specifies an alist of frame
+                              parameters to give a new frame, if
+                              one is created.
+
 The ACTION argument to `display-buffer' can also have a non-nil
 and non-list value.  This means to display the buffer in a window
 other than the selected one, even if it is already displayed in
@@ -4939,9 +5257,15 @@ This works by calling `pop-up-frame-function'.  If successful,
 return the window used; otherwise return nil.
 
 If ALIST has a non-nil `inhibit-switch-frame' entry, avoid
-raising the new frame."
-  (let ((fun pop-up-frame-function)
-        frame window)
+raising the new frame.
+
+If ALIST has a non-nil `pop-up-frame-parameters' entry, the
+corresponding value is an alist of frame parameters to give the
+new frame."
+  (let* ((params (cdr (assq 'pop-up-frame-parameters alist)))
+         (pop-up-frame-alist (append params pop-up-frame-alist))
+         (fun pop-up-frame-function)
+         frame window)
     (when (and fun
                (setq frame (funcall fun))
                (setq window (frame-selected-window frame)))
@@ -5019,8 +5343,9 @@ that frame."
                   window))
               (get-largest-window 0 not-this-window))))
     (when (window-live-p window)
-      (window--even-window-heights window)
-      (prog1 (window--display-buffer buffer window 'reuse)
+      (prog1
+          (window--display-buffer buffer window 'reuse)
+        (window--even-window-heights window)
         (unless (cdr (assq 'inhibit-switch-frame alist))
           (window--maybe-raise-frame (window-frame window)))))))
 
diff --git a/lisp/woman.el b/lisp/woman.el
index 5933d593aa5..c8cc7ea6766 100644
--- a/lisp/woman.el
+++ b/lisp/woman.el
@@ -2531,7 +2531,7 @@ REQUEST is the invoking directive without the leading dot."
     (cond
      ;; ((looking-at "[no]") (setq c t))     ; accept n(roff) and o(dd page)
      ;; ((looking-at "[te]") (setq c nil))   ; reject t(roff) and e(ven page)
-     ;; Per groff ".if v" is recognised as false (it means -Tversatec).
+     ;; Per groff ".if v" is recognized as false (it means -Tversatec).
      ((looking-at "[ntoev]")
       (setq c (memq (following-char) woman-if-conditions-true)))
      ;; Unrecognized letter so reject: