merge trunk

57 files changed, 1198 insertions, 1361 deletions

diff --git a/admin/ChangeLog b/admin/ChangeLog
index f91d53194ce..fc3370bb380 100644
--- a/admin/ChangeLog
+++ b/admin/ChangeLog
@@ -1,3 +1,7 @@
+2011-11-07  Juanma Barranquero  <lekktu@gmail.com>
+
+        * unidata/makefile.w32-in (clean): Remove bidimirror.h and biditype.h.
+
 2011-10-31  David Engster  <deng@randomsample.de>
 
         * grammars/bovine-grammar.el: Avoid using old-style backquotes.
diff --git a/admin/charsets/mapfiles/Uni2JIS b/admin/charsets/mapfiles/Uni2JIS
index 59e3a1e1dfa..b81d10c6ae2 100644
--- a/admin/charsets/mapfiles/Uni2JIS
+++ b/admin/charsets/mapfiles/Uni2JIS
@@ -514,7 +514,7 @@
 045A    S-0790                  # CYRILLIC SMALL LETTER NJE
 045B    S-0791                  # CYRILLIC SMALL LETTER TSHE (Serbocroatian)
 045C    S-0792                  # CYRILLIC SMALL LETTER KJE
-045E    S-0793                  # CYRILLIC SMALL LETTER SHORT U (Byalorussian)
+045E    S-0793                  # CYRILLIC SMALL LETTER SHORT U (Byelorussian)
 045F    S-0794                  # CYRILLIC SMALL LETTER DZHE
 2010    0-0130  1-0130  2-0130  # HYPHEN
 2014    0-0129  1-0129  2-0129  # EM DASH
diff --git a/admin/unidata/makefile.w32-in b/admin/unidata/makefile.w32-in
index 96a1f5b86fd..0e9b9f0d2bd 100644
--- a/admin/unidata/makefile.w32-in
+++ b/admin/unidata/makefile.w32-in
@@ -52,5 +52,5 @@ charprop-CMD: unidata-gen.elc unidata.txt
 ${DSTDIR}/charprop.el: charprop-$(SHELLTYPE)
 
 clean:
-        - $(DEL) unidata-gen.elc unidata.txt biditype.h bidimirror.h
+        - $(DEL) unidata-gen.elc unidata.txt
 
diff --git a/doc/lispref/ChangeLog b/doc/lispref/ChangeLog
index 1a692c6b36d..2abed9f870c 100644
--- a/doc/lispref/ChangeLog
+++ b/doc/lispref/ChangeLog
@@ -1,3 +1,46 @@
+2011-11-10  Glenn Morris  <rgm@gnu.org>
+
+        * buffers.texi (Read Only Buffers): Expand a bit on why
+        toggle-read-only should only be used interactively.  (Bug#7292)
+
+2011-11-09  Chong Yidong  <cyd@gnu.org>
+
+        * windows.texi (Window Sizes): Document window-pixel-edges,
+        window-inside-pixel-edges, window-absolute-pixel-edges, and
+        window-inside-absolute-pixel-edges.
+        (Resizing Windows): shrink-window-if-larger-than-buffer works on
+        non-full-width windows.
+
+2011-11-09  Martin Rudalics  <rudalics@gmx.at>
+
+        * windows.texi (Resizing Windows): Rewrite documentation of
+        window-resizable.
+
+2011-11-09  Chong Yidong  <cyd@gnu.org>
+
+        * windows.texi (Splitting Windows): Simplify example.
+
+2011-11-08  Chong Yidong  <cyd@gnu.org>
+
+        * windows.texi (Window Sizes): Copyedits.  Document
+        window-text-height.  Remove window-min-height and window-min-width
+        discussion, referring instead to Emacs manual.
+        (Splitting Windows, Resizing Windows): Add xref to Emacs manual.
+        (Resizing Windows): Simplify introduction.  Don't document
+        enlarge-window, shrink-window, enlarge-window-horizontally, and
+        shrink-window-horizontally; they are no longer preferred for
+        calling from Lisp, and are already documented in the Emacs manual.
+
+2011-11-07  Glenn Morris  <rgm@gnu.org>
+
+        * windows.texi (Choosing Window): Fix keybinding typo.
+
+2011-11-07  Martin Rudalics  <rudalics@gmx.at>
+
+        * windows.texi (Resizing Windows, Splitting Windows)
+        (Window Configurations): Use "child window" instead of
+        "subwindow".
+
 2011-11-06  Chong Yidong  <cyd@gnu.org>
 
         * windows.texi (Basic Windows): Clarify various definitions.
@@ -1064,9 +1107,9 @@
         * commands.texi (Misc Events): Add cross-references to where
         POSITION of a mouse event is described in detail.
 
-2010-08-08  Christoph  <cschol2112@googlemail.com>
+2010-08-08  Christoph Scholtes  <cschol2112@googlemail.com>
 
-        * control.texi (Handling Errors) <error-message-string>: Fix arg name.
+        * control.texi (Handling Errors)  <error-message-string>: Fix arg name.
 
 2010-08-08  Juanma Barranquero  <lekktu@gmail.com>
 
diff --git a/doc/lispref/buffers.texi b/doc/lispref/buffers.texi
index 816d0f9faa8..ee2ce2e2001 100644
--- a/doc/lispref/buffers.texi
+++ b/doc/lispref/buffers.texi
@@ -748,10 +748,11 @@ of the list (comparison is done with @code{eq}).
 
 @deffn Command toggle-read-only &optional arg
 This command toggles whether the current buffer is read-only.  It is
-intended for interactive use; do not use it in programs.  At any given
-point in a program, you should know whether you want the read-only flag
-on or off; so you can set @code{buffer-read-only} explicitly to the
-proper value, @code{t} or @code{nil}.
+intended for interactive use; do not use it in programs (it may have
+side-effects, such as enabling View mode, and does not affect
+read-only text properties).  To change the read-only state of a buffer in
+a program, explicitly set @code{buffer-read-only} to the proper value.
+To temporarily ignore a read-only state, bind @code{inhibit-read-only}.
 
 If @var{arg} is non-@code{nil}, it should be a raw prefix argument.
 @code{toggle-read-only} sets @code{buffer-read-only} to @code{t} if
diff --git a/doc/lispref/windows.texi b/doc/lispref/windows.texi
index 8b466e02214..cf5cfedf5af 100644
--- a/doc/lispref/windows.texi
+++ b/doc/lispref/windows.texi
@@ -274,7 +274,7 @@ the leftmost child window for a horizontal combination.  If
 @defun window-combined-p &optional window horizontal
 This function returns a non-@code{nil} value if and only if
 @var{window} is part of a vertical combination.  If @var{window} is
-omitted or nil, it defaults to the selected one.
+omitted or @code{nil}, it defaults to the selected one.
 
 If the optional argument @var{horizontal} is non-@code{nil}, this
 means to return non-@code{nil} if and only if @var{window} is part of
@@ -340,13 +340,12 @@ internal window).  The @var{edges} element is a list @code{(@var{left}
 @cindex window size
 @cindex size of window
 
-Emacs windows are rectangular.  The structure of a live window can be
-roughly sketched as follows:
+  The following schematic shows the structure of a live window:
 
 @smallexample
 @group
-         _________________________________________ 
-      ^ |______________ Header Line_______________| 
+         _________________________________________
+      ^ |______________ Header Line_______________|
       | |LS|LF|LM|                       |RM|RF|RS| ^
       | |  |  |  |                       |  |  |  | |
  Window |  |  |  |       Text Area       |  |  |  | Window
@@ -362,297 +361,218 @@ roughly sketched as follows:
 @end smallexample
 
 @cindex window body
+@cindex text area of a window
 @cindex body of a window
-The text area constitutes the body of the window.  In its most simple
-form, a window consists of its body alone.  LS and RS stand for the left
-and right scroll bar (@pxref{Scroll Bars}) respectively.  Only one of
-them can be present at any time.  LF and RF denote the left and right
-fringe, see @ref{Fringes}.  LM and RM, finally, stand for the left and
-right display margin, see @ref{Display Margins}.  The header line, if
-present, is located above theses areas, the mode line below, see
-@ref{Mode Line Format}.
+  At the center of the window is the @dfn{text area}, or @dfn{body},
+where the buffer text is displayed.  On each side of the text area is
+a series of vertical areas; from innermost to outermost, these are the
+left and right margins, denoted by LM and RM in the schematic
+(@pxref{Display Margins}); the left and right fringes, denoted by LF
+and RF (@pxref{Fringes}); and the left or right scroll bar, only one of
+which is present at any time, denoted by LS and RS (@pxref{Scroll
+Bars}).  At the top of the window is an optional header line
+(@pxref{Header Lines}), and at the bottom of the window is the mode
+line (@pxref{Mode Line Format}).
+
+  Emacs provides several functions for finding the height and width of
+a window.  Except where noted, these heights and widths are reported
+as integer numbers of lines and columns respectively.  On a graphical
+display, each ``line'' and ``column'' actually corresponds to the
+height and width of a ``default'' character specified by the frame's
+default font.  Thus, if a window is displaying text with a different
+font or size, the reported height and width for that window may differ
+from the actual number of text lines or columns displayed within it.
 
 @cindex window height
-@cindex total window height
 @cindex height of a window
 @cindex total height of a window
-The @dfn{total height of a window} is specified as the total number of
-lines occupied by the window.  Any mode or header line is included in a
-window's total height.  For an internal window, the total height is
-calculated recursively from the total heights of its child windows.
-
 @cindex window width
-@cindex total window width
 @cindex width of a window
 @cindex total width of a window
-The @dfn{total width of a window} denotes the total number of columns of
-the window.  Any scroll bar and the column of @samp{|} characters that
-separate the window from its right sibling are included in a window's
-total width.  On a window-system, fringes and display margins are
-included in a window's total width too.  For an internal window, the
-total width is calculated recursively from the total widths of its child
-windows.
-
-@cindex total size of a window
-@cindex total window size
-The following function is the standard interface for getting the total
-size of any window:
-
-@defun window-total-size &optional window &optional horizontal
-This function returns the total number of lines of @var{window}.  The
-argument @var{window} can denote any window and defaults to the selected
-one.  If @var{window} is live, the return value includes any header or
-mode lines of @var{window}.  If @var{window} is internal, the return
-value is the sum of the total heights of @var{window}'s child windows
-provided these are vertically combined and the height of @var{window}'s
-first child if they are horizontally combined.
-
-   If the optional argument @var{horizontal} is non-@code{nil}, this
-function returns the total number of columns of @var{window}.  If
-@var{window} is live, the return value includes any vertical divider
-column or scroll bars of @var{window}.  On a window-system, the return
-value includes the space occupied by any margins and fringes of
-@var{window} too.  If @var{window} is internal, the return value is the
-sum of the total widths of @var{window}'s child windows provided these
-are horizontally combined and the width of @var{window}'s first child
-otherwise.
-@end defun
-
-Alternatively, the following two functions can be used to retrieve
-either the total height or the total width of a window:
+  The @dfn{total height} of a window is the distance between the top
+and bottom of the window, including the header line (if one exists)
+and the mode line.  The @dfn{total width} of a window is the distance
+between the left and right edges of the mode line.  Note that the
+height of a frame is not the same as the height of its windows, since
+a frame may also contain an echo area, menu bar, and tool bar
+(@pxref{Size and Position}).
 
 @defun window-total-height &optional window
-This function returns the total number of lines of @var{window}.
-@var{window} can be any window and defaults to the selected one.  The
-return value includes @var{window}'s mode line and header line, if any.
-If @var{window} is internal the return value is the sum of heights of
-@var{window}'s child windows for a vertical combination and the height
-of @var{window}'s first child otherwise.
+This function returns the total height, in lines, of the window
+@var{window}.  If @var{window} is omitted or @code{nil}, it defaults
+to the selected window.  If @var{window} is an internal window, the
+return value is the total height occupied by its descendant windows.
 @end defun
 
 @defun window-total-width &optional window
-This function returns the total number of columns of @var{window}.
-@var{window} can be any window and defaults to the selected one.  The
-return value includes any vertical dividers or scrollbars of
-@var{window}.  On a window-system the return value also includes the
-space occupied by any margins and fringes of @var{window}.  If
-@var{window} is internal, the return value is the sum of the widths of
-@var{window}'s child windows for a horizontal combination and the width
-of @var{window}'s first child otherwise.
-@end defun
-
-The total height of any window is usually less than the height of the
-window's frame, because the latter may also include the minibuffer
-window.  Depending on the toolkit in use, the frame height can also
-include the menu bar and the tool bar (@pxref{Size and Position}).
-Therefore, in general it is not straightforward to compare window and
-frame heights.  The following function is useful to determine whether
-there are no other windows above or below a specified window.
+This function returns the total width, in columns, of the window
+@var{window}.  If @var{window} is omitted or @code{nil}, it defaults
+to the selected window.  If @var{window} is internal, the return value
+is the total width occupied by its descendant windows.
+@end defun
 
-@cindex full-height window
-@defun window-full-height-p &optional window
-This function returns non-@code{nil} if there is no other window above
-or below @var{window} on the containing frame.  More precisely, this
-function returns @code{t} if and only if the total height of
-@var{window} equals the total height of the root window (@pxref{Windows
-and Frames}) of @var{window}'s frame.  The @var{window} argument may
-denote any window and defaults to the selected one.
+@defun window-total-size &optional window horizontal
+This function returns either the total height or width of the window
+@var{window}.  If @var{horizontal} is omitted or @code{nil}, this is
+equivalent to calling @code{window-total-height} for @var{window};
+otherwise it is equivalent to calling @code{window-total-width} for
+@var{window}.
 @end defun
 
 @cindex full-width window
-The following function can be used to determine whether there are no
-other windows on the left or right of a specified window.
+@cindex full-height window
+  The following functions can be used to determine whether a given
+window has any adjacent windows.
+
+@defun window-full-height-p &optional window
+This function returns non-@code{nil} if @var{window} has no other
+window above or below it in its frame, i.e. its total height equals
+the total height of the root window on that frame.  If @var{window} is
+omitted or @code{nil}, it defaults to the selected window.
+@end defun
 
 @defun window-full-width-p &optional window
-This function returns non-@code{nil} if there are no other windows on
-the left or right of @var{window}; @code{nil} otherwise.  More
-precisely, this function returns @code{t} if and only if the total width
-of @var{window} equals the total width of the root window
-(@pxref{Windows and Frames}) of @var{window}'s frame.  The @var{window}
-argument may denote any window and defaults to the selected one.
+This function returns non-@code{nil} if @var{window} has no other
+window to the left or right in its frame, i.e. its total width equals
+that of the root window on that frame.  If @var{window} is omitted or
+@code{nil}, it defaults to the selected window.
 @end defun
 
-@cindex top line of window
-@cindex left column of window
-  The windows of a frame are unambiguously characterized by the
-combination of their top line and left column within that frame.
+@cindex window position
+  The following functions can be used to determine the position of a
+window relative to the window area of its frame:
 
 @defun window-top-line &optional window
-This function returns the top line of @var{window}.  The argument
-@var{window} can denote any window and defaults to the selected one.
+This function returns the distance, in lines, between the top of
+@var{window} and the top of the frame's window area.  For instance,
+the return value is 0 if there is no window above @var{window}.  If
+@var{window} is omitted or @code{nil}, it defaults to the selected
+window.
 @end defun
 
 @defun window-left-column &optional window
-This function returns the left column of @var{window}.  The argument
-@var{window} can denote any window and defaults to the selected one.
+This function returns the distance, in columns, between the left edge
+of @var{window} and the left edge of the frame's window area.  For
+instance, the return value is 0 if there is no window to the left of
+@var{window}.  If @var{window} is omitted or @code{nil}, it defaults
+to the selected window.
 @end defun
 
-For a frame displaying one window only, that window's top line and left
-column are both zero.  When a frame displays a window @var{WB} below a
-window @var{WA}, the top line of @var{WB} can be calculated by adding
-the total height of @var{WA} to the top line of @var{WA}.  When a frame
-displays a window @var{WR} on the right of a window @var{WL}, the left
-column of @var{WR} can be calculated by adding the total width of
-@var{WL} to the left column of @var{WL}.
-
 @cindex window body height
 @cindex body height of a window
-The @dfn{body height of a window} is specified as the total number of
-lines occupied by the window's text area.  Mode or header lines are not
-included in a window's body height.
-
 @cindex window body width
 @cindex body width of a window
-The @dfn{body width of a window} denotes the total number of columns
-occupied by the window's text area.  Scroll bars or columns of @samp{|}
-characters that separate side-by-side windows are not included in a
-window's body width.
-
 @cindex body size of a window
 @cindex window body size
-@cindex canonical units of window/frame size
-The following functions retrieve height and width of the body of a
-live window.  Note that the values these functions return are measured
-in @dfn{canonical units}, i.e.@: for the default frame's face.  If the
-window shows some characters with non-default face, e.g., if the font
-of some characters is larger or smaller than the default font, the
-values returned by these functions will not match the actual number of
-lines or characters per line shown in the window.  To get the actual
-number of columns and lines, move to the last character in the line
-(e.g., with @code{end-of-visual-line}) or to the last line of the
-window (e.g., with @code{window-end}), and use @code{posn-at-point} to
-find the line or column there.
-
-@defun window-body-size &optional window horizontal
-This function returns the number of lines of @var{window}'s text area.
-@var{window} must be a live window and defaults to the selected one.
-The return value does not count any mode or header line of @var{window}.
-
-Optional argument @var{horizontal} non-@code{nil} means to return the
-number of columns of @var{window}'s text area.  In this case the return
-value does not include any vertical divider or scroll bar owned by
-@var{window}.  On a window-system the return value does not include the
-number of columns used for @var{window}'s fringes or display margins
-either.
-@end defun
+  The @dfn{body height} of a window is the height of its text area,
+which does not include the mode or header line.  Similarly, the
+@dfn{body width} is the width of the text area, which does not include
+the scroll bar, fringes, or margins.
 
 @defun window-body-height &optional window
-This function returns the number of lines of @var{window}'s body.
-@var{window} must be a live window and defaults to the selected one.
+This function returns the body height, in lines, of the window
+@var{window}.  If @var{window} is omitted or @code{nil}, it defaults
+to the selected window; otherwise it must be a live window.
 
-The return value does not include @var{window}'s mode line and header
-line, if any.  If a line at the bottom of the window is only partially
-visible, that line is included in the return value.  If you do not
-want to include a partially visible bottom line in the return value,
-use @code{window-text-height} instead.
+If there is a partially-visible line at the bottom of the text area,
+that counts as a whole line; to exclude such a partially-visible line,
+use @code{window-text-height}, below.
 @end defun
 
 @defun window-body-width &optional window
-This function returns the number of columns of @var{window}'s body.
-@var{window} must be a live window and defaults to the selected one.
-
-The return value does not include any vertical dividers or scroll bars
-owned by @var{window}.  On a window-system the return value does not
-include the number of columns used for @var{window}'s fringes or
-display margins either.
+This function returns the body width, in columns, of the window
+@var{window}.  If @var{window} is omitted or @code{nil}, it defaults
+to the selected window; otherwise it must be a live window.
 @end defun
 
-The following functions have been used in earlier versions of Emacs.
-They are still supported but due to the confusing nomenclature they
-should not be used any more in future code.
-
-@defun window-height &optional window
-This function is an alias for `window-total-height', see above.
+@defun window-body-size &optional window horizontal
+This function returns the body height or body width of @var{window}.
+If @var{horizontal} is omitted or @code{nil}, it is equivalent to
+calling @code{window-body-height} for @var{window}; otherwise it is
+equivalent to calling @code{window-body-width}.
 @end defun
 
-@defun window-width &optional window
-This function is an alias for `window-body-width', see above.
+@defun window-text-height &optional window
+This function is like @code{window-body-height}, except that any
+partially-visible line at the bottom of the text area is not counted.
 @end defun
 
-@cindex minimum window size
-  The following two options constrain the sizes of windows to a minimum
-height and width.  Their values are honored when windows are split
-(@pxref{Splitting Windows}) or resized (@pxref{Resizing Windows}).  Any
-request to make a window smaller than specified here will usually result
-in an error.
-
-@defopt window-min-height
-The value of this variable specifies how short a window may be.  The
-value is measured in line units and has to account for any header or
-mode line.  The default value for this option is @code{4}.  Values less
-than @code{1} are ignored.
-@end defopt
-
-@defopt window-min-width
-The value of this variable specifies how narrow a window may be.  The
-value is measured in characters and includes any margins, fringes,
-scroll bar and vertical divider column.  The default value for this
-option is @code{10}.  A value less than @code{2} is ignored.
-@end defopt
-
-Applications should not rebind these variables.  To shrink a specific
-window to a height or width less than the one specified here, they
-should rather invoke @code{window-resize} (@pxref{Resizing Windows})
-with a non-@code{nil} @var{ignore} argument.  The function
-@code{split-window} (@pxref{Splitting Windows}) can make a window
-smaller than specified here by calling it with a non-@code{nil}
-@var{size} argument.  Interactively, the values specified here cannot be
-overridden.
-
-   Earlier versions of Emacs could delete a window when its size dropped
-below @code{window-min-height} or @code{window-min-width}.  As a rule,
-the current version of Emacs does no more delete windows by side-effect.
-The only exception to this rule are requests to resize a frame which may
-implicitly delete windows when they do not fit on the frame any more,
-see @ref{Size and Position}.
-
-   The size of a window can be fixed which means that it cannot be split
-(@pxref{Splitting Windows}) or resized (@pxref{Resizing Windows}).
+  For compatibility with previous versions of Emacs,
+@code{window-height} is an alias for @code{window-body-height}, and
+@code{window-width} is an alias for @code{window-body-width}.  These
+aliases are considered obsolete and will be removed in the future.
 
 @cindex fixed-size window
+  Commands that change the size of windows (@pxref{Resizing Windows}),
+or split them (@pxref{Splitting Windows}), obey the variables
+@code{window-min-height} and @code{window-min-width}, which specify
+the smallest allowable window height and width.  @xref{Change
+Window,,Deleting and Rearranging Windows, emacs, The GNU Emacs
+Manual}.  They also obey the variable @code{window-size-fixed}, with
+which a window can be @dfn{fixed} in size:
+
 @defvar window-size-fixed
-If this variable is non-@code{nil}, in a given buffer, then the size of
-any window displaying that buffer remains fixed unless you either
-explicitly change it or Emacs has no other choice.
+If this buffer-local variable is non-@code{nil}, the size of any
+window displaying the buffer cannot normally be changed.  Deleting a
+window or changing the frame's size may still change its size, if
+there is no choice.
 
 If the value is @code{height}, then only the window's height is fixed;
 if the value is @code{width}, then only the window's width is fixed.
 Any other non-@code{nil} value fixes both the width and the height.
-
-This variable automatically becomes buffer-local when set.
 @end defvar
 
-Commands supposed to explicitly change the size of windows such as
-@code{enlarge-window} (@pxref{Resizing Windows}) get an error if they
-had to change a window size which is fixed.  Other functions like
-@code{window-resize} (@pxref{Resizing Windows}) have an optional
-@var{ignore} argument which allows to change the size of fixed-size
-windows.
+@defun window-size-fixed-p &optional window horizontal
+This function returns a non-@code{nil} value if @var{window}'s height
+is fixed.  If @var{window} is omitted or @code{nil}, it defaults to
+the selected window.  If the optional argument @var{horizontal} is
+non-@code{nil}, the return value is non-@code{nil} if @var{window}'s
+width is fixed.
+
+A @code{nil} return value does not necessarily mean that @var{window}
+can be resized in the desired direction.  To determine that, use the
+function @code{window-resizable}.  @xref{Resizing Windows}.
+@end defun
 
-   Deleting a window or changing a frame's size may change the size of a
-fixed-size window, if there is no other alternative.
+  The following functions can be used to find a window's size and
+position in pixels.  Though mostly useful on graphical displays, they
+can also be called on text-only terminals, where the screen area of
+each text character is taken to be ``one pixel''.
 
-   The height of a vertical combination of windows cannot be changed
-when the height of all these windows is fixed.  Its width cannot be
-changed if the width of at least one of these windows is fixed.
-Similarly, the width of a horizontal combination of windows cannot be
-changed when the width of all these windows is fixed.  Its height cannot
-be changed if the height of at least one of these windows is fixed.
+@defun window-pixel-edges &optional window
+This function return a list of pixel coordinates for the edges of
+@var{window}.  If @var{window} is omitted or @code{nil}, it defaults
+to the selected window.
 
-   The next function allows to check whether the size of an arbitrary           
-window is fixed.
+The return value has the form @code{(@var{left} @var{top} @var{right}
+@var{bottom})}.  The list elements are, respectively, the X coordinate
+of the left window edge, the Y coordinate of the top edge, one more
+than the X coordinate of the right edge, and one more than the Y
+coordinate of the bottom edge.  The origin coordinate @samp{(0,0)} is
+taken to be the top left corner of the frame's window area.
 
-@defun window-size-fixed-p &optional window horizontal
-This function returns non-@code{nil} if @var{window}'s height is fixed.
-The argument @var{window} can be an arbitrary window and defaults to the
-selected one.  Optional argument @var{horizontal} non-@code{nil} means
-return non-@code{nil} if @var{window}'s width is fixed.
+These edge values include the space used by the window's scroll bar,
+margins, fringes, header line, and mode line, if any.
+@end defun
 
-If this function returns @code{nil}, this does not necessarily mean that
-@var{window} can be resized in the desired direction.  The function
-@code{window-resizable} (@pxref{Resizing Windows}) can tell that.
+@defun window-inside-pixel-edges &optional window
+This function is like @code{window-pixel-edges}, except that it
+returns the edge coordinates for the window's text area, rather than
+the edge coordinates for the window itself.  @var{window} must specify
+a live window.
 @end defun
 
+@defun window-absolute-pixel-edges &optional window
+This function is like @code{window-pixel-edges}, except that it
+returns the edge coordinates relative to the top left corner of the
+display screen.
+@end defun
+
+@defun window-inside-absolute-pixel-edges &optional window
+This function is like @code{window-inside-pixel-edges}, except that it
+returns the edge coordinates relative to the top left corner of the
+display screen.  @var{window} must specify a live window.
+@end defun
 
 @node Resizing Windows
 @section Resizing Windows
@@ -661,231 +581,147 @@ If this function returns @code{nil}, this does not necessarily mean that
 @cindex changing window size
 @cindex window size, changing
 
-Emacs does not permit overlapping windows or gaps between windows, so
-changing the size of a window always affects at least one other window.
-When a frame contains just one window, that window can be resized only
-by resizing the window's frame.  The functions described below are
-therefore meaningful only in the context of a frame containing at least
-two windows.  The size of the corresponding frame never changes when
-invoking a function described in this section.
-
-   The routines changing window sizes always operate in one dimension at
-a time.  This means that windows can be resized only either vertically
-or horizontally.  If a window shall be resized in both dimensions, it
-must be resized in one dimension first and in the other dimension
-afterwards.  If the second resize operation fails, the frame might end
-up in an unsatisfactory state.  To avoid such states, it might be useful
-to save the current window configuration (@pxref{Window Configurations})
-before attempting the first resize operation and restore the saved
-configuration in case the second resize operation fails.
-
-   Functions that resize windows are supposed to obey restrictions
-imposed by window minimum sizes and fixed-size windows, see @ref{Window
-Sizes}.  In order to determine whether resizing a specific window is
-possible in the first place, the following function can be used:
-
-@defun window-resizable window delta &optional horizontal ignore side noup nodown
+  This section describes functions for resizing a window without
+changing the size of its frame.  Because live windows do not overlap,
+these functions are meaningful only on frames that contain two or more
+windows: resizing a window also changes the size of a neighboring
+window.  If there is just one window on a frame, its size cannot be
+changed except by resizing the frame (@pxref{Size and Position}).
+
+  Except where noted, these functions also accept internal windows as
+arguments.  Resizing an internal window causes its child windows to be
+resized to fit the same space.
+
+@defun window-resizable window delta &optional horizontal ignore
 This function returns @var{delta} if the size of @var{window} can be
-changed vertically by @var{delta} lines.  Optional argument
-@var{horizontal} non-@code{nil} means to return @var{delta} if
-@var{window} can be resized horizontally by @var{delta} columns.  A
-return value of zero means that @var{window} is not resizable.
-
-If @var{delta} is a positive number, this means that @var{window} shall
-be enlarged by @var{delta} lines or columns.  If @var{window} cannot be
-enlarged by @var{delta} lines or columns, this function returns the
-maximum value in the range from 0 to @var{delta} by which @var{window}
-can be enlarged.
-
-If @var{delta} is a negative number, this means that @var{window} shall
-be shrunk by -@var{delta} lines or columns.  If @var{window} cannot be
-shrunk by -@var{delta} lines or columns, this function returns the
-minimum value in the range from @var{delta} to 0 that can be used for
-shrinking @var{window}.
-
-Optional argument @var{ignore} non-@code{nil} means ignore any
-restrictions imposed by the variables @code{window-min-height} or
-@code{window-min-width} and @code{window-size-fixed}.  In this case the
-minimum height of a window is specified as the minimum number of lines
-that allow viewing any header or mode line and at least one line of the
-text area of window.  The minimum width of a window includes any
-fringes, margins and the scroll bar as well as two text columns.
-
-If @var{ignore} denotes a window, this means to ignore restrictions for
-that window only.  If @var{ignore} equals the constant @code{safe}, this
-means a live window may get as small as one line or two columns.
-
-Optional argument @var{noup} non-@code{nil} means don't go up in the
-window tree but try to steal or distribute the space needed for the
-resize operation among the other windows within @var{window}'s
-combination.  Optional argument @var{nodown} non-@code{nil} means don't
-check whether @var{window} itself and its subwindows can be resized.
-@end defun
-
-The function @code{window-resizable} does not change any window sizes.
-The following function does:
+changed vertically by @var{delta} lines.  If the optional argument
+@var{horizontal} is non-@code{nil}, it instead returns @var{delta} if
+@var{window} can be resized horizontally by @var{delta} columns.  It
+does not actually change the window size.
+
+If @var{window} is @code{nil}, it defaults to the selected window.
+
+A positive value of @var{delta} means to check whether the window can be
+enlarged by that number of lines or columns; a negative value of
+@var{delta} means to check whether the window can be shrunk by that many
+lines or columns.  If @var{delta} is non-zero, a return value of 0 means
+that the window cannot be resized.
+
+Normally, the variables @code{window-min-height} and
+@code{window-min-width} specify the smallest allowable window size.
+@xref{Change Window,, Deleting and Rearranging Windows, emacs, The GNU
+Emacs Manual}.  However, if the optional argument @var{ignore} is
+non-@code{nil}, this function ignores @code{window-min-height} and
+@code{window-min-width}, as well as @code{window-size-fixed}.
+Instead, it considers the minimum-height window to be one consisting
+of a header (if any), a mode line, plus a text area one line tall; and
+a minimum-width window as one consisting of fringes, margins, and
+scroll bar (if any), plus a text area two columns wide.
+@end defun
 
 @defun window-resize window delta &optional horizontal ignore
-This function resizes @var{window} vertically by @var{delta} lines.  The
-argument @var{window} can denote an arbitrary window and defaults to the
-selected one.  An attempt to resize the root window of a frame will
-raise an error.
-
-Second argument @var{delta} a positive number means @var{window} shall
-be enlarged by @var{delta} lines.  If @var{delta} is negative, that
-means @var{window} shall be shrunk by -@var{delta} lines.
-
-Optional argument @var{horizontal} non-@code{nil} means to resize
-@var{window} horizontally by @var{delta} columns.  In this case a
-positive @var{delta} means enlarge @var{window} by @var{delta} columns.
-A negative @var{delta} means @var{window} shall be shrunk by
--@var{delta} columns.
-
-Optional argument @var{ignore} has the same meaning as for the function
-@code{window-resizable} above.
-
-This function can simultaneously move two edges of WINDOW.  Exactly
-which edges of @var{window} are moved and which other windows are
-resized along with @var{window} is determined by the splits and nest
-status of the involved windows (@pxref{Splitting Windows}).  If only the
-low (right) edge of @var{window} shall be moved, the function
-@code{adjust-window-trailing-edge} described below should be used.
-@end defun
-
-The next four commands are simple interfaces to @code{window-resize}.
-They always operate on the selected window, never delete any window, and
-always raise an error when resizing would violate a restriction imposed
-by @code{window-min-height}, @code{window-min-width}, or
-@code{window-size-fixed}.
-
-@deffn Command enlarge-window delta &optional horizontal
-This function makes the selected window @var{delta} lines taller.
-Interactively, if no argument is given, it makes the selected window one
-line taller.  If optional argument @var{horizontal} is non-@code{nil},
-it makes the selected window wider by @var{delta} columns.  If
-@var{delta} is negative, it shrinks the selected window by -@var{delta}
-lines or columns.  The return value is @code{nil}.
-@end deffn
+This function resizes @var{window} by @var{delta} increments.  If
+@var{horizontal} is @code{nil}, it changes the height by @var{delta}
+lines; otherwise, it changes the width by @var{delta} columns.  A
+positive @var{delta} means to enlarge the window, and a negative
+@var{delta} means to shrink it.
 
-@deffn Command enlarge-window-horizontally delta
-This function makes the selected window @var{delta} columns wider.
-Interactively, if no argument is given, it makes the selected window one
-column wider.
-@end deffn
+If @var{window} is @code{nil}, it defaults to the selected window.  If
+the window cannot be resized as demanded, an error is signaled.
 
-@deffn Command shrink-window delta &optional horizontal
-This function makes the selected window @var{delta} lines smaller.
-Interactively, if no argument is given, it makes the selected window one
-line smaller.  If optional argument @var{horizontal} is non-@code{nil},
-it makes the selected window narrower by @var{delta} columns.  If
-@var{delta} is negative, it enlarges the selected window by -@var{delta}
-lines or columns.  The return value is @code{nil}.
-@end deffn
+The optional argument @var{ignore} has the same meaning as for the
+function @code{window-resizable} above.
 
-@deffn Command shrink-window-horizontally delta
-This function makes the selected window @var{delta} columns narrower.
-Interactively, if no argument is given, it makes the selected window one
-column narrower.
-@end deffn
+The choice of which window edge this function alters depends on the
+splitting and nesting status of the involved windows; in some cases,
+it may alter both edges.  @xref{Splitting Windows}.  To resize by
+moving only the bottom or right edge of a window, use the function
+@code{adjust-window-trailing-edge}, below.
+@end defun
 
-The following function is useful for moving the line dividing two
-windows.
+@c The commands enlarge-window, enlarge-window-horizontally,
+@c shrink-window, and shrink-window-horizontally are documented in the
+@c Emacs manual.  They are not preferred for calling from Lisp.
 
 @defun adjust-window-trailing-edge window delta &optional horizontal
 This function moves @var{window}'s bottom edge by @var{delta} lines.
-Optional argument @var{horizontal} non-@code{nil} means to move
-@var{window}'s right edge by @var{delta} columns.  The argument
-@var{window} defaults to the selected window.
+If optional argument @var{horizontal} is non-@code{nil}, it instead
+moves the right edge by @var{delta} columns.  If @var{window} is
+@code{nil}, it defaults to the selected window.
 
-If @var{delta} is greater zero, this moves the edge downwards or to the
-right.  If @var{delta} is less than zero, this moves the edge upwards or
-to the left. If the edge can't be moved by @var{delta} lines or columns,
-it is moved as far as possible in the desired direction but no error is
-signalled.
+A positive @var{delta} moves the edge downwards or to the right; a
+negative @var{delta} moves it upwards or to the left.  If the edge
+cannot be moved as far as specified by @var{delta}, this function
+moves it as far as possible but does not signal a error.
 
 This function tries to resize windows adjacent to the edge that is
-moved.  Only if this is insufficient, it will also resize windows not
-adjacent to that edge.  As a consequence, if you move an edge in one
-direction and back in the other direction by the same amount, the
-resulting window configuration will not be necessarily identical to the
-one before the first move.  So if your intend to just resize
-@var{window}, you should not use this function but call
-@code{window-resize} (see above) instead.
+moved.  If this is not possible for some reason (e.g. if that adjacent
+window is fixed-size), it may resize other windows.
 @end defun
 
+  The following commands resize windows in more specific ways.  When
+called interactively, they act on the selected window.
+
 @deffn Command fit-window-to-buffer &optional window max-height min-height override
-This command makes @var{window} the right height to display its
-contents exactly.  The default for @var{window} is the selected window.
-
-The optional argument @var{max-height} specifies the maximum total
-height the window is allowed to be; @code{nil} means use the maximum
-permissible height of a window on @var{window}'s frame.  The optional
-argument @var{min-height} specifies the minimum toatl height for the
-window; @code{nil} means use @code{window-min-height}.  All these height
-values include the mode line and/or header line.
-
-If the optional argument @var{override} is non-@code{nil}, this means to
-ignore any restrictions imposed by @code{window-min-height} and
-@code{window-min-width} on the size of @var{window}.
-
-This function returns non-@code{nil} if it orderly resized @var{window},
-and @code{nil} otherwise.
+This command adjusts the height of @var{window} to fit the text in it.
+It returns non-@code{nil} if it was able to resize @var{window}, and
+@code{nil} otherwise.  If @var{window} is omitted or @code{nil}, it
+defaults to the selected window.  Otherwise, it should be a live
+window.
+
+The optional argument @var{max-height}, if non-@code{nil}, specifies
+the maximum total height that this function can give @var{window}.
+The optional argument @var{min-height}, if no-@code{nil}, specifies
+the minimum total height that it can give, which overrides the
+variable @code{window-min-height}.
+
+If the optional argument @var{override} is non-@code{nil}, this
+function ignores any size restrictions imposed by
+@code{window-min-height} and @code{window-min-width}.
 @end deffn
 
 @deffn Command shrink-window-if-larger-than-buffer &optional window
-This command shrinks @var{window} vertically to be as small as possible
-while still showing the full contents of its buffer---but not less than
-@code{window-min-height} lines.  The argument @var{window} must denote
-a live window and defaults to the selected one.
-
-However, this command does nothing if the window is already too small to
-display the whole text of the buffer, or if part of the contents are
-currently scrolled off screen, or if the window is not the full width of
-its frame, or if the window is the only window in its frame.
-
-This command returns non-@code{nil} if it actually shrank the window
-and @code{nil} otherwise.
+This command attempts to reduce @var{window}'s height as much as
+possible while still showing its full buffer, but no less than
+@code{window-min-height} lines.  The return value is non-@code{nil} if
+the window was resized, and @code{nil} otherwise.  If @var{window} is
+omitted or @code{nil}, it defaults to the selected window.  Otherwise,
+it should be a live window.
+
+This command does nothing if the window is already too short to
+display all of its buffer, or if any of the buffer is scrolled
+off-screen, or if the window is the only live window in its frame.
 @end deffn
 
 @cindex balancing window sizes
-Emacs provides two functions to balance windows, that is, to even out
-the sizes of all windows on the same frame.  The minibuffer window and
-fixed-size windows are not resized by these functions.
-
 @deffn Command balance-windows &optional window-or-frame
 This function balances windows in a way that gives more space to
 full-width and/or full-height windows.  If @var{window-or-frame}
 specifies a frame, it balances all windows on that frame.  If
-@var{window-or-frame} specifies a window, it balances that window and
-its siblings (@pxref{Windows and Frames}) only.
+@var{window-or-frame} specifies a window, it balances only that window
+and its siblings (@pxref{Windows and Frames}).
 @end deffn
 
 @deffn Command balance-windows-area
 This function attempts to give all windows on the selected frame
-approximately the same share of the screen area.  This means that
-full-width or full-height windows are not given more space than other
-windows.
+approximately the same share of the screen area.  Full-width or
+full-height windows are not given more space than other windows.
 @end deffn
 
 @cindex maximizing windows
-The following function can be used to give a window the maximum possible
-size without deleting other ones.
-
 @deffn Command maximize-window &optional window
-This function maximizes @var{window}.  More precisely, this makes
-@var{window} as large as possible without resizing its frame or deleting
-other windows.  @var{window} can be any window and defaults to the
-selected one.
+This function attempts to make @var{window} as large as possible, in
+both dimensions, without resizing its frame or deleting other windows.
+If @var{window} is omitted or @code{nil}, it defaults to the selected
+window.
 @end deffn
 
 @cindex minimizing windows
-To make a window as small as possible without deleting it the
-following function can be used.
-
 @deffn Command minimize-window &optional window
-This function minimizes @var{window}.  More precisely, this makes
-@var{window} as small as possible without deleting it or resizing its
-frame.  @var{window} can be any window and defaults to the selected one.
+This function attempts to make @var{window} as small as possible, in
+both dimensions, without deleting it or resizing its frame.  If
+@var{window} is omitted or @code{nil}, it defaults to the selected
+window.
 @end deffn
 
 
@@ -894,335 +730,130 @@ frame.  @var{window} can be any window and defaults to the selected one.
 @cindex splitting windows
 @cindex window splitting
 
-The functions described below are the primitives needed for creating a
-new window.  They do not accept a buffer as an argument.  Rather, they
-``split'' an existing window into two halves, both displaying the buffer
-previously visible in the window that was split.
+This section describes functions for creating a new window by
+@dfn{splitting} an existing one.
 
 @deffn Command split-window &optional window size side
-This function creates a new window adjacent to @var{window}.  It returns
-the new window which is always a live window.  The argument @var{window}
-can denote any window and defaults to the selected one.  This function
-does not change the selected window.
-
-Optional second argument @var{size} a positive number means make
-@var{window} @var{size} lines (or columns) tall.  If @var{size} is
-negative, make the new window @minus{}@var{size} lines (or columns)
-tall.  If @var{size} is omitted or @code{nil}, then @var{window} is
-divided evenly into two parts.  (If there is an odd line, it is
-allocated to the new window.)
-
-If splitting would result in making a window smaller than
-@code{window-min-height} or @code{window-min-width} (@pxref{Window
-Sizes}), this function usually signals an error.  However, if @var{size}
-is non-@code{nil} and valid, a new window of the requested size is
-created.  (A size value would be invalid if it assigned less than one
-line or less than two columns to the new window.)
-
-Optional third argument @var{side} @code{nil} (or @code{below})
-specifies that the new window shall be located below @var{window}.  The
-value @code{above} means the new window will be located above
-@var{window}.  In both cases @var{size} specifies the new number of
-lines for @var{window} (or the new window if @var{size} is negative)
-including space reserved for the mode and/or header line.
-
-If @var{side} is @code{t} or @code{right} the new window will be
-positioned on the right side of @var{window}.  The value @code{left}
-means the new window will be located on the left side of @var{window}.
-In both cases @var{size} specifies the new number of columns for
-@var{window} (or the new window provided @var{size} is negative)
-including space reserved for margins, fringes and the scroll bar or a
-divider column.
-
-Any other non-@code{nil} value for @var{side} is currently handled like
-@code{t} (or @code{right}).  Since this might change in the future,
-application programs should refrain from using other values.
-
-If @var{window} is live, properties of the new window like margins and
-scroll bars are inherited from @var{window}.  If @var{window} is an
-internal window, these properties, as well as the buffer shown in the
-new window, are inherited from the window selected on @var{window}'s
-frame.
-
-If @code{ignore-window-parameters} is non-@code{nil}, this function
-ignores window parameters (@pxref{Window Parameters}).  Otherwise, if
-the @code{split-window} parameter of @var{window} is @code{t}, it splits
-the window disregarding any other window parameters.  If the
-@code{split-window} parameter specifies a function, that function is
-called with the arguments @var{window}, @var{size}, and @var{side} to
-split @var{window}.  If that function is @code{ignore}, nothing is done.
+This function creates a new live window next to the window
+@var{window}.  If @var{window} is omitted or @code{nil}, it defaults
+to the selected window.  That window is ``split'', and reduced in
+size.  The space is taken up by the new window, which is returned.
+
+The optional second argument @var{size} determines the sizes of
+@var{window} and/or the new window.  If it is omitted or @code{nil},
+both windows are given equal sizes; if there is an odd line, it is
+allocated to the new window.  If @var{size} is a positive number,
+@var{window} is given @var{size} lines (or columns, depending on the
+value of @var{side}).  If @var{size} is a negative number, the new
+window is given @minus{}@var{size} lines (or columns).
+
+If @var{size} is @code{nil}, this function obeys the variables
+@code{window-min-height} and @code{window-min-width}.  @xref{Change
+Window,,Deleting and Rearranging Windows, emacs, The GNU Emacs
+Manual}.  Thus, it signals an error if splitting would result in
+making a window smaller than those variables specify.  However, a
+non-@code{nil} value for @var{size} causes those variables to be
+ignored; in that case, the smallest allowable window is considered to
+be one that has space for a text area one line tall and/or two columns
+wide.
+
+The optional third argument @var{side} determines the position of the
+new window relative to @var{window}.  If it is @code{nil} or
+@code{below}, the new window is placed below @var{window}.  If it is
+@code{above}, the new window is placed above @var{window}.  In both
+these cases, @var{size} specifies a total window height, in lines.
+
+If @var{side} is @code{t} or @code{right}, the new window is placed on
+the right of @var{window}.  If @var{side} is @code{left}, the new
+window is placed on the left of @var{window}.  In both these cases,
+@var{size} specifies a total window width, in columns.
+
+If @var{window} is a live window, the new window inherits various
+properties from it, including margins and scroll bars.  If
+@var{window} is an internal window, the new window inherits the
+properties of the window selected within @var{window}'s frame.
+
+If the variable @code{ignore-window-parameters} is non-@code{nil}
+(@pxref{Window Parameters}), this function ignores window parameters.
+Otherwise, it consults the @code{split-window} parameter of
+@var{window}; if this is @code{t}, it splits the window disregarding
+any other window parameters.  If the @code{split-window} parameter
+specifies a function, that function is called with the arguments
+@var{window}, @var{size}, and @var{side} to split @var{window}, in
+lieu of the usual action of @code{split-window}.
 @end deffn
 
-The following example starts with one window on a screen that is 50
-lines high by 80 columns wide; then it splits the window.
+  As an example, we show a combination of @code{split-window} calls
+that yields the window configuration discussed in @ref{Windows and
+Frames}.  This example demonstrates splitting a live window as well as
+splitting an internal window.  We begin with a frame containing a
+single window (a live root window), which we denote by @var{W4}.
+Calling @code{(split-window W3)} yields this window configuration:
 
 @smallexample
 @group
-(setq W1 (selected-window))
-     @result{} #<window 8 on windows.texi>
-(setq W2 (split-window W1 15))
-     @result{} #<window 28 on windows.texi>
-@end group
-@group
-(window-top-line W1)
-     @result{} 0
-(window-total-size W1)
-     @result{} 15
-(window-top-line W2)
-     @result{} 15
-@end group
-@end smallexample
-
-The screen looks like this:
-
-@smallexample
-@group
-         __________
-        |          |  line 0
-        |    W1    |
-        |__________|
-        |          |  line 15
-        |    W2    |
-        |__________|
-                      line 50
- column 0   column 80
-@end group
-@end smallexample
-
-Next, split the top window into two side-by-side windows:
-
-@smallexample
-@group
-(setq W3 (split-window W1 35 t))
-     @result{} #<window 32 on windows.texi>
-@end group
-@group
-(window-left-column W1)
-     @result{} 0
-(window-total-size W1 t)
-     @result{} 35
-(window-left-column W3)
-     @result{} 35
-@end group
-@end smallexample
-
-@need 3000
-Now the screen looks like this:
-
-@smallexample
-@group
-     column 35
-         __________
-        |    |     |  line 0
-        | W1 |  W3 |
-        |____|_____|
-        |          |  line 15
-        |    W2    |
-        |__________|
-                      line 50
- column 0   column 80
-@end group
-@end smallexample
-
-Normally, Emacs indicates the border between two side-by-side windows
-with a scroll bar (@pxref{Scroll Bars}), or with @samp{|} characters.  The
-display table can specify alternative border characters; see @ref{Display
-Tables}.
-
-Below we describe how @code{split-window} can be used to create the
-window configuration from our earlier example (@pxref{Windows and
-Frames}) and how internal windows are created for this purpose.  We
-start with a frame containing one live window @code{W2} (in the
-following scenarios window names are assigned in an arbitrary manner in
-order to match the names of the example).  Evaluating the form
-@code{(split-window W2 8 t)} creates a new internal window @code{W1}
-with two children---@code{W2} (the window we've split) and a new leaf
-window @code{W6}:
-@smallexample
-@group
-     ______________________________________
-    | ______  ____________________________ |
-    ||      ||                            ||
-    ||      ||                            ||
-    ||      ||                            ||
-    ||      ||                            ||
-    ||      ||                            ||
-    ||      ||                            ||
-    ||      ||                            ||
-    ||      ||                            ||
-    ||      ||                            ||
-    ||      ||                            ||
-    ||__W2__||_____________W6_____________ |
-    |__________________W1__________________|
-
-@end group
-@end smallexample
-
-Evaluating now @code{(split-window W6 -3)} creates another internal
-window @code{W3} with two children---@code{W6} and a new live window
-@code{W5}.  This leaves us with a vertically combined window @code{W3}
-embedded in the horizontally combined window @code{W1}:
-@smallexample
-@group
-     ______________________________________
-    | ______  ____________________________ |
-    ||      || __________________________ ||
-    ||      |||                          |||
-    ||      |||                          |||
-    ||      |||                          |||
-    ||      |||                          |||
-    ||      |||                          |||
-    ||      |||____________W6____________|||
-    ||      || __________________________ ||
-    ||      |||                          |||
-    ||      |||____________W5____________|||
-    ||__W2__||_____________W3_____________ |
-    |__________________W1__________________|
-
-@end group
-@end smallexample
-
-Finally, evaluating @code{(split-window W6 nil t)} should get us the
-desired configuration as depicted below.
-@smallexample
-@group
-     ______________________________________
-    | ______  ____________________________ |
-    ||      || __________________________ ||
-    ||      ||| ___________  ___________ |||
-    ||      ||||           ||           ||||
-    ||      ||||           ||           ||||
-    ||      ||||_____W6____||_____W7____||||
-    ||      |||____________W4____________|||
-    ||      || __________________________ ||
-    ||      |||                          |||
-    ||      |||____________W5____________|||
-    ||__W2__||_____________W3_____________ |
-    |__________________W1__________________|
-
-@end group
-@end smallexample
-
-The scenario sketched above is the standard way to obtain the desired
-configuration.  In Emacs 23 it was also the only way to do that since
-Emacs 23 did't allow splitting internal windows.
-
-With Emacs 24 you can also proceed as follows: Split an initial window
-@code{W6} by evaluating @code{(split-window W6 -3)} to produce the
-following vertical combination:
-@smallexample
-@group
      ______________________________________
     | ____________________________________ |
     ||                                    ||
     ||                                    ||
     ||                                    ||
+    ||_________________W4_________________||
+    | ____________________________________ |
     ||                                    ||
     ||                                    ||
     ||                                    ||
-    ||                                    ||
-    ||_________________W6_________________||
-    | ____________________________________ |
-    ||                                    ||
     ||_________________W5_________________||
     |__________________W3__________________|
 
 @end group
 @end smallexample
 
-Evaluating now @code{(split-window (window-parent W6) -8 'left)} or,
-equivalently, @code{(split-window W3 -8 'left)} should now produce the
-penultimate configuration from the previous scenario from where we can
-continue as described before.
-
-   Another strategy starts with splitting an initial window @code{W6} by
-evaluating @code{(split-window W6 nil nil t)} with the following result:
-@smallexample
-@group
-     ______________________________________
-    | _________________  _________________ |
-    ||                 ||                 ||
-    ||                 ||                 ||
-    ||                 ||                 ||
-    ||                 ||                 ||
-    ||                 ||                 ||
-    ||                 ||                 ||
-    ||                 ||                 ||
-    ||                 ||                 ||
-    ||                 ||                 ||
-    ||                 ||                 ||
-    ||________W6_______||________W7_______||
-    |__________________W4__________________|
-
-@end group
-@end smallexample
-
-Evaluating now @code{(split-window W4 -3)} or @code{(split-window
-(window-parent W6) -3)} should get us a configuration as shown next.
-@smallexample
-@group
-     ______________________________________
-    | ____________________________________ |
-    || ________________  ________________ ||
-    |||                ||                |||
-    |||                ||                |||
-    |||                ||                |||
-    |||                ||                |||
-    |||                ||                |||
-    |||_______W6_______||________W7______|||
-    ||_________________W4_________________||
-    | ____________________________________ |
-    ||                                    ||
-    ||_________________W5_________________||
-    |__________________W3__________________|
-
-@end group
-@end smallexample
+@noindent
+The @code{split-window} call has created a new live window, denoted by
+@var{W5}.  It has also created a new internal window, denoted by
+@var{W3}, which becomes the root window and the parent of both
+@var{W4} and @var{W5}.
 
-The desired configuration can be now obtained by evaluating
-@code{(split-window W3 -8 'left)} or, equivalently, @code{(split-window
-(window-parent W5) -8 'left)}.
+  Next, we call @code{(split-window W3 nil 'left)}, passing the
+internal window @var{W3} as the argument.  The result:
 
-   For a final approach let's start with the configuration of two live
-windows @code{W6} and @code{W7} shown above.  If we now evaluate
-@code{(split-window W4 -8 'left)} or @code{(split-window (window-parent
-W6) -8 'left)} we get the following configuration.
 @smallexample
 @group
      ______________________________________
     | ______  ____________________________ |
-    ||      || ____________  ____________ ||
-    ||      |||            ||            |||
-    ||      |||            ||            |||
-    ||      |||            ||            |||
-    ||      |||            ||            |||
-    ||      |||            ||            |||
-    ||      |||            ||            |||
-    ||      |||            ||            |||
-    ||      |||______W6____||______W7____|||
-    ||__W2__||_____________W4_____________||
+    ||      || __________________________ ||
+    ||      |||                          |||
+    ||      |||                          |||
+    ||      |||                          |||
+    ||      |||____________W4____________|||
+    ||      || __________________________ ||
+    ||      |||                          |||
+    ||      |||                          |||
+    ||      |||____________W5____________|||
+    ||__W2__||_____________W3_____________ |
     |__________________W1__________________|
-
 @end group
 @end smallexample
 
-Evaluating now @code{(split-window W4 -3)} or, for example,
-@code{(split-window (window-parent W6) -3)} should produce the desired
-configuration.
+@noindent
+A new live window @var{W2} is created, to the left of the internal
+window @var{W3}.  A new internal window @var{W1} is created, becoming
+the new root window.
 
-  The two options described next can be used to tune the operation of
+  The following two options can be used to modify the operation of
 @code{split-window}.
 
 @defopt window-splits
-If this variable is nil, the function @code{split-window} can split a
-window if and only if that window's screen estate is sufficiently large
-to accommodate both--itself and the new window.
+If this variable is @code{nil}, @code{split-window} can only split a
+window (denoted by @var{window}) if @var{window}'s screen area is
+large enough to accommodate both itself and the new window.  This is
+the default.
 
-If this variable is non-@code{nil}, @code{split-window} tries to resize
-all windows that are part of the same combination as the old window to
-accommodate the new window.  Hence, the new window can be also created if
-the old window is of fixed size or too small to split (@pxref{Window
-Sizes}).
+If this variable is non-@code{nil}, @code{split-window} tries to
+resize all windows that are part of the same combination as
+@var{window}, in order to accommodate the new window.  In particular,
+this may allow @code{split-window} to succeed even if @var{window} is
+a fixed-size window or too small to ordinarily split.
 
 In any case, the value of this variable is assigned to the splits status
 of the new window and, provided old and new window form a new
@@ -1352,15 +983,15 @@ windows only.
 
 @cindex nest status
 The @dfn{nest status} of a window specifies whether that window may be
-removed and its subwindows recombined with that window's siblings when
-such a sibling's subwindow is deleted.  The nest status is initially
-assigned by @code{split-window} from the current value of the variable
-@code{window-nest} (see above) and can be reset by the function
+removed and its child windows recombined with that window's siblings
+when such a sibling's child window is deleted.  The nest status is
+initially assigned by @code{split-window} from the current value of the
+variable @code{window-nest} (see above) and can be reset by the function
 @code{set-window-nest} (see below).
 
-If the return value is @code{nil}, subwindows of @var{window} may be
+If the return value is @code{nil}, child windows of @var{window} may be
 recombined with @var{window}'s siblings when a window gets deleted.  A
-return value of @code{nil} means that subwindows of @var{window} are
+return value of @code{nil} means that child windows of @var{window} are
 never (re-)combined with @var{window}'s siblings in such a case.
 @end defun
 
@@ -1601,11 +1232,11 @@ function, it calls that function with @var{window} as its sole argument.
 @end deffn
 
 @deffn Command delete-windows-on &optional buffer-or-name frame
-This function deletes all windows showing @var{buffer-or-name} and
-returns nil.  If there are no windows showing @var{buffer-or-name}, it
-does nothing.  The optional argument @var{buffer-or-name} may be a
-buffer or the name of an existing buffer and defaults to the current
-buffer.  Invoking this command on a minibuffer signals an error.
+This function deletes all windows showing @var{buffer-or-name}.  If
+there are no windows showing @var{buffer-or-name}, it does nothing.
+The optional argument @var{buffer-or-name} may be a buffer or the name
+of an existing buffer and defaults to the current buffer.  Invoking
+this command on a minibuffer signals an error.
 
 The function @code{delete-windows-on} operates by calling
 @code{delete-window} for each window showing @var{buffer-or-name}.  If a
@@ -1833,7 +1464,7 @@ This function does not select a window that has a non-@code{nil}
 @end deffn
 
 The following function returns a copy of the list of windows in the
-cyclic odering.
+cyclic ordering.
 
 @defun window-list-1 &optional window &optional minibuf &optional all_frames
 This function returns a list of live windows.  The optional arguments
@@ -1843,7 +1474,7 @@ in the list.  See the description of @code{next-window} for details.
 The optional argument @var{window} specifies the first window to list
 and defaults to the selected window.  If @var{window} is not on the list
 of windows returned, some other window will be listed first but no error
-is signalled.
+is signaled.
 @end defun
 
 The functions described below use @code{window-list-1} for generating a
@@ -1956,7 +1587,7 @@ This function makes @var{window} display @var{buffer-or-name} and
 returns @code{nil}.  The argument @var{window} has to denote a live
 window and defaults to the selected one.  The argument
 @var{buffer-or-name} must specify a buffer or the name of an existing
-buffer.  An error is signalled when @var{window} is @dfn{strongly}
+buffer.  An error is signaled when @var{window} is @dfn{strongly}
 dedicated to its buffer (@pxref{Dedicated Windows}) and does not already
 display @var{buffer-or-name}.
 
@@ -2043,7 +1674,7 @@ If a window displaying @var{buffer-or-name} is dedicated
 (@pxref{Dedicated Windows}) and is not the only window on its frame,
 that window is deleted.  If that window is the only window on its frame
 and there are other frames on the frame's terminal, that frame is dealt
-with by the function spcecified by @code{frame-auto-hide-function}
+with by the function specified by @code{frame-auto-hide-function}
 (@pxref{Quitting Windows}).  Otherwise, the buffer provided by the
 function @code{switch-to-prev-buffer} (@pxref{Window History}) is
 displayed in the window instead.
@@ -2163,7 +1794,7 @@ unless @var{norecord} is non-@code{nil}.
 
   The command @code{display-buffer} flexibly chooses a window for
 display, and displays a specified buffer in that window.  It can be
-called interactively, via the key binding @kbd{C-x 4 o}.  It is also
+called interactively, via the key binding @kbd{C-x 4 C-o}.  It is also
 used as a subroutine by many functions and commands, including
 @code{switch-to-buffer} and @code{pop-to-buffer} (@pxref{Switching
 Buffers}).
@@ -2221,7 +1852,7 @@ The constant @code{display-buffer-fallback-action}.
 @noindent
 Each action function is called in turn, passing the buffer as the
 first argument and the combined action alist as the second argument,
-until one of the functions returns non-nil.
+until one of the functions returns non-@code{nil}.
 
 The argument @var{action} can also have a non-@code{nil}, non-list
 value.  This has the special meaning that the buffer should be
@@ -2272,7 +1903,7 @@ returns the window if it succeeds, and @code{nil} if it fails.
 This function tries to display @var{buffer} in the selected window.
 It fails if the selected window is a minibuffer window or is dedicated
 to another buffer (@pxref{Dedicated Windows}).  It also fails if
-@var{alist} has a non-nil @code{inhibit-same-window} entry.
+@var{alist} has a non-@code{nil} @code{inhibit-same-window} entry.
 @end defun
 
 @defun display-buffer-reuse-window buffer alist
@@ -3281,7 +2912,7 @@ This function scrolls the text in the selected window so that point is
 displayed at a specified vertical position within the window.  It does
 not ``move point'' with respect to the text.
 
-If @var{count} is a nonnegative number, that puts the line containing
+If @var{count} is a non-negative number, that puts the line containing
 point @var{count} lines down from the top of the window.  If
 @var{count} is a negative number, then it counts upward from the
 bottom of the window, so that @minus{}1 stands for the last usable
@@ -3740,7 +3371,7 @@ selected one.
 
 The optional argument @var{ignore} non-@code{nil} means to ignore
 minimum window sizes and fixed size restrictions.  If @var{ignore}
-equals @code{safe}, this means subwindows can get as small as one line
+equals @code{safe}, this means windows can get as small as one line
 and/or two columns.
 @end defun
 
diff --git a/doc/misc/auth.texi b/doc/misc/auth.texi
index a16da92343e..b64562f6875 100644
--- a/doc/misc/auth.texi
+++ b/doc/misc/auth.texi
@@ -64,13 +64,13 @@ It is a way for multiple applications to share a single configuration
 
 @menu
 * Overview::                    Overview of the auth-source library.
-* Help for users::              
-* Secret Service API::          
-* Help for developers::         
-* GnuPG and EasyPG Assistant Configuration::  
-* Index::                       
-* Function Index::              
-* Variable Index::              
+* Help for users::
+* Secret Service API::
+* Help for developers::
+* GnuPG and EasyPG Assistant Configuration::
+* Index::
+* Function Index::
+* Variable Index::
 @end menu
 @end ifnottex
 
@@ -182,7 +182,7 @@ Here's a mixed example using two sources:
 If you don't customize @code{auth-sources}, you'll have to live with
 the defaults: any host and any port are looked up in the netrc
 file @code{~/.authinfo.gpg}, which is a GnuPG encrypted file
-(@pxref{GnuPG and EasyPG Assistant Configuration}).  
+(@pxref{GnuPG and EasyPG Assistant Configuration}).
 
 If that fails, the unencrypted netrc files @code{~/.authinfo} and
 @code{~/.netrc} will be used.
@@ -340,7 +340,7 @@ If you are using earlier versions of Emacs, you will need:
 @end lisp
 
 If you want your GnuPG passwords to be cached, set up @code{gpg-agent}
-or EasyPG Assitant
+or EasyPG Assistant
 (@pxref{Caching Passphrases, , Caching Passphrases, epa}).
 
 To quick start, here are some questions:
diff --git a/doc/misc/gnus.texi b/doc/misc/gnus.texi
index 70ed62ddfa9..545306e4dc7 100644
--- a/doc/misc/gnus.texi
+++ b/doc/misc/gnus.texi
@@ -1001,7 +1001,7 @@ press @kbd{^} from the Group buffer to see it.  In the Server buffer,
 you can press @kbd{RET} on a defined server to see all the groups it
 serves (subscribed or not!).  You can also add or delete servers, edit
 a foreign server's definition, agentize or de-agentize a server, and
-do many other neat things.  @xref{Server Buffer}.  
+do many other neat things.  @xref{Server Buffer}.
 @xref{Foreign Groups}.  @xref{Agent Basics}.
 
 @vindex gnus-select-method
@@ -11805,7 +11805,7 @@ fit these criteria.
 
 To use this, make sure that you have @code{w3m} and @code{curl}
 installed.  If you have, then Gnus should display @acronym{HTML}
-automatically. 
+automatically.
 
 
 
@@ -21078,8 +21078,8 @@ as well.
 
 This chapter describes tools for searching groups and servers for
 articles matching a query and then retrieving those articles. Gnus
-provides a simpler mechanism for searching through articles in a summary buffer 
-to find those matching a pattern. @xref{Searching for Articles}. 
+provides a simpler mechanism for searching through articles in a summary buffer
+to find those matching a pattern. @xref{Searching for Articles}.
 
 @menu
 * nnir::                     Searching with various engines.
@@ -21110,7 +21110,7 @@ interface.
 
 The @code{nnimap} and @code{gmane} search engines should work with no
 configuration. Other engines require a local index that needs to be
-created and maintained outside of Gnus. 
+created and maintained outside of Gnus.
 
 
 @node Basic Usage
@@ -21150,7 +21150,7 @@ One more thing: individual search engines may have special search
 features. You can access these special features by giving a prefix-arg
 to @code{gnus-group-make-nnir-group}. If you are searching multiple
 groups with different search engines you will be prompted for the
-special search features for each engine separately. 
+special search features for each engine separately.
 
 
 @node Setting up nnir
@@ -21191,7 +21191,7 @@ named @code{home} you can use
 
 @lisp
 (setq gnus-secondary-select-methods
-      '((nnml "home" 
+      '((nnml "home"
          (nnimap-address "localhost")
          (nnir-search-engine namazu))))
 @end lisp
@@ -21216,9 +21216,9 @@ could change this to
 @node The imap Engine
 @subsubsection The imap Engine
 
-The @code{imap} engine requires no configuration. 
+The @code{imap} engine requires no configuration.
 
-Queries using the @code{imap} engine follow a simple query language. 
+Queries using the @code{imap} engine follow a simple query language.
 The search is always case-insensitive and supports the following
 features (inspired by the Google search input language):
 
@@ -21231,7 +21231,7 @@ operators must be written with all capital letters to be
 recognised. Also preceding a term with a - sign is equivalent to NOT
 term.
 
-@item Automatic AND queries 
+@item Automatic AND queries
 If you specify multiple words then they will be treated as an AND
 expression intended to match all components.
 
@@ -21264,7 +21264,7 @@ customize @code{nnir-imap-default-search-key}. For example to use
 @node The gmane Engine
 @subsubsection The gmane Engine
 
-The @code{gmane} engine requires no configuration. 
+The @code{gmane} engine requires no configuration.
 
 Gmane queries follow a simple query language:
 
@@ -21278,11 +21278,11 @@ recognised.
 @item Required and excluded terms
 + and - can be used to require or exclude terms, e.g. football -american
 
-@item Unicode handling 
+@item Unicode handling
 The search engine converts all text to utf-8, so searching should work
 in any language.
 
-@item Stopwords 
+@item Stopwords
 Common English words (like 'the' and 'a') are ignored by default. You
 can override this by prefixing such words with a + (e.g. +the) or
 enclosing the word in quotes (e.g. "the").
@@ -21345,7 +21345,7 @@ to get a group name. By default this is @code{$HOME/Mail}.
 Using the namazu engine requires creating and maintaining index files.
 One directory should contain all the index files, and nnir must be told
 where to find them by setting the @code{nnir-namazu-index-directory}
-variable.  
+variable.
 
 To work correctly the @code{nnir-namazu-remove-prefix} variable must
 also be correct. This is the prefix to remove from each file name
@@ -21408,7 +21408,7 @@ this command periodically, say every four hours.
 This engine is obsolete.
 
 @node Customizations
-@subsubsection Custimozations
+@subsubsection Customizations
 
 @table @code
 
diff --git a/etc/NEWS b/etc/NEWS
index 5e7e6cbb47e..59fab6d9107 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -621,6 +621,10 @@ view-diary-entries, list-diary-entries, show-all-diary-entries
 inserted by the compilation filter function, when calling
 compilation-filter-hook.
 
+*** `compilation-error-screen-columns' is obeyed in the editing buffer.
+So programming language modes can set it, whereas previously only the value
+in the *compilation* buffer was used.
+
 ** Customize
 
 *** Customize buffers now contain a search field.
diff --git a/etc/images/icons/allout-widgets/light-bg/locked-encrypted.png b/etc/images/icons/allout-widgets/light-bg/locked-encrypted.png
index a6bc3e99a7a..a6bc3e99a7a 100755..100644
--- a/etc/images/icons/allout-widgets/light-bg/locked-encrypted.png
+++ b/etc/images/icons/allout-widgets/light-bg/locked-encrypted.png
diff --git a/etc/images/icons/allout-widgets/light-bg/unlocked-encrypted.png b/etc/images/icons/allout-widgets/light-bg/unlocked-encrypted.png
index e70d075690a..e70d075690a 100755..100644
--- a/etc/images/icons/allout-widgets/light-bg/unlocked-encrypted.png
+++ b/etc/images/icons/allout-widgets/light-bg/unlocked-encrypted.png
diff --git a/leim/quail/ipa.el b/leim/quail/ipa.el
index 425a0591c9d..503d8b4ec89 100644
--- a/leim/quail/ipa.el
+++ b/leim/quail/ipa.el
@@ -451,7 +451,7 @@ displays them, incorrectly, as separate from the modified glyphs.")
  ;; them, and the recipient's client is capable, they will get through,
  ;; though.
 
- ("_\"" "̈")   ;; Centralised                          U+0308
+ ("_\"" "̈")   ;; Centralized                          U+0308
  ("_+" "̟")    ;; Advanced                             U+031F
  ("_-" "̠")    ;; Retracted                            U+0320
  ("_/" "ˇ")    ;; Rising tone                          U+02C7
diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 6cc9cc86515..6df54fb4527 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,120 @@
+2011-11-11  Glenn Morris  <rgm@gnu.org>
+
+        * subr.el (eval-after-load): If FILE is already loaded,
+        evaluate FORM before it gets wrapped in more stuff.  (Bug#10009)
+
+2011-11-10  Glenn Morris  <rgm@gnu.org>
+
+        * vc/vc-svn.el (vc-svn-create-repo, vc-svn-modify-change-comment):
+        Call svn via vc-svn-command rather than vc-do-command.
+        (vc-svn-command): Add --non-interactive.  (Bug#9993)
+        (vc-svn-update, vc-svn-merge-news): No need for --non-interactive.
+
+        * emacs-lisp/bytecomp.el (byte-compile-interactive-only-functions):
+        Add toggle-read-only.  (Bug#7292)
+        * files.el (toggle-read-only): Mention that it should only
+        be used interactively.  (Bug#10006)
+
+2011-11-09  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * progmodes/compile.el (compilation-error-regexp-alist-alist):
+        Adjust regexp for OCaml warnings.
+
+        * electric.el (electric-pair-post-self-insert-function): Let user
+        turn it off buffer-locally (bug#9932).
+
+        * progmodes/python.el (python-beginning-of-statement):
+        Rewrite (bug#2703).
+
+        * progmodes/compile.el: Better handle TABs (bug#9749).
+        (compilation-internal-error-properties)
+        (compilation-next-error-function): Obey the target buffer's
+        compilation-error-screen-columns.
+
+2011-11-09  Juanma Barranquero  <lekktu@gmail.com>
+
+        * progmodes/meta-mode.el: Remove obsolete comments.
+        (meta-right-comment-regexp, meta-ignore-comment-regexp):
+        Fix typos in docstrings.
+
+2011-11-09  Martin Rudalics  <rudalics@gmx.at>
+
+        * window.el (window-size-fixed-p): Rewrite doc-string.
+        (window-resizable-p): Rename to window--resizable-p.  Update callers.
+        (window--resizable): New function.  Make all callers of
+        window-resizable call window--resizable instead.
+        (window-resizable): Rewrite in terms of window--resizable.
+
+2011-11-08  Glenn Morris  <rgm@gnu.org>
+
+        * progmodes/delphi.el (delphi-mode-syntax-table):
+        Let define-derived-mode define a proper syntax table.  (Bug#9994)
+
+2011-11-08  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * window.el: Stay away from defsubst.
+        (window-list-no-nils): Remove.
+        (window-state-get-1, window-state-get): Use backquote instead.
+
+2011-11-08  thierry  <thierry.volpiatto@gmail.com>
+
+        * emacs-lisp/find-func.el (find-function-read):
+        Fix incorrect use of default argument in `completing-read'.
+
+2011-11-08  Martin Rudalics  <rudalics@gmx.at>
+
+        * window.el (display-buffer-function, special-display-function):
+        Mention display-buffer-record-window but do not mention
+        help-setup parameter in doc-strings.
+        (window-min-delta): Fix doc-string typo.
+
+2011-11-08  Chong Yidong  <cyd@gnu.org>
+
+        * window.el (window-total-height, window-total-width): Doc fix.
+        (window-body-size): Move from C.
+        (window-body-height, window-body-width): Move to C.
+
+2011-11-08  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * window.el: Make special-display like display-buffer-alist (bug#9532).
+        (display-buffer--special-action): New function, morphed
+        from display-buffer--special.
+        (display-buffer): Use it to handle special-display-buffers at higher
+        priority (just after display-buffer-alist).
+        (display-buffer-fallback-action, display-buffer--other-frame-action)
+        (pop-to-buffer-same-window): Remove display-buffer--special.
+
+2011-11-07  Glenn Morris  <rgm@gnu.org>
+
+        * calendar/cal-menu.el (cal-menu-set-date-title):
+        Do nothing if not in a calendar.  (Bug#9976)
+
+2011-11-07  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * files.el (find-file): Always use selected-window.
+
+2011-11-07  Martin Rudalics  <rudalics@gmx.at>
+
+        * window.el (window-combinations): Make WINDOW argument
+        mandatory.  Rewrite doc-string.
+        (walk-window-subtree, window-atom-check, window-min-delta)
+        (window-max-delta, window--resize-this-window)
+        (window--resize-root-window-vertically, window-tree)
+        (balance-windows, window-state-put): Rewrite doc-strings as to
+        not mention the term "subwindow".
+        (window--resize-subwindows-skip-p): Rename to
+        window--resize-child-windows-skip-p.
+        (window--resize-subwindows-normal): Rename to
+        window--resize-child-windows-normal.
+        (window--resize-subwindows): Rename to
+        window--resize-child-windows.
+        (window-or-subwindow-p): Rename to window--in-subtree-p.
+
+2011-11-07  Mark Lillibridge  <mark.lillibridge@hp.com>  (tiny change)
+
+        * mail/rmail.el (rmail-get-new-mail, rmail-insert-inbox-text):
+        Ensure that mbox format messages end in two newlines (Bug#9974).
+
 2011-11-06  Chong Yidong  <cyd@gnu.org>
 
         * window.el (window-combination-p): Function deleted; its
@@ -11,7 +128,7 @@
         (window-size-ignore, window-state-get): Callers changed.
         (window-normalize-window): Rename from window-normalize-any-window.
         New arg LIVE-ONLY, replacing window-normalize-live-window.
-        (window-normalize-live-window): Deleted.
+        (window-normalize-live-window): Delete.
         (window-combination-p, window-combined-p, window-combinations)
         (walk-window-subtree, window-atom-root, window-min-size)
         (window-sizable, window-sizable-p, window-size-fixed-p)
diff --git a/lisp/calendar/cal-menu.el b/lisp/calendar/cal-menu.el
index 3ebb7edab3f..d8de171c0a1 100644
--- a/lisp/calendar/cal-menu.el
+++ b/lisp/calendar/cal-menu.el
@@ -215,13 +215,15 @@ is non-nil."
 ;; but easymenu does not seem to allow this (?).
 ;; The ignore-errors is because `documentation' can end up calling
 ;; this in a non-calendar buffer where displayed-month is unbound.  (Bug#3862)
+;; This still has issues - bug#9976, so added derived-mode-p call.
 (defun cal-menu-set-date-title (menu)
   "Convert date of last event to title suitable for MENU."
-  (let ((date (ignore-errors (calendar-cursor-to-date nil last-input-event))))
-    (if date
-        (easy-menu-filter-return menu (calendar-date-string date t nil))
-      (message "Not on a date!")
-      nil)))
+  (when (derived-mode-p 'calendar-mode)
+    (let ((date (ignore-errors (calendar-cursor-to-date nil last-input-event))))
+      (if date
+          (easy-menu-filter-return menu (calendar-date-string date t nil))
+        (message "Not on a date!")
+        nil))))
 
 (easy-menu-define cal-menu-context-mouse-menu nil
   "Pop up mouse menu for selected date in the calendar window."
diff --git a/lisp/delim-col.el b/lisp/delim-col.el
index d9f8634fb54..ed6ab96107a 100644
--- a/lisp/delim-col.el
+++ b/lisp/delim-col.el
@@ -194,7 +194,7 @@ Any other value is treated as t."
                  :tag "Column Formating"
                  (const :tag "No Formating" nil)
                  (const :tag "Column Alignment" t)
-                 (const :tag "Separator Aligment" separator)
+                 (const :tag "Separator Alignment" separator)
                  (const :tag "Column Padding" padding))
   :group 'columns)
 
diff --git a/lisp/electric.el b/lisp/electric.el
index 26fba20ea12..3d7c1fd8ac4 100644
--- a/lisp/electric.el
+++ b/lisp/electric.el
@@ -284,6 +284,7 @@ This can be convenient for people who find it easier to hit ) than C-f."
 
 (defun electric-pair-post-self-insert-function ()
   (let* ((syntax (and (eq (char-before) last-command-event) ; Sanity check.
+                      electric-pair-mode
                       (let ((x (assq last-command-event electric-pair-pairs)))
                         (cond
                          (x (if (eq (car x) (cdr x)) ?\" ?\())
diff --git a/lisp/emacs-lisp/bytecomp.el b/lisp/emacs-lisp/bytecomp.el
index fae402d4215..84aaf8718ed 100644
--- a/lisp/emacs-lisp/bytecomp.el
+++ b/lisp/emacs-lisp/bytecomp.el
@@ -355,7 +355,7 @@ else the global value will be modified."
 (defvar byte-compile-interactive-only-functions
   '(beginning-of-buffer end-of-buffer replace-string replace-regexp
     insert-file insert-buffer insert-file-literally previous-line next-line
-    goto-line comint-run delete-backward-char)
+    goto-line comint-run delete-backward-char toggle-read-only)
   "List of commands that are not meant to be called from Lisp.")
 
 (defvar byte-compile-not-obsolete-vars nil
diff --git a/lisp/emacs-lisp/find-func.el b/lisp/emacs-lisp/find-func.el
index 08e73b32a15..070faca8d91 100644
--- a/lisp/emacs-lisp/find-func.el
+++ b/lisp/emacs-lisp/find-func.el
@@ -363,29 +363,23 @@ If TYPE is nil, insist on a symbol with a function definition.
 Otherwise TYPE should be `defvar' or `defface'.
 If TYPE is nil, defaults using `function-called-at-point',
 otherwise uses `variable-at-point'."
-  (let ((symb (if (null type)
-                  (function-called-at-point)
-                (if (eq type 'defvar)
-                    (variable-at-point)
-                  (variable-at-point t))))
-        (predicate (cdr (assq type '((nil . fboundp) (defvar . boundp)
-                                     (defface . facep)))))
-        (prompt (cdr (assq type '((nil . "function") (defvar . "variable")
-                                  (defface . "face")))))
-        (enable-recursive-minibuffers t)
-        val)
-    (if (equal symb 0)
-        (setq symb nil))
-    (setq val (completing-read
-               (concat "Find "
-                       prompt
-                       (if symb
-                           (format " (default %s)" symb))
-                       ": ")
-               obarray predicate t nil))
-    (list (if (equal val "")
-              symb
-            (intern val)))))
+  (let* ((symb1 (cond ((null type) (function-called-at-point))
+                      ((eq type 'defvar) (variable-at-point))
+                      (t (variable-at-point t))))
+         (symb  (unless (eq symb1 0) symb1))
+         (predicate (cdr (assq type '((nil . fboundp)
+                                      (defvar . boundp)
+                                      (defface . facep)))))
+         (prompt-type (cdr (assq type '((nil . "function")
+                                        (defvar . "variable")
+                                        (defface . "face")))))
+         (prompt (concat "Find " prompt-type
+                         (and symb (format " (default %s)" symb))
+                         ": "))
+         (enable-recursive-minibuffers t))
+    (list (intern (completing-read
+                   prompt obarray predicate
+                   t nil nil (and symb (symbol-name symb)))))))
 
 (defun find-function-do-it (symbol type switch-fn)
   "Find Emacs Lisp SYMBOL in a buffer and display it.
diff --git a/lisp/emulation/edt.el b/lisp/emulation/edt.el
index 7ed0255d987..acdc3caa449 100644
--- a/lisp/emulation/edt.el
+++ b/lisp/emulation/edt.el
@@ -2484,7 +2484,7 @@ Argument GOLD-BINDING is the Emacs function to be bound to GOLD <KEY>."
   F10: Cut Rectangle
 G-F10: Paste Rectangle
   F11: ESC
-  F12: Begining of Line           +----------+----------+----------+----------+
+  F12: Beginning of Line          +----------+----------+----------+----------+
 G-F12: Delete Other Windows       |   GOLD   |   HELP   |  FNDNXT  |  DEL L   |
   F13: Delete to Begin of Word    |   (PF1)  |   (PF2)  |   (PF3)  |  (PF4)   |
  HELP: Keypad Help                |Mark Wisel|Desc Funct|   FIND   |  UND L   |
diff --git a/lisp/files.el b/lisp/files.el
index 40e2df14c1b..aac415c1a96 100644
--- a/lisp/files.el
+++ b/lisp/files.el
@@ -1343,7 +1343,7 @@ automatically choosing a major mode, use \\[find-file-literally]."
   (let ((value (find-file-noselect filename nil nil wildcards)))
     (if (listp value)
         (mapcar 'switch-to-buffer (nreverse value))
-      (switch-to-buffer value))))
+      (switch-to-buffer value nil 'force-same-window))))
 
 (defun find-file-other-window (filename &optional wildcards)
   "Edit file FILENAME, in another window.
@@ -4686,7 +4686,15 @@ prints a message in the minibuffer.  Instead, use `set-buffer-modified-p'."
   "Change whether this buffer is read-only.
 With prefix argument ARG, make the buffer read-only if ARG is
 positive, otherwise make it writable.  If buffer is read-only
-and `view-read-only' is non-nil, enter view mode."
+and `view-read-only' is non-nil, enter view mode.
+
+This function is usually the wrong thing to use in a Lisp program.
+It can have side-effects beyond changing the read-only status of a buffer
+\(e.g., enabling view mode), and does not affect read-only regions that
+are caused by text properties.  To make a buffer read-only in Lisp code,
+set `buffer-read-only'.  To ignore read-only status (whether due to text
+properties or buffer state) and make changes, temporarily bind
+`inhibit-read-only'."
   (interactive "P")
   (if (and arg
            (if (> (prefix-numeric-value arg) 0) buffer-read-only
diff --git a/lisp/generic-x.el b/lisp/generic-x.el
index 5205a6811f6..2c00229c76e 100644
--- a/lisp/generic-x.el
+++ b/lisp/generic-x.el
@@ -1436,7 +1436,7 @@ like an INI file.  You can add this hook to `find-file-hook'."
     "REGDB_APPPATH"
     "REGDB_BINARY"
     "REGDB_ERR_CONNECTIONEXISTS"
-    "REGDB_ERR_CORRUPTEDREGSITRY"
+    "REGDB_ERR_CORRUPTEDREGISTRY"
     "REGDB_ERR_INITIALIZATION"
     "REGDB_ERR_INVALIDHANDLE"
     "REGDB_ERR_INVALIDNAME"
diff --git a/lisp/gnus/ChangeLog b/lisp/gnus/ChangeLog
index c36d4729518..fbbf3bad5a8 100644
--- a/lisp/gnus/ChangeLog
+++ b/lisp/gnus/ChangeLog
@@ -18491,7 +18491,7 @@
 2004-10-05  Jesper Harder  <harder@ifa.au.dk>
 
         * nnsoup.el (nnsoup-read-active-file): Use dolist, mapc or last
-        where approriate.
+        where appropriate.
 
         * nnml.el (nnml-generate-active-info): do.
 
diff --git a/lisp/gnus/smime.el b/lisp/gnus/smime.el
index 5a7079883e6..f0951b7b803 100644
--- a/lisp/gnus/smime.el
+++ b/lisp/gnus/smime.el
@@ -689,7 +689,7 @@ The following commands are available:
       (dolist (key smime-keys)
         (insert
          (format "\t\t%s: %s\n" (car key) (cadr key))))
-      (insert "\nTrusted Certificate Authoritys:\n")
+      (insert "\nTrusted Certificate Authorities:\n")
       (insert "\nKnown Certificates:\n"))))
 
 (defun smime ()
diff --git a/lisp/international/robin.el b/lisp/international/robin.el
index 7e98a507f93..6f78aaede3f 100644
--- a/lisp/international/robin.el
+++ b/lisp/international/robin.el
@@ -22,7 +22,7 @@
 ;; You should have received a copy of the GNU General Public License
 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
 
-;;; Comentary:
+;;; Commentary:
 
 ;; Functionalities
 ;; ---------------
diff --git a/lisp/mail/rmail.el b/lisp/mail/rmail.el
index a535d3a86db..4b3441a8cdc 100644
--- a/lisp/mail/rmail.el
+++ b/lisp/mail/rmail.el
@@ -1721,10 +1721,12 @@ not be a new one).  It returns non-nil if it got any new messages."
                 (setq all-files (cdr all-files)))
               ;; Put them back in their original order.
               (setq files (nreverse files))
-              ;; In case of brain damage caused by require-final-newline.
               (goto-char (point-max))
-              (skip-chars-backward " \t\n")
-              (delete-region (point) (point-max))
+              ;; Make sure we end with a blank line unless there are
+              ;; no messages, as required by mbox format (Bug#9974).
+              (unless (bobp)
+                (while (not (looking-back "\n\n"))
+                  (insert "\n")))
               (setq found (or
                            (rmail-get-new-mail-1 file-name files delete-files)
                            found))))
@@ -2024,22 +2026,12 @@ Value is the size of the newly read mail after conversion."
                   (rmail-unrmail-new-mail-maybe
                    tofile
                    (nth 1 (insert-file-contents tofile))))
-            ;; Determine if a pair of newline message separators need
-            ;; to be added to the new collection of messages.  This is
-            ;; the case for all new message collections added to a
-            ;; non-empty mail file.
-            (unless (zerop size)
-              (save-restriction
-                (let ((start (point-min)))
-                  (widen)
-                  (unless (eq start (point-min))
-                    (goto-char start)
-                    (insert "\n\n")
-                    (setq size (+ 2 size))))))
             (goto-char (point-max))
-            (or (= (preceding-char) ?\n)
-                (zerop size)
-                (insert ?\n))
+            ;; Make sure the read-in mbox data properly ends with a
+            ;; blank line unless it is of size 0.
+            (unless (zerop size)
+              (while (not (looking-back "\n\n"))
+                (insert "\n")))
             (if (not (and rmail-preserve-inbox (string= file tofile)))
                 (setq delete-files (cons tofile delete-files)))))
       (message "")
diff --git a/lisp/net/secrets.el b/lisp/net/secrets.el
index 89378497c36..9fa5eb32d43 100644
--- a/lisp/net/secrets.el
+++ b/lisp/net/secrets.el
@@ -774,7 +774,7 @@ to their attributes."
            (cons
             (1+ (length "password"))
             (mapcar
-             ;; Atribute names have a leading ":", which will be suppressed.
+             ;; Attribute names have a leading ":", which will be suppressed.
              (lambda (attribute) (length (symbol-name (car attribute))))
              attributes)))))
     (cons
diff --git a/lisp/org/org-agenda.el b/lisp/org/org-agenda.el
index aea284fe72c..53a0c5587a2 100644
--- a/lisp/org/org-agenda.el
+++ b/lisp/org/org-agenda.el
@@ -764,7 +764,7 @@ because you will take care of it on the day when scheduled."
   :group 'org-agenda-skip
   :group 'org-agenda-daily/weekly
   :type '(choice
-          (const :tag "Alwas show prewarning" nil)
+          (const :tag "Always show prewarning" nil)
           (const :tag "Remove prewarning if entry is scheduled" t)
           (integer :tag "Restart prewarning N days before deadline")))
 
@@ -1388,13 +1388,13 @@ When nil, such items are sorted as 0 minutes effort."
     (tags  . " %i %-12:c")
     (search . " %i %-12:c"))
   "Format specifications for the prefix of items in the agenda views.
-An alist with five entries, each for the different agenda types.  The 
-keys of the sublists are `agenda', `timeline', `todo', `search' and `tags'.  
+An alist with five entries, each for the different agenda types.  The
+keys of the sublists are `agenda', `timeline', `todo', `search' and `tags'.
 The values are format strings.
 
 This format works similar to a printf format, with the following meaning:
 
-  %c   the category of the item, \"Diary\" for entries from the diary, 
+  %c   the category of the item, \"Diary\" for entries from the diary,
        or as given by the CATEGORY keyword or derived from the file name
   %i   the icon category of the item, see `org-agenda-category-icon-alist'
   %T   the last tag of the item (ignore inherited tags, which come first)
@@ -1408,10 +1408,10 @@ contain two additional characters:  a question mark just after the `%'
 and a whitespace/punctuation character just before the final letter.
 
 If the first character after `%' is a question mark, the entire field
-will only be included if the corresponding value applies to the current 
-entry.  This is useful for fields which should have fixed width when 
-present, but zero width when absent.  For example, \"%?-12t\" will 
-result in a 12 character time field if a time of the day is specified, 
+will only be included if the corresponding value applies to the current
+entry.  This is useful for fields which should have fixed width when
+present, but zero width when absent.  For example, \"%?-12t\" will
+result in a 12 character time field if a time of the day is specified,
 but will completely disappear in entries which do not contain a time.
 
 If there is punctuation or whitespace character just before the final
@@ -1420,7 +1420,7 @@ the value is not empty.  For example, the format \"%-12:c\" leads to
 \"Diary: \" if the category is \"Diary\".  If the category were be
 empty, no additional colon would be inserted.
 
-The default value for the agenda sublist is \"  %-12:c%?-12t% s\", 
+The default value for the agenda sublist is \"  %-12:c%?-12t% s\",
 which means:
 
 - Indent the line with two space characters
@@ -1697,7 +1697,7 @@ For example, this value makes those two functions available:
     (?C bulk-cut))
 
 With selected entries in an agenda buffer, `B R' will call
-the custom function `set-category' on the selected entries.  
+the custom function `set-category' on the selected entries.
 Note that functions in this alist don't need to be quoted."
   :type 'alist
   :group 'org-agenda)
@@ -5003,9 +5003,9 @@ See also the user option `org-agenda-clock-consistency-checks'."
                      "\\(-\\{1,3\\}\\(\\[.*?\\]\\)\\)?")) ; group 3 is second
          (tlstart 0.)
          (tlend 0.)
-         (maxtime (org-hh:mm-string-to-minutes 
+         (maxtime (org-hh:mm-string-to-minutes
                    (or (plist-get pl :max-duration) "24:00")))
-         (mintime (org-hh:mm-string-to-minutes 
+         (mintime (org-hh:mm-string-to-minutes
                    (or (plist-get pl :min-duration) 0)))
          (maxgap  (org-hh:mm-string-to-minutes
                    ;; default 30:00 means never complain
diff --git a/lisp/progmodes/compile.el b/lisp/progmodes/compile.el
index 156c90159cd..3dba1af515a 100644
--- a/lisp/progmodes/compile.el
+++ b/lisp/progmodes/compile.el
@@ -157,7 +157,7 @@ of[ \t]+\"?\\([a-zA-Z]?:?[^\":\n]+\\)\"?:" 3 2 nil (1))
 
     (python-tracebacks-and-caml
      "^[ \t]*File \\(\"?\\)\\([^,\" \n\t<>]+\\)\\1, lines? \\([0-9]+\\)-?\\([0-9]+\\)?\\(?:$\\|,\
-\\(?: characters? \\([0-9]+\\)-?\\([0-9]+\\)?:\\)?\\([ \n]Warning:\\)?\\)"
+\\(?: characters? \\([0-9]+\\)-?\\([0-9]+\\)?:\\)?\\([ \n]Warning\\(?: [0-9]+\\)?:\\)?\\)"
      2 (3 . 4) (5 . 6) (7))
 
     (comma
@@ -1056,7 +1056,7 @@ FMTS is a list of format specs for transforming the file name.
           (cadr (compilation--file-struct->loc-tree file-struct)))
          (marker
           (if marker-line (compilation--loc->marker (cadr marker-line))))
-         (compilation-error-screen-columns compilation-error-screen-columns)
+         (screen-columns compilation-error-screen-columns)
          end-marker loc end-loc)
     (if (not (and marker (marker-buffer marker)))
         (setq marker nil)               ; no valid marker for this file
@@ -1064,16 +1064,21 @@ FMTS is a list of format specs for transforming the file name.
       (catch 'marker                    ; find nearest loc, at least one exists
         (dolist (x (cddr (compilation--file-struct->loc-tree
                           file-struct)))        ; Loop over remaining lines.
-          (if (> (car x) loc)           ; still bigger
+          (if (> (car x) loc)           ; Still bigger.
               (setq marker-line x)
             (if (> (- (or (car marker-line) 1) loc)
-                   (- loc (car x)))     ; current line is nearer
+                   (- loc (car x)))     ; Current line is nearer.
                 (setq marker-line x))
             (throw 'marker t))))
       (setq marker (compilation--loc->marker (cadr marker-line))
             marker-line (or (car marker-line) 1))
       (with-current-buffer (marker-buffer marker)
-        (save-excursion
+        (let ((screen-columns
+               ;; Obey the compilation-error-screen-columns of the target
+               ;; buffer if its major mode set it buffer-locally.
+               (if (local-variable-p 'compilation-error-screen-columns)
+                   compilation-error-screen-columns screen-columns)))
+          (save-excursion
           (save-restriction
             (widen)
             (goto-char (marker-position marker))
@@ -1081,17 +1086,15 @@ FMTS is a list of format specs for transforming the file name.
               (beginning-of-line (- (or end-line line) marker-line -1))
               (if (or (null end-col) (< end-col 0))
                   (end-of-line)
-                (compilation-move-to-column
-                 end-col compilation-error-screen-columns))
+                (compilation-move-to-column end-col screen-columns))
               (setq end-marker (point-marker)))
             (beginning-of-line (if end-line
                                    (- line end-line -1)
                                  (- loc marker-line -1)))
             (if col
-                (compilation-move-to-column
-                 col compilation-error-screen-columns)
+                (compilation-move-to-column col screen-columns)
               (forward-to-indentation 0))
-            (setq marker (point-marker))))))
+            (setq marker (point-marker)))))))
 
     (setq loc (compilation-assq line (compilation--file-struct->loc-tree
                                       file-struct)))
@@ -2266,7 +2269,7 @@ This is the value of `next-error-function' in Compilation buffers."
   (interactive "p")
   (when reset
     (setq compilation-current-error nil))
-  (let* ((columns compilation-error-screen-columns) ; buffer's local value
+  (let* ((screen-columns compilation-error-screen-columns)
          (last 1)
          (msg (compilation-next-error (or n 1) nil
                                       (or compilation-current-error
@@ -2301,29 +2304,34 @@ This is the value of `next-error-function' in Compilation buffers."
            marker
            (caar (compilation--loc->file-struct loc))
            (cadr (car (compilation--loc->file-struct loc))))
-        (save-restriction
-          (widen)
-          (goto-char (point-min))
-          ;; Treat file's found lines in forward order, 1 by 1.
-          (dolist (line (reverse (cddr (compilation--loc->file-struct loc))))
-            (when (car line)            ; else this is a filename w/o a line#
-              (beginning-of-line (- (car line) last -1))
-              (setq last (car line)))
-            ;; Treat line's found columns and store/update a marker for each.
-            (dolist (col (cdr line))
-              (if (compilation--loc->col col)
-                  (if (eq (compilation--loc->col col) -1)
-                      ;; Special case for range end.
-                      (end-of-line)
-                    (compilation-move-to-column (compilation--loc->col col)
-                                                columns))
-                (beginning-of-line)
-                (skip-chars-forward " \t"))
-              (if (compilation--loc->marker col)
-                  (set-marker (compilation--loc->marker col) (point))
-                (setf (compilation--loc->marker col) (point-marker)))
-              ;; (setf (compilation--loc->timestamp col) timestamp)
-              )))))
+        (let ((screen-columns
+               ;; Obey the compilation-error-screen-columns of the target
+               ;; buffer if its major mode set it buffer-locally.
+               (if (local-variable-p 'compilation-error-screen-columns)
+                   compilation-error-screen-columns screen-columns)))
+          (save-restriction
+            (widen)
+            (goto-char (point-min))
+            ;; Treat file's found lines in forward order, 1 by 1.
+            (dolist (line (reverse (cddr (compilation--loc->file-struct loc))))
+              (when (car line)          ; else this is a filename w/o a line#
+                (beginning-of-line (- (car line) last -1))
+                (setq last (car line)))
+              ;; Treat line's found columns and store/update a marker for each.
+              (dolist (col (cdr line))
+                (if (compilation--loc->col col)
+                    (if (eq (compilation--loc->col col) -1)
+                        ;; Special case for range end.
+                        (end-of-line)
+                      (compilation-move-to-column (compilation--loc->col col)
+                                                  screen-columns))
+                  (beginning-of-line)
+                  (skip-chars-forward " \t"))
+                (if (compilation--loc->marker col)
+                    (set-marker (compilation--loc->marker col) (point))
+                  (setf (compilation--loc->marker col) (point-marker)))
+                ;; (setf (compilation--loc->timestamp col) timestamp)
+                ))))))
     (compilation-goto-locus marker (compilation--loc->marker loc)
                             (compilation--loc->marker end-loc))
     (setf (compilation--loc->visited loc) t)))
diff --git a/lisp/progmodes/cperl-mode.el b/lisp/progmodes/cperl-mode.el
index ad3b777977c..a79d1a2c064 100644
--- a/lisp/progmodes/cperl-mode.el
+++ b/lisp/progmodes/cperl-mode.el
@@ -6481,7 +6481,7 @@ are CPerl, PerlStyle, GNU, K&R, BSD, C++ and Whitesmith.
 The current value of style is memorized (unless there is a memorized
 data already), may be restored by `cperl-set-style-back'.
 
-Chosing \"Current\" style will not change style, so this may be used for
+Choosing \"Current\" style will not change style, so this may be used for
 side-effect of memorizing only.  Examples in `cperl-style-examples'."
   (interactive
    (let ((list (mapcar (function (lambda (elt) (list (car elt))))
diff --git a/lisp/progmodes/delphi.el b/lisp/progmodes/delphi.el
index e8e2f8ffbf0..e513b617022 100644
--- a/lisp/progmodes/delphi.el
+++ b/lisp/progmodes/delphi.el
@@ -1959,10 +1959,6 @@ comment block.  If not in a // comment, just does a normal newline."
     kmap)
   "Keymap used in Delphi mode.")
 
-(defvar delphi-mode-syntax-table nil
-  "Delphi mode's syntax table.  It is just a standard syntax table.
-This is ok since we do our own keyword/comment/string face coloring.")
-
 ;;;###autoload
 (define-derived-mode delphi-mode prog-mode "Delphi"
   "Major mode for editing Delphi code. \\<delphi-mode-map>
diff --git a/lisp/progmodes/gdb-mi.el b/lisp/progmodes/gdb-mi.el
index f9ddabf1552..e47ba3c92f3 100644
--- a/lisp/progmodes/gdb-mi.el
+++ b/lisp/progmodes/gdb-mi.el
@@ -1965,7 +1965,7 @@ Sets `gdb-thread-number' to new id."
   (setq gud-running t)
   ;; GDB doesn't seem to respond to -thread-info before first stop or
   ;; thread exit (even in non-stop mode), so this is useless.
-  ;; Behaviour may change in the future.
+  ;; Behavior may change in the future.
   (gdb-emit-signal gdb-buf-publisher 'update-threads))
 
 ;; -break-insert -t didn't give a reason before gdb 6.9
diff --git a/lisp/progmodes/gud.el b/lisp/progmodes/gud.el
index 7b3a2893610..944a412fb63 100644
--- a/lisp/progmodes/gud.el
+++ b/lisp/progmodes/gud.el
@@ -2155,7 +2155,7 @@ during jdb initialization depending on the value of
                    string
                    (concat "[ \t\n\r,\"" path-separator "]+")))))
 
-;; See comentary for other debugger's marker filters - there you will find
+;; See commentary for other debugger's marker filters - there you will find
 ;; important notes about STRING.
 (defun gud-jdb-marker-filter (string)
 
diff --git a/lisp/progmodes/meta-mode.el b/lisp/progmodes/meta-mode.el
index ab640c0e270..e15f765ea58 100644
--- a/lisp/progmodes/meta-mode.el
+++ b/lisp/progmodes/meta-mode.el
@@ -27,53 +27,17 @@
 ;;
 ;; This Emacs Lisp package provides a major mode for editing Metafont
 ;; or MetaPost sources.  It includes all the necessary code to set up
-;; a major mode including an approriate syntax table, keymap, and a
+;; a major mode including an appropriate syntax table, keymap, and a
 ;; mode-specific pull-down menu.  It also provides a sophisticated set
 ;; of font-lock patterns, a fancy indentation function adapted from
 ;; AUCTeX's latex.el, and some basic mode-specific editing functions
 ;; such as functions to move to the beginning or end of the enclosing
 ;; environment, or to mark, re-indent, or comment-out environments.
 ;; On the other hand, it doesn't yet provide any functionality for
-;; running Metafont or MetaPost in a shell buffer form within Emacs,
+;; running Metafont or MetaPost in a shell buffer from within Emacs,
 ;; but such functionality might be added later, either as part of this
 ;; package or as a separate Emacs Lisp package.
 
-;; Installation:
-;;
-;; An interface to running Metafont or MetaPost as a shell process
-;; from within Emacs is currently under development as a separate
-;; Emacs Lisp package (meta-buf.el).  In order to have that package
-;; loaded automatically when first entering Metafont or MetaPost mode,
-;; you might use the load-hook provided in this package by adding
-;; these lines to your startup file:
-;;
-;;  (add-hook 'meta-mode-load-hook
-;;            (lambda () (require 'meta-buf)))
-;;
-;; The add-on package loaded this way may in turn make use of the
-;; mode-hooks provided in this package to activate additional features
-;; when entering Metafont or MetaPost mode.
-
-;; Font Lock Support:
-;;
-;; If you are using global-font-lock-mode (introduced in Emacs 19.31),
-;; fontification in Metafont and/or MetaPost mode will be activated
-;; automatically.  To speed up fontification for the rather complex
-;; patterns used in these modes, it may be a good idea to activate
-;; lazy-lock as a font-lock-support-mode (introduced in Emacs 19.32)
-;; by adding these lines to your startup file:
-;;
-;;  (global-font-lock-mode t)
-;;  (setq font-lock-support-mode 'lazy-lock-mode)
-;;
-;; If you are using an older version of Emacs, which doesn't provide
-;; global-font-lock-mode or font-lock-support-mode, you can also
-;; activate fontification in Metafont and/or MetaPost mode by adding
-;; the following lines to your startup file:
-;;
-;;  (add-hook 'meta-common-mode-hook 'turn-on-font-lock)
-;;  (add-hook 'meta-common-mode-hook 'turn-on-lazy-lock)
-
 ;; Customization:
 ;;
 ;; Following the usual Emacs Lisp coding conventions, the major modes
@@ -88,10 +52,6 @@
 
 ;; Availability:
 ;;
-;; This package is currently available via my "TeX Software" WWW page:
-;;
-;;  http://www.thphy.uni-duesseldorf.de/~vieth/subjects/tex/software.html
-;;
 ;; As of this version 1.0, this package will be uploaded to CTAN
 ;; archives, where it shall find a permanent home, presumably in
 ;; tex-archive/support/emacs-modes.  It will also be submitted for
@@ -104,7 +64,7 @@
 ;; v 0.2 -- 1997/02/03  UV  Improved and debugged font-lock patterns.
 ;;                          Added indent-line-function for TAB.
 ;; v 0.3 -- 1997/02/17  UV  Improved font-lock patterns and syntax table.
-;;                          Improved and debbuged indentation function.
+;;                          Improved and debugged indentation function.
 ;; v 0.4 -- 1997/02/18  UV  Added functions to indent regions for M-C-q,
 ;;                          also added a preliminary mode-specific menu.
 ;; v 0.5 -- 1997/02/19  UV  Added functions to skip to next or previous
@@ -513,13 +473,13 @@ If the list was changed, sort the list and remove duplicates first."
   :group 'meta-font)
 
 (defcustom meta-right-comment-regexp nil
-  "Regexp matching comments that should be placed to the right margin."
+  "Regexp matching comments that should be placed on the right margin."
   :type '(choice regexp
                  (const :tag "None" nil))
   :group 'meta-font)
 
 (defcustom meta-ignore-comment-regexp "%[^%]"
-  "Regexp matching comments that whose indentation should not be touched."
+  "Regexp matching comments whose indentation should not be touched."
   :type 'regexp
   :group 'meta-font)
 
diff --git a/lisp/progmodes/python.el b/lisp/progmodes/python.el
index 38bf9552b2a..8615400bf6a 100644
--- a/lisp/progmodes/python.el
+++ b/lisp/progmodes/python.el
@@ -948,22 +948,12 @@ Finds end of innermost nested class or method definition."
   "Go to start of current statement.
 Accounts for continuation lines, multi-line strings, and
 multi-line bracketed expressions."
-  (beginning-of-line)
-  (python-beginning-of-string)
-  (let (point)
-    (while (and (python-continuation-line-p)
-                (if point
-                    (< (point) point)
-                  t))
-      (beginning-of-line)
+  (while
       (if (python-backslash-continuation-line-p)
-          (progn
-            (forward-line -1)
-            (while (python-backslash-continuation-line-p)
-              (forward-line -1)))
-        (python-beginning-of-string)
-        (python-skip-out))
-      (setq point (point))))
+          (progn (forward-line -1) t)
+        (beginning-of-line)
+        (or (python-beginning-of-string)
+            (python-skip-out))))
   (back-to-indentation))
 
 (defun python-skip-out (&optional forward syntax)
@@ -971,6 +961,7 @@ multi-line bracketed expressions."
 Skip forward if FORWARD is non-nil, else backward.
 If SYNTAX is non-nil it is the state returned by `syntax-ppss' at point.
 Return non-nil if and only if skipping was done."
+  ;; FIXME: Use syntax-ppss-toplevel-pos.
   (let ((depth (syntax-ppss-depth (or syntax (syntax-ppss))))
         (forward (if forward -1 1)))
     (unless (zerop depth)
diff --git a/lisp/progmodes/vhdl-mode.el b/lisp/progmodes/vhdl-mode.el
index d7aa82aee1b..2f06afaa5ef 100644
--- a/lisp/progmodes/vhdl-mode.el
+++ b/lisp/progmodes/vhdl-mode.el
@@ -3510,7 +3510,7 @@ STRING are replaced by `-' and substrings are converted to lower case."
                         menu-list))
             (setq comp-alist (cdr comp-alist)))
           (setq menu-list (nreverse menu-list))
-          (vhdl-menu-split menu-list "Compler")))
+          (vhdl-menu-split menu-list "Compiler")))
       ["Use Local Error Regexp"
        (customize-set-variable 'vhdl-compile-use-local-error-regexp
                                (not vhdl-compile-use-local-error-regexp))
diff --git a/lisp/rot13.el b/lisp/rot13.el
index 89b687efdc6..d4885395900 100644
--- a/lisp/rot13.el
+++ b/lisp/rot13.el
@@ -32,7 +32,7 @@
 ;; This hack is mainly to show off the char table stuff.
 ;;
 ;; New entry points, `rot13', `rot13-string', and `rot13-region' that
-;; performs Ceasar cipher encrypt/decrypt on buffers and strings, was
+;; performs Caesar cipher encrypt/decrypt on buffers and strings, was
 ;; added by Simon Josefsson.
 
 ;;; Code:
diff --git a/lisp/subr.el b/lisp/subr.el
index d5120826812..1cd6598eeb5 100644
--- a/lisp/subr.el
+++ b/lisp/subr.el
@@ -1797,30 +1797,29 @@ This function makes or adds to an entry on `after-load-alist'."
       (push elt after-load-alist))
     ;; Make sure `form' is evalled in the current lexical/dynamic code.
     (setq form `(funcall ',(eval `(lambda () ,form) lexical-binding)))
-    (when (symbolp regexp-or-feature)
-      ;; For features, the after-load-alist elements get run when `provide' is
-      ;; called rather than at the end of the file.  So add an indirection to
-      ;; make sure that `form' is really run "after-load" in case the provide
-      ;; call happens early.
-      (setq form
-            `(when load-file-name
-               (let ((fun (make-symbol "eval-after-load-helper")))
-                 (fset fun `(lambda (file)
-                              (if (not (equal file ',load-file-name))
-                                  nil
-                                (remove-hook 'after-load-functions ',fun)
-                                ,',form)))
-                 (add-hook 'after-load-functions fun)))))
-    ;; Add FORM to the element unless it's already there.
-    (unless (member form (cdr elt))
-      (nconc elt (purecopy (list form))))
-
     ;; Is there an already loaded file whose name (or `provide' name)
     ;; matches FILE?
-    (if (if (stringp file)
-            (load-history-filename-element regexp-or-feature)
-          (featurep file))
-        (eval form))))
+    (prog1 (if (if (stringp file)
+                   (load-history-filename-element regexp-or-feature)
+                 (featurep file))
+               (eval form))
+      (when (symbolp regexp-or-feature)
+        ;; For features, the after-load-alist elements get run when `provide' is
+        ;; called rather than at the end of the file.  So add an indirection to
+        ;; make sure that `form' is really run "after-load" in case the provide
+        ;; call happens early.
+        (setq form
+              `(when load-file-name
+                 (let ((fun (make-symbol "eval-after-load-helper")))
+                   (fset fun `(lambda (file)
+                                (if (not (equal file ',load-file-name))
+                                    nil
+                                  (remove-hook 'after-load-functions ',fun)
+                                  ,',form)))
+                   (add-hook 'after-load-functions fun)))))
+      ;; Add FORM to the element unless it's already there.
+      (unless (member form (cdr elt))
+        (nconc elt (purecopy (list form)))))))
 
 (defvar after-load-functions nil
   "Special hook run after loading a file.
diff --git a/lisp/textmodes/reftex-parse.el b/lisp/textmodes/reftex-parse.el
index b0f22085064..4d6b5e5fb83 100644
--- a/lisp/textmodes/reftex-parse.el
+++ b/lisp/textmodes/reftex-parse.el
@@ -443,7 +443,7 @@ of master file."
 (defvar test-dummy)
 (defun reftex-index-info (file)
   ;; Return an index entry for the current match.
-  ;; Carefull: This function expects the match-data to be still in place!
+  ;; Careful: This function expects the match-data to be still in place!
   (catch 'exit
     (let* ((macro (reftex-match-string 10))
            (bom (match-beginning 10))
diff --git a/lisp/textmodes/rst.el b/lisp/textmodes/rst.el
index f9fda7e0a74..0ce71c25ad7 100644
--- a/lisp/textmodes/rst.el
+++ b/lisp/textmodes/rst.el
@@ -476,8 +476,8 @@ for modes derived from Text mode, like Mail mode."
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Section Decoration Adjusment
-;; ============================
+;; Section Decoration Adjustment
+;; =============================
 ;;
 ;; The following functions implement a smart automatic title sectioning feature.
 ;; The idea is that with the cursor sitting on a section title, we try to get as
diff --git a/lisp/url/url-http.el b/lisp/url/url-http.el
index 557ef33919c..6e192cd5aae 100644
--- a/lisp/url/url-http.el
+++ b/lisp/url/url-http.el
@@ -257,7 +257,7 @@ request.")
     (if (not (equal extra-headers ""))
         (setq extra-headers (concat extra-headers "\r\n")))
 
-    ;; This was done with a call to `format'.  Concatting parts has
+    ;; This was done with a call to `format'.  Concatenating parts has
     ;; the advantage of keeping the parts of each header together and
     ;; allows us to elide null lines directly, at the cost of making
     ;; the layout less clear.
diff --git a/lisp/vc/vc-svn.el b/lisp/vc/vc-svn.el
index 7362258a42d..dc4e179e060 100644
--- a/lisp/vc/vc-svn.el
+++ b/lisp/vc/vc-svn.el
@@ -263,8 +263,8 @@ RESULT is a list of conses (FILE . STATE) for directory DIR."
 (defun vc-svn-create-repo ()
   "Create a new SVN repository."
   (vc-do-command "*vc*" 0 "svnadmin" '("create" "SVN"))
-  (vc-do-command "*vc*" 0 vc-svn-program '(".")
-                 "checkout" (concat "file://" default-directory "SVN")))
+  (vc-svn-command "*vc*" 0 "." "checkout"
+                  (concat "file://" default-directory "SVN")))
 
 (defun vc-svn-register (files &optional rev comment)
   "Register FILES into the SVN version-control system.
@@ -334,7 +334,6 @@ This is only possible if SVN is responsible for FILE's directory.")
     ;; Check out a particular version (or recreate the file).
     (vc-file-setprop file 'vc-working-revision nil)
     (apply 'vc-svn-command nil 0 file
-           "--non-interactive"          ; bug#4280
            "update"
            (cond
             ((null rev) "-rBASE")
@@ -373,7 +372,7 @@ The changes are between FIRST-VERSION and SECOND-VERSION."
   (message "Merging changes into %s..." file)
   ;; (vc-file-setprop file 'vc-working-revision nil)
   (vc-file-setprop file 'vc-checkout-time 0)
-  (vc-svn-command nil 0 file "--non-interactive" "update") ; see bug#7152
+  (vc-svn-command nil 0 file "update")
   ;; Analyze the merge result reported by SVN, and set
   ;; file properties accordingly.
   (with-current-buffer (get-buffer "*vc*")
@@ -425,7 +424,7 @@ This is only supported if the repository access method is either file://
 or svn+ssh://."
   (let (tempfile host remotefile directory fileurl-p)
     (with-temp-buffer
-      (vc-do-command (current-buffer) 0 vc-svn-program nil "info")
+      (vc-svn-command (current-buffer) 0 nil "info")
       (goto-char (point-min))
       (unless (re-search-forward "Repository Root: \\(file://\\(/.*\\)\\)\\|\\(svn\\+ssh://\\([^/]+\\)\\(/.*\\)\\)" nil t)
         (error "Repository information is unavailable"))
@@ -581,12 +580,19 @@ NAME is assumed to be a URL."
 (defun vc-svn-command (buffer okstatus file-or-list &rest flags)
   "A wrapper around `vc-do-command' for use in vc-svn.el.
 The difference to vc-do-command is that this function always invokes `svn',
-and that it passes `vc-svn-global-switches' to it before FLAGS."
-  (apply 'vc-do-command (or buffer "*vc*") okstatus vc-svn-program file-or-list
-         (if (stringp vc-svn-global-switches)
+and that it passes \"--non-interactive\" and `vc-svn-global-switches' to
+it before FLAGS."
+  ;; Might be nice if svn defaulted to non-interactive if stdin not tty.
+  ;; http://svn.haxx.se/dev/archive-2008-05/0762.shtml
+  ;; http://svn.haxx.se/dev/archive-2009-04/0094.shtml
+  ;; Maybe newer ones do?
+  (or (member "--non-interactive"
+              (setq flags (if (stringp vc-svn-global-switches)
              (cons vc-svn-global-switches flags)
-           (append vc-svn-global-switches
-                   flags))))
+                            (append vc-svn-global-switches flags))))
+      (setq flags (cons "--non-interactive" flags)))
+  (apply 'vc-do-command (or buffer "*vc*") okstatus vc-svn-program file-or-list
+         flags))
 
 (defun vc-svn-repository-hostname (dirname)
   (with-temp-buffer
diff --git a/lisp/window.el b/lisp/window.el
index 1b51bde36bd..ecd4a62b093 100644
--- a/lisp/window.el
+++ b/lisp/window.el
@@ -68,19 +68,19 @@ are not altered by this macro (unless they are altered in BODY)."
 ;; they don't substitute the selected window for nil), and they return
 ;; nil when WINDOW doesn't have a parent (like a frame's root window or
 ;; a minibuffer window).
-(defsubst window-right (window)
+(defun window-right (window)
   "Return WINDOW's right sibling.
 Return nil if WINDOW is the root window of its frame.  WINDOW can
 be any window."
   (and window (window-parent window) (window-next-sibling window)))
 
-(defsubst window-left (window)
+(defun window-left (window)
   "Return WINDOW's left sibling.
 Return nil if WINDOW is the root window of its frame.  WINDOW can
 be any window."
   (and window (window-parent window) (window-prev-sibling window)))
 
-(defsubst window-child (window)
+(defun window-child (window)
   "Return WINDOW's first child window."
   (or (window-top-child window) (window-left-child window)))
 
@@ -100,7 +100,7 @@ be any window."
       (setq window (window-next-sibling window))))
   window)
 
-(defsubst window-valid-p (object)
+(defun window-valid-p (object)
   "Return t if OBJECT denotes a live window or internal window.
 Otherwise, return nil; this includes the case where OBJECT is a
 deleted window."
@@ -108,7 +108,7 @@ deleted window."
        (or (window-buffer object) (window-child object))
        t))
 
-(defsubst window-normalize-buffer (buffer-or-name)
+(defun window-normalize-buffer (buffer-or-name)
   "Return buffer specified by BUFFER-OR-NAME.
 BUFFER-OR-NAME must be either a buffer or a string naming a live
 buffer and defaults to the current buffer."
@@ -123,7 +123,7 @@ buffer and defaults to the current buffer."
    (t
     (error "No such buffer %s" buffer-or-name))))
 
-(defsubst window-normalize-frame (frame)
+(defun window-normalize-frame (frame)
   "Return frame specified by FRAME.
 FRAME must be a live frame and defaults to the selected frame."
   (if frame
@@ -132,7 +132,7 @@ FRAME must be a live frame and defaults to the selected frame."
         (error "%s is not a live frame" frame))
     (selected-frame)))
 
-(defsubst window-normalize-window (window &optional live-only)
+(defun window-normalize-window (window &optional live-only)
   "Return window specified by WINDOW.
 If WINDOW is nil, return `selected-window'.
 If WINDOW is a live window or internal window, return WINDOW;
@@ -195,7 +195,7 @@ narrower, explictly specify the SIZE argument of that function."
   :version "24.1"
   :group 'windows)
 
-(defsubst window-combined-p (&optional window horizontal)
+(defun window-combined-p (&optional window horizontal)
   "Return non-nil if WINDOW has siblings in a given direction.
 If WINDOW is omitted or nil, it defaults to the selected window.
 
@@ -211,11 +211,11 @@ horizontal window combination."
              (window-left-child parent)
            (window-top-child parent)))))
 
-(defun window-combinations (&optional window horizontal)
-  "Return largest number of vertically arranged subwindows of WINDOW.
+(defun window-combinations (window &optional horizontal)
+  "Return largest number of windows vertically arranged within WINDOW.
 If WINDOW is omitted or nil, it defaults to the selected window.
 If HORIZONTAL is non-nil, return the largest number of
-horizontally arranged subwindows of WINDOW."
+windows horizontally arranged within WINDOW."
   (setq window (window-normalize-window window))
   (cond
    ((window-live-p window)
@@ -225,7 +225,7 @@ horizontally arranged subwindows of WINDOW."
         (window-left-child window)
       (window-top-child window))
     ;; If WINDOW is iso-combined, return the sum of the values for all
-    ;; subwindows of WINDOW.
+    ;; child windows of WINDOW.
     (let ((child (window-child window))
           (count 0))
       (while child
@@ -236,7 +236,7 @@ horizontally arranged subwindows of WINDOW."
       count))
    (t
     ;; If WINDOW is not iso-combined, return the maximum value of any
-    ;; subwindow of WINDOW.
+    ;; child window of WINDOW.
     (let ((child (window-child window))
           (count 1))
       (while child
@@ -279,14 +279,16 @@ unpredictable."
      proc (frame-root-window walk-window-tree-frame) any)))
 
 (defun walk-window-subtree (proc &optional window any)
-  "Run function PROC on each live subwindow of WINDOW.
+  "Run function PROC on the subtree of windows rooted at WINDOW.
 WINDOW defaults to the selected window.  PROC must be a function
-with one argument - a window.  ANY, if non-nil means to run PROC
-on all live and internal subwindows of WINDOW.
+with one argument - a window.  By default, run PROC only on live
+windows of the subtree.  If the optional argument ANY is non-nil,
+run PROC on all live and internal windows of the subtree.  If
+WINDOW is live, run PROC on WINDOW only.
 
 This function performs a pre-order, depth-first traversal of the
-window tree rooted at WINDOW.  If PROC changes that window tree,
-the result is unpredictable."
+subtree rooted at WINDOW.  If PROC changes that tree, the result
+is unpredictable."
   (setq window (window-normalize-window window))
   (walk-window-tree-1 proc window any t))
 
@@ -381,9 +383,9 @@ WINDOW must be an internal window.  Return WINDOW."
 (defun window-atom-check (&optional frame)
   "Check atomicity of all windows on FRAME.
 FRAME defaults to the selected frame.  If an atomic window is
-wrongly configured, reset the atomicity of all its subwindows to
-nil.  An atomic window is wrongly configured if it has no
-subwindows or one of its subwindows is not atomic."
+wrongly configured, reset the atomicity of all its windows on
+FRAME to nil.  An atomic window is wrongly configured if it has
+no child windows or one of its child windows is not atomic."
   (window-atom-check-1 (frame-root-window frame)))
 
 ;; Side windows.
@@ -528,7 +530,7 @@ unless it has no other choice \(like when deleting a neighboring
 window).")
 (make-variable-buffer-local 'window-size-fixed)
 
-(defsubst window-size-ignore (window ignore)
+(defun window-size-ignore (window ignore)
   "Return non-nil if IGNORE says to ignore size restrictions for WINDOW."
   (if (window-valid-p ignore) (eq window ignore) ignore))
 
@@ -555,13 +557,13 @@ restrictions for that window only."
           ;; WINDOW is an internal window.
           (if (window-combined-p sub horizontal)
               ;; The minimum size of an iso-combination is the sum of
-              ;; the minimum sizes of its subwindows.
+              ;; the minimum sizes of its child windows.
               (while sub
                 (setq value (+ value
                                (window-min-size-1 sub horizontal ignore)))
                 (setq sub (window-right sub)))
             ;; The minimum size of an ortho-combination is the maximum of
-            ;; the minimum sizes of its subwindows.
+            ;; the minimum sizes of its child windows.
             (while sub
               (setq value (max value
                                (window-min-size-1 sub horizontal ignore)))
@@ -619,8 +621,9 @@ Optional argument HORIZONTAL non-nil means return DELTA if DELTA
 columns can be added to WINDOW.  A return value of zero means
 that no lines (or columns) can be added to WINDOW.
 
-This function looks only at WINDOW and its subwindows.  The
-function `window-resizable' looks at other windows as well.
+This function looks only at WINDOW and, recursively, its child
+windows.  The function `window-resizable' looks at other windows
+as well.
 
 DELTA positive means WINDOW shall be enlarged by DELTA lines or
 columns.  If WINDOW cannot be enlarged by DELTA lines or columns
@@ -652,7 +655,7 @@ restrictions for that window only."
       delta))
    (t 0)))
 
-(defsubst window-sizable-p (window delta &optional horizontal ignore)
+(defun window-sizable-p (window delta &optional horizontal ignore)
   "Return t if WINDOW can be resized by DELTA lines.
 For the meaning of the arguments of this function see the
 doc-string of `window-sizable'."
@@ -668,24 +671,24 @@ doc-string of `window-sizable'."
       (if sub
           ;; WINDOW is an internal window.
           (if (window-combined-p sub horizontal)
-              ;; An iso-combination is fixed size if all its subwindows
-              ;; are fixed-size.
+              ;; An iso-combination is fixed size if all its child
+              ;; windows are fixed-size.
               (progn
                 (while sub
                   (unless (window-size-fixed-1 sub horizontal)
-                    ;; We found a non-fixed-size subwindow, so WINDOW's
-                    ;; size is not fixed.
+                    ;; We found a non-fixed-size child window, so
+                    ;; WINDOW's size is not fixed.
                     (throw 'fixed nil))
                   (setq sub (window-right sub)))
-                ;; All subwindows are fixed-size, so WINDOW's size is
+                ;; All child windows are fixed-size, so WINDOW's size is
                 ;; fixed.
                 (throw 'fixed t))
             ;; An ortho-combination is fixed-size if at least one of its
-            ;; subwindows is fixed-size.
+            ;; child windows is fixed-size.
             (while sub
               (when (window-size-fixed-1 sub horizontal)
-                ;; We found a fixed-size subwindow, so WINDOW's size is
-                ;; fixed.
+                ;; We found a fixed-size child window, so WINDOW's size
+                ;; is fixed.
                 (throw 'fixed t))
               (setq sub (window-right sub))))
         ;; WINDOW is a live window.
@@ -701,8 +704,8 @@ window.  Optional argument HORIZONTAL non-nil means return
 non-nil if WINDOW's width is fixed.
 
 If this function returns nil, this does not necessarily mean that
-WINDOW can be resized in the desired direction.  The functions
-`window-resizable' and `window-resizable-p' will tell that."
+WINDOW can be resized in the desired direction.  The function
+`window-resizable' can tell that."
   (window-size-fixed-1
    (window-normalize-window window) horizontal))
 
@@ -717,8 +720,8 @@ WINDOW can be resized in the desired direction.  The functions
       (catch 'done
         (if (window-combined-p sub horizontal)
             ;; In an iso-combination throw DELTA if we find at least one
-            ;; subwindow and that subwindow is either not of fixed-size
-            ;; or we can ignore fixed-sizeness.
+            ;; child window and that window is either not fixed-size or
+            ;; we can ignore fixed-sizeness.
             (let ((skip (eq trail 'after)))
               (while sub
                 (cond
@@ -728,11 +731,11 @@ WINDOW can be resized in the desired direction.  The functions
                  ((and (not (window-size-ignore window ignore))
                        (window-size-fixed-p sub horizontal)))
                  (t
-                  ;; We found a non-fixed-size subwindow.
+                  ;; We found a non-fixed-size child window.
                   (throw 'done delta)))
                 (setq sub (window-right sub))))
           ;; In an ortho-combination set DELTA to the minimum value by
-          ;; which other subwindows can shrink.
+          ;; which other child windows can shrink.
           (while sub
             (unless (eq sub window)
               (setq delta
@@ -768,8 +771,8 @@ Optional argument NOUP non-nil means don't go up in the window
 tree but try to enlarge windows within WINDOW's combination only.
 
 Optional argument NODOWN non-nil means don't check whether WINDOW
-itself \(and its subwindows) can be shrunk; check only whether at
-least one other windows can be enlarged appropriately."
+itself \(and its child windows) can be shrunk; check only whether
+at least one other window can be enlarged appropriately."
   (setq window (window-normalize-window window))
   (let ((size (window-total-size window horizontal))
         (minimum (window-min-size window horizontal ignore)))
@@ -797,7 +800,7 @@ least one other windows can be enlarged appropriately."
       (catch 'fixed
         (if (window-combined-p sub horizontal)
             ;; For an iso-combination calculate how much we can get from
-            ;; other subwindows.
+            ;; other child windows.
             (let ((skip (eq trail 'after)))
               (while sub
                 (cond
@@ -811,7 +814,7 @@ least one other windows can be enlarged appropriately."
                               (window-min-size sub horizontal ignore))))))
                 (setq sub (window-right sub))))
           ;; For an ortho-combination throw DELTA when at least one
-          ;; subwindow is fixed-size.
+          ;; child window is fixed-size.
           (while sub
             (when (and (not (eq sub window))
                        (not (window-size-ignore sub ignore))
@@ -850,8 +853,8 @@ tree but try to obtain the entire space from windows within
 WINDOW's combination.
 
 Optional argument NODOWN non-nil means do not check whether
-WINDOW itself \(and its subwindows) can be enlarged; check only
-whether other windows can be shrunk appropriately."
+WINDOW itself \(and its child windows) can be enlarged; check
+only whether other windows can be shrunk appropriately."
   (setq window (window-normalize-window window))
   (if (and (not (window-size-ignore window ignore))
            (not nodown) (window-size-fixed-p window horizontal))
@@ -862,14 +865,14 @@ whether other windows can be shrunk appropriately."
     (window-max-delta-1 window 0 horizontal ignore trail noup)))
 
 ;; Make NOUP also inhibit the min-size check.
-(defun window-resizable (window delta &optional horizontal ignore trail noup nodown)
+(defun window--resizable (window delta &optional horizontal ignore trail noup nodown)
   "Return DELTA if WINDOW can be resized vertically by DELTA lines.
 Optional argument HORIZONTAL non-nil means return DELTA if WINDOW
 can be resized horizontally by DELTA columns.  A return value of
 zero means that WINDOW is not resizable.
 
 DELTA positive means WINDOW shall be enlarged by DELTA lines or
-columns.  If WINDOW cannot be enlarged by DELTA lines or columns
+columns.  If WINDOW cannot be enlarged by DELTA lines or columns,
 return the maximum value in the range 0..DELTA by which WINDOW
 can be enlarged.
 
@@ -891,11 +894,12 @@ of or below WINDOW can be shrunk.  Optional argument TRAIL
 shrunk.
 
 Optional argument NOUP non-nil means don't go up in the window
-tree but try to distribute the space among the other windows
-within WINDOW's combination.
+tree but check only whether space can be obtained from (or given
+to) WINDOW's siblings.
 
-Optional argument NODOWN non-nil means don't check whether WINDOW
-and its subwindows can be resized."
+Optional argument NODOWN non-nil means don't go down in the
+window tree.  This means do not check whether resizing would
+violate size restrictions of WINDOW or its child windows."
   (setq window (window-normalize-window window))
   (cond
    ((< delta 0)
@@ -906,34 +910,58 @@ and its subwindows can be resized."
          delta))
    (t 0)))
 
-(defun window-resizable-p (window delta &optional horizontal ignore trail noup nodown)
+(defun window--resizable-p (window delta &optional horizontal ignore trail noup nodown)
   "Return t if WINDOW can be resized vertically by DELTA lines.
 For the meaning of the arguments of this function see the
-doc-string of `window-resizable'."
+doc-string of `window--resizable'."
   (setq window (window-normalize-window window))
   (if (> delta 0)
-      (>= (window-resizable window delta horizontal ignore trail noup nodown)
+      (>= (window--resizable window delta horizontal ignore trail noup nodown)
           delta)
-    (<= (window-resizable window delta horizontal ignore trail noup nodown)
+    (<= (window--resizable window delta horizontal ignore trail noup nodown)
         delta)))
 
-(defsubst window-total-height (&optional window)
-  "Return the total number of lines of WINDOW.
-WINDOW can be any window and defaults to the selected one.  The
-return value includes WINDOW's mode line and header line, if any.
-If WINDOW is internal the return value is the sum of the total
-number of lines of WINDOW's child windows if these are vertically
-combined and the height of WINDOW's first child otherwise.
+(defun window-resizable (window delta &optional horizontal ignore)
+  "Return DELTA if WINDOW can be resized vertically by DELTA lines.
+Optional argument HORIZONTAL non-nil means return DELTA if WINDOW
+can be resized horizontally by DELTA columns.  A return value of
+zero means that WINDOW is not resizable.
+
+DELTA positive means WINDOW shall be enlarged by DELTA lines or
+columns.  If WINDOW cannot be enlarged by DELTA lines or columns
+return the maximum value in the range 0..DELTA by which WINDOW
+can be enlarged.
+
+DELTA negative means WINDOW shall be shrunk by -DELTA lines or
+columns.  If WINDOW cannot be shrunk by -DELTA lines or columns,
+return the minimum value in the range DELTA..0 that can be used
+for shrinking WINDOW.
+
+Optional argument IGNORE non-nil means ignore any restrictions
+imposed by fixed size windows, `window-min-height' or
+`window-min-width' settings.  IGNORE a window means ignore
+restrictions for that window only.  IGNORE equal `safe' means
+live windows may get as small as `window-safe-min-height' lines
+and `window-safe-min-width' columns."
+  (setq window (window-normalize-window window))
+  (window--resizable window delta horizontal ignore))
 
-Note: This function does not take into account the value of
-`line-spacing' when calculating the number of lines in WINDOW."
-  (window-total-size window))
+(defun window-total-size (&optional window horizontal)
+  "Return the total height or width of window WINDOW.
+If WINDOW is omitted or nil, it defaults to the selected window.
+
+If HORIZONTAL is omitted or nil, return the total height of
+WINDOW, in lines, like `window-total-height'.  Otherwise return
+the total width, in columns, like `window-total-width'."
+  (if horizontal
+      (window-total-width window)
+    (window-total-height window)))
 
 ;; Eventually we should make `window-height' obsolete.
 (defalias 'window-height 'window-total-height)
 
 ;; See discussion in bug#4543.
-(defsubst window-full-height-p (&optional window)
+(defun window-full-height-p (&optional window)
   "Return t if WINDOW is as high as the containing frame.
 More precisely, return t if and only if the total height of
 WINDOW equals the total height of the root window of WINDOW's
@@ -943,17 +971,7 @@ one."
   (= (window-total-size window)
      (window-total-size (frame-root-window window))))
 
-(defsubst window-total-width (&optional window)
-  "Return the total number of columns of WINDOW.
-WINDOW can be any window and defaults to the selected one.  The
-return value includes any vertical dividers or scrollbars of
-WINDOW.  If WINDOW is internal, the return value is the sum of
-the total number of columns of WINDOW's child windows if these
-are horizontally combined and the width of WINDOW's first child
-otherwise."
-  (window-total-size window t))
-
-(defsubst window-full-width-p (&optional window)
+(defun window-full-width-p (&optional window)
   "Return t if WINDOW is as wide as the containing frame.
 More precisely, return t if and only if the total width of WINDOW
 equals the total width of the root window of WINDOW's frame.
@@ -962,40 +980,17 @@ WINDOW can be any window and defaults to the selected one."
   (= (window-total-size window t)
      (window-total-size (frame-root-window window) t)))
 
-(defsubst window-body-height (&optional window)
-  "Return the number of lines of WINDOW's body.
-WINDOW must be a live window and defaults to the selected one.
-
-The return value does not include WINDOW's mode line and header
-line, if any.  If a line at the bottom of the window is only
-partially visible, that line is included in the return value.  If
-you do not want to include a partially visible bottom line in the
-return value, use `window-text-height' instead.
-
-Note that the return value is measured in canonical units, i.e. for
-the default frame's face.  If the window shows some characters with
-non-default face, e.g., if the font of some characters is larger or
-smaller than the default font, the value returned by this function
-will not match the actual number of lines shown in the window.  To
-get the actual number of lines, use `posn-at-point'."
-  (window-body-size window))
-
-(defsubst window-body-width (&optional window)
-  "Return the number of columns of WINDOW's body.
-WINDOW must be a live window and defaults to the selected one.
-
-The return value does not include any vertical dividers or scroll
-bars owned by WINDOW.  On a window-system the return value does
-not include the number of columns used for WINDOW's fringes or
-display margins either.
+(defun window-body-size (&optional window horizontal)
+  "Return the height or width of WINDOW's text area.
+If WINDOW is omitted or nil, it defaults to the selected window.
+Signal an error if the window is not live.
 
-Note that the return value is measured in canonical units, i.e. for
-the default frame's face.  If the window shows some characters with
-non-default face, e.g., if the font of some characters is larger or
-smaller than the default font, the value returned by this function
-will not match the actual number of characters per line shown in the
-window.  To get the actual number of columns, use `posn-at-point'."
-  (window-body-size window t))
+If HORIZONTAL is omitted or nil, return the height of the text
+area, like `window-body-height'.  Otherwise, return the width of
+the text area, like `window-body-width'."
+  (if horizontal
+      (window-body-width window)
+    (window-body-height window)))
 
 ;; Eventually we should make `window-height' obsolete.
 (defalias 'window-width 'window-body-width)
@@ -1463,9 +1458,9 @@ as small) as possible but don't signal an error."
 
       ;; Resize now.
       (window--resize-reset frame)
-      ;; Ideally we should be able to resize just the last subwindow of
-      ;; root here.  See the comment in `resize-root-window-vertically'
-      ;; for why we do not do that.
+      ;; Ideally we should be able to resize just the last child of root
+      ;; here.  See the comment in `resize-root-window-vertically' for
+      ;; why we do not do that.
       (window--resize-this-window root (- delta) nil nil t)
       (set-window-new-total window (+ height delta))
       ;; The following routine catches the case where we want to resize
@@ -1506,7 +1501,7 @@ instead."
       (error "Cannot resize the root window of a frame"))
      ((window-minibuffer-p window)
       (window--resize-mini-window window delta))
-     ((window-resizable-p window delta horizontal ignore)
+     ((window--resizable-p window delta horizontal ignore)
       (window--resize-reset frame horizontal)
       (window--resize-this-window window delta horizontal ignore t)
       (if (and (not (window-splits window))
@@ -1532,14 +1527,14 @@ instead."
      (t
       (error "Cannot resize window %s" window)))))
 
-(defsubst window--resize-subwindows-skip-p (window)
+(defun window--resize-child-windows-skip-p (window)
   "Return non-nil if WINDOW shall be skipped by resizing routines."
   (memq (window-new-normal window) '(ignore stuck skip)))
 
-(defun window--resize-subwindows-normal (parent horizontal window this-delta &optional trail other-delta)
-  "Set the new normal height of subwindows of window PARENT.
+(defun window--resize-child-windows-normal (parent horizontal window this-delta &optional trail other-delta)
+  "Recursively set new normal height of child windows of window PARENT.
 HORIZONTAL non-nil means set the new normal width of these
-windows.  WINDOW specifies a subwindow of PARENT that has been
+windows.  WINDOW specifies a child window of PARENT that has been
 resized by THIS-DELTA lines \(columns).
 
 Optional argument TRAIL either 'before or 'after means set values
@@ -1561,8 +1556,8 @@ PARENT in order to resize WINDOW."
          (parent-normal 0.0)
          (skip (eq trail 'after)))
 
-    ;; Set parent-normal to the sum of the normal sizes of all
-    ;; subwindows of PARENT that shall be resized, excluding only WINDOW
+    ;; Set parent-normal to the sum of the normal sizes of all child
+    ;; windows of PARENT that shall be resized, excluding only WINDOW
     ;; and any windows specified by the optional TRAIL argument.
     (while sub
       (cond
@@ -1574,7 +1569,7 @@ PARENT in order to resize WINDOW."
               (+ parent-normal (window-normal-size sub horizontal)))))
       (setq sub (window-right sub)))
 
-    ;; Set the new normal size of all subwindows of PARENT from what
+    ;; Set the new normal size of all child windows of PARENT from what
     ;; they should have contributed for recovering THIS-DELTA lines
     ;; (columns).
     (setq sub (window-child parent))
@@ -1633,11 +1628,11 @@ PARENT in order to resize WINDOW."
        ;; Don't get larger than 1 or smaller than 0.
        (min 1.0 (max (- 1.0 sum) 0.0))))))
 
-(defun window--resize-subwindows (parent delta &optional horizontal window ignore trail edge)
-  "Resize subwindows of window PARENT vertically by DELTA lines.
+(defun window--resize-child-windows (parent delta &optional horizontal window ignore trail edge)
+  "Resize child windows of window PARENT vertically by DELTA lines.
 PARENT must be a vertically combined internal window.
 
-Optional argument HORIZONTAL non-nil means resize subwindows of
+Optional argument HORIZONTAL non-nil means resize child windows of
 PARENT horizontally by DELTA columns.  In this case PARENT must
 be a horizontally combined internal window.
 
@@ -1669,10 +1664,10 @@ already set by this routine."
                (setq sub first)
                (while (and (window-right sub)
                            (or (and (eq trail 'before)
-                                    (not (window--resize-subwindows-skip-p
+                                    (not (window--resize-child-windows-skip-p
                                           (window-right sub))))
                                (and (eq trail 'after)
-                                    (window--resize-subwindows-skip-p sub))))
+                                    (window--resize-child-windows-skip-p sub))))
                  (setq sub (window-right sub)))
                sub)
              (if horizontal
@@ -1700,7 +1695,7 @@ already set by this routine."
                  window (- (window-normal-size window horizontal)
                            (- (window-new-normal sub)
                               (window-normal-size sub horizontal)))))
-            (window--resize-subwindows-normal
+            (window--resize-child-windows-normal
              parent horizontal sub 0 trail delta))
           ;; Return 'normalized to notify `window--resize-siblings' that
           ;; normal sizes have been already set.
@@ -1709,9 +1704,9 @@ already set by this routine."
       (setq sub first)
       (while sub
         (cond
-         ((or (window--resize-subwindows-skip-p sub)
-              ;; Ignore windows to skip and fixed-size subwindows - in
-              ;; the latter case make it a window to skip.
+         ((or (window--resize-child-windows-skip-p sub)
+              ;; Ignore windows to skip and fixed-size child windows -
+              ;; in the latter case make it a window to skip.
               (and (not ignore)
                    (window-size-fixed-p sub horizontal)
                    (set-window-new-normal sub 'ignore))))
@@ -1799,7 +1794,7 @@ already set by this routine."
             (set-window-new-normal sub))
 
           (unless (eq (window-new-normal sub) 'ignore)
-            ;; Resize this subwindow's subwindows (back-engineering
+            ;; Resize this window's child windows (back-engineering
             ;; delta from sub's old and new total sizes).
             (let ((delta (- (window-new-total sub)
                             (window-total-size sub horizontal))))
@@ -1860,7 +1855,7 @@ preferably only resize windows adjacent to EDGE."
             ;; Set this-delta to what we can get from WINDOW's siblings.
             (if (= (- delta) (window-total-size window horizontal))
                 ;; A deletion, presumably.  We must handle this case
-                ;; specially since `window-resizable' can't be used.
+                ;; specially since `window--resizable' can't be used.
                 (if this-delta
                     ;; There's at least one resizable sibling we can
                     ;; give WINDOW's size to.
@@ -1869,7 +1864,7 @@ preferably only resize windows adjacent to EDGE."
                   (setq this-delta 0))
               ;; Any other form of resizing.
               (setq this-delta
-                    (window-resizable window delta horizontal ignore trail t)))
+                    (window--resizable window delta horizontal ignore trail t)))
 
             ;; Set other-delta to what we still have to get from
             ;; ancestor windows of parent.
@@ -1882,19 +1877,19 @@ preferably only resize windows adjacent to EDGE."
             (if (zerop this-delta)
                 ;; We haven't got anything from WINDOW's siblings but we
                 ;; must update the normal sizes to respect other-delta.
-                (window--resize-subwindows-normal
+                (window--resize-child-windows-normal
                  parent horizontal window this-delta trail other-delta)
               ;; We did get something from WINDOW's siblings which means
-              ;; we have to resize their subwindows.
-              (unless (eq (window--resize-subwindows
+              ;; we have to resize their child windows.
+              (unless (eq (window--resize-child-windows
                            parent (- this-delta) horizontal
                            window ignore trail edge)
-                          ;; If `window--resize-subwindows' returns
+                          ;; If `window--resize-child-windows' returns
                           ;; 'normalized, this means it has set the
                           ;; normal sizes already.
                           'normalized)
                 ;; Set the normal sizes.
-                (window--resize-subwindows-normal
+                (window--resize-child-windows-normal
                  parent horizontal window this-delta trail other-delta))
               ;; Set DELTA to what we still have to get from ancestor
               ;; windows.
@@ -1934,8 +1929,8 @@ resize only windows on the left or above EDGE.  If TRAIL equals
 `after', resize only windows on the right or below EDGE.  Also,
 preferably only resize windows adjacent to EDGE.
 
-This function recursively resizes WINDOW's subwindows to fit the
-new size.  Make sure that WINDOW is `window-resizable' before
+This function recursively resizes WINDOW's child windows to fit the
+new size.  Make sure that WINDOW is `window--resizable' before
 calling this function.  Note that this function does not resize
 siblings of WINDOW or WINDOW's parent window.  You have to
 eventually call `window-resize-apply' in order to make resizing
@@ -1948,11 +1943,11 @@ actually take effect."
     (cond
      ((not sub))
      ((window-combined-p sub horizontal)
-      ;; In an iso-combination resize subwindows according to their
+      ;; In an iso-combination resize child windows according to their
       ;; normal sizes.
-      (window--resize-subwindows
+      (window--resize-child-windows
        window delta horizontal nil ignore trail edge))
-     ;; In an ortho-combination resize each subwindow by DELTA.
+     ;; In an ortho-combination resize each child window by DELTA.
      (t
       (while sub
         (window--resize-this-window
@@ -1978,7 +1973,7 @@ resizes windows proportionally and never deletes any windows."
   "Resize root window WINDOW vertically by DELTA lines.
 If DELTA is less than zero and we can't shrink WINDOW by DELTA
 lines, shrink it as much as possible.  If DELTA is greater than
-zero, this function can resize fixed-size subwindows in order to
+zero, this function can resize fixed-size windows in order to
 recover the necessary lines.
 
 Return the number of lines that were recovered.
@@ -2075,7 +2070,7 @@ move it as far as possible in the desired direction."
           ;; Start resizing.
           (window--resize-reset frame horizontal)
           ;; Try to enlarge LEFT first.
-          (setq this-delta (window-resizable left delta horizontal))
+          (setq this-delta (window--resizable left delta horizontal))
           (unless (zerop this-delta)
             (window--resize-this-window
              left this-delta horizontal nil t 'before
@@ -2098,7 +2093,7 @@ move it as far as possible in the desired direction."
           ;; Start resizing.
           (window--resize-reset frame horizontal)
           ;; Try to enlarge RIGHT.
-          (setq this-delta (window-resizable right (- delta) horizontal))
+          (setq this-delta (window--resizable right (- delta) horizontal))
           (unless (zerop this-delta)
             (window--resize-this-window
              right this-delta horizontal nil t 'after
@@ -2129,7 +2124,7 @@ Return nil."
    ((zerop delta))
    ((window-size-fixed-p nil horizontal)
     (error "Selected window has fixed size"))
-   ((window-resizable-p nil delta horizontal)
+   ((window--resizable-p nil delta horizontal)
     (window-resize nil delta horizontal))
    (t
     (window-resize
@@ -2150,7 +2145,7 @@ Return nil."
    ((zerop delta))
    ((window-size-fixed-p nil horizontal)
     (error "Selected window has fixed size"))
-   ((window-resizable-p nil (- delta) horizontal)
+   ((window--resizable-p nil (- delta) horizontal)
     (window-resize nil (- delta) horizontal))
    (t
     (window-resize
@@ -2177,7 +2172,7 @@ WINDOW can be any window and defaults to the selected window."
   (window-resize window (- (window-min-delta window)))
   (window-resize window (- (window-min-delta window t)) t))
 
-(defsubst frame-root-window-p (window)
+(defun frame-root-window-p (window)
   "Return non-nil if WINDOW is the root window of its frame."
   (eq window (frame-root-window window)))
 
@@ -2214,9 +2209,9 @@ is the frame's minibuffer window.
 If the root window is not split, ROOT is the root window itself.
 Otherwise, ROOT is a list (DIR EDGES W1 W2 ...) where DIR is nil
 for a horizontal split, and t for a vertical split.  EDGES gives
-the combined size and position of the subwindows in the split,
-and the rest of the elements are the subwindows in the split.
-Each of the subwindows may again be a window or a list
+the combined size and position of the child windows in the split,
+and the rest of the elements are the child windows in the split.
+Each of the child windows may again be a window or a list
 representing a window split, and so on.  EDGES is a list \(LEFT
 TOP RIGHT BOTTOM) as returned by `window-edges'."
   (setq frame (window-normalize-frame frame))
@@ -2352,13 +2347,13 @@ frame."
       ;; frame.
       t))))
 
-(defun window-or-subwindow-p (subwindow window)
-  "Return t if SUBWINDOW is either WINDOW or a subwindow of WINDOW."
-  (or (eq subwindow window)
-      (let ((parent (window-parent subwindow)))
+(defun window--in-subtree-p (window root)
+  "Return t if WINDOW is either ROOT or a member of ROOT's subtree."
+  (or (eq window root)
+      (let ((parent (window-parent window)))
         (catch 'done
           (while parent
-            (if (eq parent window)
+            (if (eq parent root)
                 (throw 'done t)
               (setq parent (window-parent parent))))))))
 
@@ -2410,7 +2405,7 @@ non-side window, signal an error."
       (let* ((horizontal (window-left-child parent))
              (size (window-total-size window horizontal))
              (frame-selected
-              (window-or-subwindow-p (frame-selected-window frame) window))
+              (window--in-subtree-p (frame-selected-window frame) window))
              ;; Emacs 23 preferably gives WINDOW's space to its left
              ;; sibling.
              (sibling (or (window-left window) (window-right window))))
@@ -2423,7 +2418,7 @@ non-side window, signal an error."
           (set-window-new-normal
            sibling (+ (window-normal-size sibling horizontal)
                       (window-normal-size window horizontal))))
-         ((window-resizable-p window (- size) horizontal nil nil nil t)
+         ((window--resizable-p window (- size) horizontal nil nil nil t)
           ;; Can do without resizing fixed-size windows.
           (window--resize-siblings window (- size) horizontal))
          (t
@@ -3050,7 +3045,7 @@ showing BUFFER-OR-NAME."
         (unrecord-window-buffer window buffer)))))
 
 ;;; Splitting windows.
-(defsubst window-split-min-size (&optional horizontal)
+(defun window-split-min-size (&optional horizontal)
   "Return minimum height of any window when splitting windows.
 Optional argument HORIZONTAL non-nil means return minimum width."
   (if horizontal
@@ -3126,8 +3121,8 @@ frame.  The selected window is not changed by this function."
         ;; The `split-window' parameter specifies the function to call.
         ;; If that function is `ignore', do nothing.
         (throw 'done (funcall function window size side)))
-       ;; If WINDOW is a subwindow of an atomic window, split the root
-       ;; window of that atomic window instead.
+       ;; If WINDOW is part of an atomic window, split the root window
+       ;; of that atomic window instead.
        ((and (window-parameter window 'window-atom)
              (setq atom-root (window-atom-root window))
              (not (eq atom-root window)))
@@ -3249,7 +3244,7 @@ frame.  The selected window is not changed by this function."
             ;; we won't be able to return space to those windows when we
             ;; delete the one we create here.  Hence we do not go up.
             (progn
-              (window--resize-subwindows parent (- new-size) horizontal)
+              (window--resize-child-windows parent (- new-size) horizontal)
               (let* ((normal (- 1.0 new-normal))
                      (sub (window-child parent)))
                 (while sub
@@ -3365,8 +3360,8 @@ right, if any."
 ;;; Balancing windows.
 
 ;; The following routine uses the recycled code from an old version of
-;; `window--resize-subwindows'.  It's not very pretty, but coding it the way the
-;; new `window--resize-subwindows' code does would hardly make it any shorter or
+;; `window--resize-child-windows'.  It's not very pretty, but coding it the way the
+;; new `window--resize-child-windows' code does would hardly make it any shorter or
 ;; more readable (FWIW we'd need three loops - one to calculate the
 ;; minimum sizes per window, one to enlarge or shrink windows until the
 ;; new parent-size matches, and one where we shrink the largest/enlarge
@@ -3395,14 +3390,14 @@ is non-nil."
       (setq failed nil)
       (setq sub first)
       (while (and sub (not failed))
-        ;; Ignore subwindows that should be ignored or are stuck.
-        (unless (window--resize-subwindows-skip-p sub)
+        ;; Ignore child windows that should be ignored or are stuck.
+        (unless (window--resize-child-windows-skip-p sub)
           (setq found t)
           (setq sub-total (window-total-size sub horizontal))
           (setq sub-delta (- size sub-total))
           (setq sub-amount
                 (window-sizable sub sub-delta horizontal))
-          ;; Register the new total size for this subwindow.
+          ;; Register the new total size for this child window.
           (set-window-new-total sub (+ sub-total sub-amount))
           (unless (= sub-amount sub-delta)
             (setq total-sum (- total-sum sub-total sub-amount))
@@ -3417,7 +3412,7 @@ is non-nil."
     ;; (column) until `rest' is zero.
     (setq sub first)
     (while (and sub (> rest 0))
-      (unless (window--resize-subwindows-skip-p window)
+      (unless (window--resize-child-windows-skip-p window)
         (set-window-new-total sub 1 t)
         (setq rest (1- rest)))
       (setq sub (window-right sub)))
@@ -3439,7 +3434,7 @@ is non-nil."
                   (window-total-size sub horizontal)
                 (window-new-total sub))
               (float parent-size)))
-      ;; Recursively balance each subwindow's subwindows.
+      ;; Recursively balance each window's child windows.
       (balance-windows-1 sub horizontal)
       (setq sub (window-right sub)))))
 
@@ -3456,11 +3451,11 @@ is non-nil."
               (setq sub (window-right sub))))))))
 
 (defun balance-windows (&optional window-or-frame)
-  "Balance the sizes of subwindows of WINDOW-OR-FRAME.
+  "Balance the sizes of windows of WINDOW-OR-FRAME.
 WINDOW-OR-FRAME is optional and defaults to the selected frame.
 If WINDOW-OR-FRAME denotes a frame, balance the sizes of all
-subwindows of that frame's root window.  If WINDOW-OR-FRAME
-denots a window, balance the sizes of all subwindows of that
+windows of that frame.  If WINDOW-OR-FRAME denots a window,
+recursively balance the sizes of all child windows of that
 window."
   (interactive)
   (let* ((window
@@ -3593,10 +3588,6 @@ specific buffers."
     ))
 
 ;;; Window states, how to get them and how to put them in a window.
-(defsubst window-list-no-nils (&rest args)
-  "Like LIST but do not add nil elements of ARGS."
-  (delq nil (apply 'list args)))
-
 (defvar window-state-ignored-parameters '(quit-restore)
   "List of window parameters ignored by `window-state-get'.")
 
@@ -3610,46 +3601,47 @@ specific buffers."
          (buffer (window-buffer window))
          (selected (eq window (selected-window)))
          (head
-          (window-list-no-nils
-           type
-           (unless (window-next-sibling window) (cons 'last t))
-           (cons 'total-height (window-total-size window))
-           (cons 'total-width (window-total-size window t))
-           (cons 'normal-height (window-normal-size window))
-           (cons 'normal-width (window-normal-size window t))
-           (cons 'splits (window-splits window))
-           (cons 'nest (window-nest window))
-           (let (list)
-             (dolist (parameter (window-parameters window))
-               (unless (memq (car parameter)
-                             window-state-ignored-parameters)
-                 (setq list (cons parameter list))))
-             (unless (window-parameter window 'clone-of)
-               ;; Make a clone-of parameter.
-               (setq list (cons (cons 'clone-of window) list)))
-             (when list
-               (cons 'parameters list)))
-           (when buffer
-             ;; All buffer related things go in here - make the buffer
-             ;; current when retrieving `point' and `mark'.
-             (with-current-buffer (window-buffer window)
-               (let ((point (window-point-1 window))
-                     (start (window-start window))
-                     (mark (mark)))
-                 (window-list-no-nils
-                  'buffer (buffer-name buffer)
-                  (cons 'selected selected)
-                  (when window-size-fixed (cons 'size-fixed window-size-fixed))
-                  (cons 'hscroll (window-hscroll window))
-                  (cons 'fringes (window-fringes window))
-                  (cons 'margins (window-margins window))
-                  (cons 'scroll-bars (window-scroll-bars window))
-                  (cons 'vscroll (window-vscroll window))
-                  (cons 'dedicated (window-dedicated-p window))
-                  (cons 'point (if markers (copy-marker point) point))
-                  (cons 'start (if markers (copy-marker start) start))
-                  (when mark
-                    (cons 'mark (if markers (copy-marker mark) mark)))))))))
+          `(,type
+            ,@(unless (window-next-sibling window) `((last . t)))
+            (total-height . ,(window-total-size window))
+            (total-width . ,(window-total-size window t))
+            (normal-height . ,(window-normal-size window))
+            (normal-width . ,(window-normal-size window t))
+            (splits . ,(window-splits window))
+            (nest . ,(window-nest window))
+            ,@(let (list)
+                (dolist (parameter (window-parameters window))
+                  (unless (memq (car parameter)
+                                window-state-ignored-parameters)
+                    (setq list (cons parameter list))))
+                (unless (window-parameter window 'clone-of)
+                  ;; Make a clone-of parameter.
+                  (setq list (cons (cons 'clone-of window) list)))
+                (when list
+                  `((parameters . ,list))))
+            ,@(when buffer
+                ;; All buffer related things go in here - make the buffer
+                ;; current when retrieving `point' and `mark'.
+                (with-current-buffer (window-buffer window)
+                  (let ((point (window-point-1 window))
+                        (start (window-start window))
+                        (mark (mark)))
+                    `((buffer
+                       ,(buffer-name buffer)
+                       (selected . ,selected)
+                       ,@(when window-size-fixed
+                           `((size-fixed . ,window-size-fixed)))
+                       (hscroll . ,(window-hscroll window))
+                       (fringes . ,(window-fringes window))
+                       (margins . ,(window-margins window))
+                       (scroll-bars . ,(window-scroll-bars window))
+                       (vscroll . ,(window-vscroll window))
+                       (dedicated . ,(window-dedicated-p window))
+                       (point . ,(if markers (copy-marker point) point))
+                       (start . ,(if markers (copy-marker start) start))
+                       ,@(when mark
+                           `((mark . ,(if markers
+                                          (copy-marker mark) mark)))))))))))
          (tail
           (when (memq type '(vc hc))
             (let (list)
@@ -3680,21 +3672,20 @@ value can be also stored on disk and read back in a new session."
               (error "%s is not a live or internal window" window))
           (frame-root-window)))
   ;; The return value is a cons whose car specifies some constraints on
-  ;; the size of WINDOW.  The cdr lists the states of the subwindows of
-  ;; WINDOW.
+  ;; the size of WINDOW.  The cdr lists the states of the child windows
+  ;; of WINDOW.
   (cons
    ;; Frame related things would go into a function, say `frame-state',
    ;; calling `window-state-get' to insert the frame's root window.
-   (window-list-no-nils
-    (cons 'min-height (window-min-size window))
-    (cons 'min-width (window-min-size window t))
-    (cons 'min-height-ignore (window-min-size window nil t))
-    (cons 'min-width-ignore (window-min-size window t t))
-    (cons 'min-height-safe (window-min-size window nil 'safe))
-    (cons 'min-width-safe (window-min-size window t 'safe))
-    ;; These are probably not needed.
-    (when (window-size-fixed-p window) (cons 'fixed-height t))
-    (when (window-size-fixed-p window t) (cons 'fixed-width t)))
+   `((min-height        . ,(window-min-size window))
+     (min-width         . ,(window-min-size window t))
+     (min-height-ignore . ,(window-min-size window nil t))
+     (min-width-ignore  . ,(window-min-size window t t))
+     (min-height-safe   . ,(window-min-size window nil 'safe))
+     (min-width-safe    . ,(window-min-size window t 'safe))
+     ;; These are probably not needed.
+     ,@(when (window-size-fixed-p window) `((fixed-height . t)))
+     ,@(when (window-size-fixed-p window t) `((fixed-width . t))))
    (window-state-get-1 window markers)))
 
 (defvar window-state-put-list nil
@@ -3798,13 +3789,13 @@ value can be also stored on disk and read back in a new session."
               (let ((delta (- (cdr (assq 'total-height item))
                               (window-total-height window)))
                     window-size-fixed)
-                (when (window-resizable-p window delta)
+                (when (window--resizable-p window delta)
                   (window-resize window delta)))
             ;; Else check whether the window is not high enough.
             (let* ((min-size (window-min-size window nil ignore))
                    (delta (- min-size (window-total-size window))))
               (when (and (> delta 0)
-                         (window-resizable-p window delta nil ignore))
+                         (window--resizable-p window delta nil ignore))
                 (window-resize window delta nil ignore))))
           ;; Adjust horizontally.
           (if (memq window-size-fixed '(t width))
@@ -3812,13 +3803,13 @@ value can be also stored on disk and read back in a new session."
               (let ((delta (- (cdr (assq 'total-width item))
                               (window-total-width window)))
                     window-size-fixed)
-                (when (window-resizable-p window delta)
+                (when (window--resizable-p window delta)
                   (window-resize window delta)))
             ;; Else check whether the window is not wide enough.
             (let* ((min-size (window-min-size window t ignore))
                    (delta (- min-size (window-total-size window t))))
               (when (and (> delta 0)
-                         (window-resizable-p window delta t ignore))
+                         (window--resizable-p window delta t ignore))
                 (window-resize window delta t ignore))))
           ;; Set dedicated status.
           (set-window-dedicated-p window (cdr (assq 'dedicated state)))
@@ -3843,7 +3834,7 @@ specify a live window and defaults to the selected one.
 
 Optional argument IGNORE non-nil means ignore minimum window
 sizes and fixed size restrictions.  IGNORE equal `safe' means
-subwindows can get as small as `window-safe-min-height' and
+windows can get as small as `window-safe-min-height' and
 `window-safe-min-width'."
   (setq window (window-normalize-window window t))
   (let* ((frame (window-frame window))
@@ -3948,8 +3939,9 @@ means that the currently selected window is not acceptable.  It
 should choose or create a window, display the specified buffer in
 it, and return the window.
 
-The function specified here is responsible for setting the
-quit-restore and help-setup parameters of the window used."
+The specified function should call `display-buffer-record-window'
+with corresponding arguments to set up the quit-restore parameter
+of the window used."
   :type '(choice
           (const nil)
           (function :tag "function"))
@@ -4202,6 +4194,7 @@ and (cdr ARGS) as second."
                  (make-frame (append args special-display-frame-alist))))
               (window (frame-selected-window frame)))
          (display-buffer-record-window 'frame window buffer)
+         ;; FIXME: Use window--display-buffer-2?
          (set-window-buffer window buffer)
          ;; Reset list of WINDOW's previous buffers to nil.
          (set-window-prev-buffers window nil)
@@ -4221,8 +4214,9 @@ A buffer is special when its name is either listed in
 `special-display-buffer-names' or matches a regexp in
 `special-display-regexps'.
 
-The function specified here is responsible for setting the
-quit-restore and help-setup parameters of the window used."
+The specified function should call `display-buffer-record-window'
+with corresponding arguments to set up the quit-restore parameter
+of the window used."
   :type 'function
   :group 'frames)
 
@@ -4622,9 +4616,8 @@ See `display-buffer' for details."
   :group 'windows)
 
 (defconst display-buffer-fallback-action
-  '((display-buffer--maybe-same-window
+  '((display-buffer--maybe-same-window  ;FIXME: why isn't this redundant?
      display-buffer-reuse-window
-     display-buffer--special
      display-buffer--maybe-pop-up-frame-or-window
      display-buffer-use-some-window
      ;; If all else fails, pop up a new frame.
@@ -4655,7 +4648,6 @@ specified, e.g. by the user options `display-buffer-alist' or
 
 (defvar display-buffer--other-frame-action
   '((display-buffer-reuse-window
-     display-buffer--special
      display-buffer-pop-up-frame)
     (reusable-frames . 0)
     (inhibit-same-window . t))
@@ -4721,6 +4713,7 @@ search for a window that is already displaying the buffer.  See
       (let* ((user-action
               (display-buffer-assq-regexp (buffer-name buffer)
                                           display-buffer-alist))
+             (special-action (display-buffer--special-action buffer))
              ;; Extra actions from the arguments to this function:
              (extra-action
               (cons nil (append (if inhibit-same-window
@@ -4729,7 +4722,7 @@ search for a window that is already displaying the buffer.  See
                                     `((reusable-frames . ,frame))))))
              ;; Construct action function list and action alist.
              (actions (list display-buffer-overriding-action
-                            user-action action extra-action
+                            user-action special-action action extra-action
                             display-buffer-base-action
                             display-buffer-fallback-action))
              (functions (apply 'append
@@ -4812,7 +4805,7 @@ terminal if either of those variables is non-nil."
       (display-buffer-record-window 'reuse window buffer)
       (window--display-buffer-1 window))))
 
-(defun display-buffer--special (buffer alist)
+(defun display-buffer--special-action (buffer)
   "Try to display BUFFER using `special-display-function'.
 Call `special-display-p' on BUFFER's name, and if that returns
 non-nil, call `special-display-function' on BUFFER."
@@ -4821,8 +4814,10 @@ non-nil, call `special-display-function' on BUFFER."
        ;; parameters to pass to `special-display-function'.
        (let ((pars (special-display-p (buffer-name buffer))))
          (when pars
-           (funcall special-display-function
-                    buffer (if (listp pars) pars))))))
+           (list (list #'display-buffer-reuse-window
+                       `(lambda (buffer _alist)
+                          (funcall special-display-function
+                                   buffer ',(if (listp pars) pars)))))))))
 
 (defun display-buffer-pop-up-frame (buffer alist)
   "Display BUFFER in a new frame.
@@ -4970,8 +4965,7 @@ the buffer.
 NORECORD, if non-nil means do not put this buffer at the front of
 the list of recently selected ones."
   (pop-to-buffer buffer
-                 '((display-buffer--special
-                    display-buffer-same-window)
+                 '(display-buffer-same-window
                    (inhibit-same-window . nil))
                  norecord))
 
@@ -5435,8 +5429,8 @@ by `recenter-positions'."
 
 ;;; Scrolling commands.
 
-;;; Scrolling commands which does not signal errors at top/bottom
-;;; of buffer at first key-press (instead moves to top/bottom
+;;; Scrolling commands which do not signal errors at top/bottom
+;;; of buffer at first key-press (instead move to top/bottom
 ;;; of buffer).
 
 (defcustom scroll-error-top-bottom nil
diff --git a/lisp/woman.el b/lisp/woman.el
index 7b530d1004f..078acfc0362 100644
--- a/lisp/woman.el
+++ b/lisp/woman.el
@@ -1440,7 +1440,7 @@ The cdr of each alist element is the path-index / filename."
                 files))
       (setq path-index (1+ path-index)))
     ;; Uniquefy topics:
-    ;; Concate all lists with a single nconc call to
+    ;; Concatenate all lists with a single nconc call to
     ;; avoid retraversing the first lists repeatedly  -- dak
     (woman-topic-all-completions-merge
      (apply #'nconc files))))
diff --git a/src/ChangeLog b/src/ChangeLog
index b09dae946f4..42dede8e300 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -3,6 +3,74 @@
         * xdisp.c (fill_composite_glyph_string): Always set s->face, to
         avoid a crash (bug#9496).
 
+2011-11-09  Chong Yidong  <cyd@gnu.org>
+
+        * window.c (Fwindow_inside_edges, Fwindow_inside_pixel_edges)
+        (Fwindow_inside_absolute_pixel_edges): Only allow live windows.
+
+2011-11-08  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * s/gnu.h (GC_MARK_STACK): Define to GC_MAKE_GCPROS_NOOPS (Bug#9926).
+
+2011-11-08  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Avoid some portability problems by eschewing 'extern inline' functions.
+        The trivial performance wins aren't worth the portability hassles; see
+        <http://lists.gnu.org/archive/html/emacs-devel/2011-11/msg00084.html>
+        et seq.
+        * dispextern.h (window_box, window_box_height, window_text_bottom_y)
+        (window_box_width, window_box_left, window_box_left_offset)
+        (window_box_right, window_box_right_offset): Undo previous change,
+        by removing the "extern"s.
+        * intervals.c (adjust_intervals_for_insertion)
+        (adjust_intervals_for_deletion): Undo previous change,
+        making these static again.
+        (offset_intervals, temp_set_point_both, temp_set_point)
+        (copy_intervals_to_string): No longer inline.
+        * xdisp.c (window_text_bottom_y, window_box_width)
+        (window_box_height, window_box_left_offset)
+        (window_box_right_offset, window_box_left, window_box_right)
+        (window_box): No longer inline.
+
+2011-11-08  Chong Yidong  <cyd@gnu.org>
+
+        * window.c (Fwindow_left_column, Fwindow_top_line): Doc fix.
+        (Fwindow_body_height, Fwindow_body_width): Move from Lisp.  Signal
+        an error if not a live window.
+        (Fwindow_total_width, Fwindow_total_height): Move from Lisp.
+        (Fwindow_total_size, Fwindow_body_size): Move to Lisp.
+
+2011-11-07  Juanma Barranquero  <lekktu@gmail.com>
+
+        * lisp.h (syms_of_abbrev): Remove declaration.
+        Reported by CHENG Gao <chenggao@royau.me>.
+
+2011-11-07  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32.c (check_windows_init_file): Don't look for term/w32-win.el
+        if Vpurify_flag is non-nil.  Fixes a crash when running w32 build
+        of temacs in GUI mode.
+
+2011-11-07  Martin Rudalics  <rudalics@gmx.at>
+
+        * window.h: Declare delete_all_child_windows instead of
+        delete_all_subwindows.
+        * window.c (Fwindow_nest, Fset_window_nest)
+        (Fset_window_new_total, Fset_window_new_normal)
+        (Fwindow_resize_apply): Don't use term subwindow in doc-strings.
+        (delete_all_subwindows): Rename to delete_all_child_windows.
+        (Fdelete_other_windows_internal, Fset_window_configuration):
+        Call delete_all_child_windows instead of delete_all_subwindows.
+        * frame.c (delete_frame): Call delete_all_child_windows instead
+        of delete_all_subwindows.
+
+2011-11-07  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * alloc.c (DEADP): New macro, for porting to GNU/Hurd (Bug#9926).
+        This is also needed for porting to any host where GC_MARK_STACK is
+        not GC_MAKE_GCPROS_NOOPS.
+        (which_symbols): Use it.
+
 2011-11-07  Kenichi Handa  <handa@m17n.org>
 
         * coding.c (coding_set_destination): Check coding->src_pos only
diff --git a/src/alloc.c b/src/alloc.c
index 210dd7d1687..985e4b71426 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -315,6 +315,7 @@ static POINTER_TYPE *lisp_malloc (size_t, enum mem_type);
    on free lists recognizable in O(1).  */
 
 static Lisp_Object Vdead;
+#define DEADP(x) EQ (x, Vdead)
 
 #ifdef GC_MALLOC_CHECK
 
@@ -411,6 +412,10 @@ static void check_gcpros (void);
 
 #endif /* GC_MARK_STACK || GC_MALLOC_CHECK */
 
+#ifndef DEADP
+# define DEADP(x) 0
+#endif
+
 /* Recording what needs to be marked for gc.  */
 
 struct gcpro *gcprolist;
@@ -6261,7 +6266,7 @@ which_symbols (Lisp_Object obj, EMACS_INT find_max)
    int gc_count = inhibit_garbage_collection ();
    Lisp_Object found = Qnil;
 
-   if (!EQ (obj, Vdead))
+   if (! DEADP (obj))
      {
        for (sblk = symbol_block; sblk; sblk = sblk->next)
          {
diff --git a/src/ccl.c b/src/ccl.c
index cb96eece5ee..01943eddf58 100644
--- a/src/ccl.c
+++ b/src/ccl.c
@@ -429,7 +429,7 @@ static Lisp_Object Vccl_program_table;
 
 #define CCL_Extension           0x1F /* Extended CCL code
                                         1:ExtendedCOMMNDRrrRRRrrrXXXXX
-                                        2:ARGUEMENT
+                                        2:ARGUMENT
                                         3:...
                                         ------------------------------
                                         extended_command (rrr,RRR,Rrr,ARGS)
diff --git a/src/dispextern.h b/src/dispextern.h
index fdc7f2f908d..5c60a5499da 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -3006,14 +3006,14 @@ int resize_mini_window (struct window *, int);
 void set_vertical_scroll_bar (struct window *);
 #endif
 int try_window (Lisp_Object, struct text_pos, int);
-extern void window_box (struct window *, int, int *, int *, int *, int *);
-extern int window_box_height (struct window *);
-extern int window_text_bottom_y (struct window *);
-extern int window_box_width (struct window *, int);
-extern int window_box_left (struct window *, int);
-extern int window_box_left_offset (struct window *, int);
-extern int window_box_right (struct window *, int);
-extern int window_box_right_offset (struct window *, int);
+void window_box (struct window *, int, int *, int *, int *, int *);
+int window_box_height (struct window *);
+int window_text_bottom_y (struct window *);
+int window_box_width (struct window *, int);
+int window_box_left (struct window *, int);
+int window_box_left_offset (struct window *, int);
+int window_box_right (struct window *, int);
+int window_box_right_offset (struct window *, int);
 int estimate_mode_line_height (struct frame *, enum face_id);
 void pixel_to_glyph_coords (struct frame *, int, int, int *, int *,
                             NativeRectangle *, int);
diff --git a/src/font.c b/src/font.c
index 1a4742ba959..f6723157de1 100644
--- a/src/font.c
+++ b/src/font.c
@@ -162,7 +162,7 @@ static struct font_driver_list *font_driver_list;
 
 
 
-/* Creaters of font-related Lisp object.  */
+/* Creators of font-related Lisp object.  */
 
 static Lisp_Object
 font_make_spec (void)
diff --git a/src/frame.c b/src/frame.c
index 112f102a1f2..d56a2efb17f 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -1320,7 +1320,7 @@ delete_frame (Lisp_Object frame, Lisp_Object force)
 
   /* Mark all the windows that used to be on FRAME as deleted, and then
      remove the reference to them.  */
-  delete_all_subwindows (f->root_window);
+  delete_all_child_windows (f->root_window);
   f->root_window = Qnil;
 
   Vframe_list = Fdelq (frame, Vframe_list);
diff --git a/src/intervals.c b/src/intervals.c
index be1bdfb9056..a78c7f07f6c 100644
--- a/src/intervals.c
+++ b/src/intervals.c
@@ -52,11 +52,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #define TMEM(sym, set) (CONSP (set) ? ! NILP (Fmemq (sym, set)) : ! NILP (set))
 
-extern INTERVAL adjust_intervals_for_insertion (INTERVAL,
-                                                EMACS_INT, EMACS_INT);
-extern void adjust_intervals_for_deletion (struct buffer *,
-                                           EMACS_INT, EMACS_INT);
-
 static Lisp_Object merge_properties_sticky (Lisp_Object, Lisp_Object);
 static INTERVAL merge_interval_right (INTERVAL);
 static INTERVAL reproduce_tree (INTERVAL, INTERVAL);
@@ -803,7 +798,7 @@ update_interval (register INTERVAL i, EMACS_INT pos)
    and check the hungry bits of both.  Then add the length going back up
    to the root.  */
 
-INTERVAL
+static INTERVAL
 adjust_intervals_for_insertion (INTERVAL tree, EMACS_INT position,
                                 EMACS_INT length)
 {
@@ -864,7 +859,7 @@ adjust_intervals_for_insertion (INTERVAL tree, EMACS_INT position,
    interval.  Another possibility would be to create a new interval for
    this text, and make it have the merged properties of both ends.  */
 
-INTERVAL
+static INTERVAL
 adjust_intervals_for_insertion (INTERVAL tree,
                                 EMACS_INT position, EMACS_INT length)
 {
@@ -1374,7 +1369,7 @@ interval_deletion_adjustment (register INTERVAL tree, register EMACS_INT from,
    text.  The deletion is effected at position START (which is a
    buffer position, i.e. origin 1).  */
 
-void
+static void
 adjust_intervals_for_deletion (struct buffer *buffer,
                                EMACS_INT start, EMACS_INT length)
 {
@@ -1430,7 +1425,7 @@ adjust_intervals_for_deletion (struct buffer *buffer,
    compiler that does not allow calling a static function (here,
    adjust_intervals_for_deletion) from a non-static inline function.  */
 
-inline void
+void
 offset_intervals (struct buffer *buffer, EMACS_INT start, EMACS_INT length)
 {
   if (NULL_INTERVAL_P (BUF_INTERVALS (buffer)) || length == 0)
@@ -1882,7 +1877,7 @@ lookup_char_property (Lisp_Object plist, register Lisp_Object prop, int textprop
 /* Set point in BUFFER "temporarily" to CHARPOS, which corresponds to
    byte position BYTEPOS.  */
 
-inline void
+void
 temp_set_point_both (struct buffer *buffer,
                      EMACS_INT charpos, EMACS_INT bytepos)
 {
@@ -1902,7 +1897,7 @@ temp_set_point_both (struct buffer *buffer,
 
 /* Set point "temporarily", without checking any text properties.  */
 
-inline void
+void
 temp_set_point (struct buffer *buffer, EMACS_INT charpos)
 {
   temp_set_point_both (buffer, charpos,
@@ -2391,7 +2386,7 @@ copy_intervals (INTERVAL tree, EMACS_INT start, EMACS_INT length)
 
 /* Give STRING the properties of BUFFER from POSITION to LENGTH.  */
 
-inline void
+void
 copy_intervals_to_string (Lisp_Object string, struct buffer *buffer,
                           EMACS_INT position, EMACS_INT length)
 {
diff --git a/src/lisp.h b/src/lisp.h
index f3c704bc763..46448f7a1fb 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -3155,10 +3155,6 @@ extern void syms_of_fileio (void);
 extern Lisp_Object make_temp_name (Lisp_Object, int);
 extern Lisp_Object Qdelete_file;
 
-/* Defined in abbrev.c */
-
-extern void syms_of_abbrev (void);
-
 /* Defined in search.c */
 extern void shrink_regexp_cache (void);
 EXFUN (Fstring_match, 3);
diff --git a/src/s/gnu.h b/src/s/gnu.h
index c40f764f8bf..b40f7b0a95b 100644
--- a/src/s/gnu.h
+++ b/src/s/gnu.h
@@ -44,3 +44,5 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #endif /* !_IO_STDIO_H */
 #endif /* emacs */
 
+/* Use the GC_MAKE_GCPROS_NOOPS (see lisp.h) method for marking the stack.  */
+#define GC_MARK_STACK   GC_MAKE_GCPROS_NOOPS
diff --git a/src/w32.c b/src/w32.c
index f17e987f437..c752333c68d 100644
--- a/src/w32.c
+++ b/src/w32.c
@@ -5784,7 +5784,10 @@ check_windows_init_file (void)
      it cannot find the Windows installation file.  If this file does
      not exist in the expected place, tell the user.  */
 
-  if (!noninteractive && !inhibit_window_system)
+  if (!noninteractive && !inhibit_window_system
+      /* Vload_path is not yet initialized when we are loading
+         loadup.el.  */
+      && NILP (Vpurify_flag))
     {
       Lisp_Object objs[2];
       Lisp_Object full_load_path;
diff --git a/src/window.c b/src/window.c
index 605d00b8e05..83a8974e88d 100644
--- a/src/window.c
+++ b/src/window.c
@@ -504,8 +504,8 @@ DEFUN ("window-nest", Fwindow_nest, Swindow_nest, 0, 1, 0,
        doc: /* Return nest status of window WINDOW.
 If WINDOW is omitted or nil, it defaults to the selected window.
 
-If the return value is nil, subwindows of WINDOW can be recombined with
-WINDOW's siblings.  A return value of non-nil means that subwindows of
+If the return value is nil, child windows of WINDOW can be recombined with
+WINDOW's siblings.  A return value of non-nil means that child windows of
 WINDOW are never \(re-)combined with WINDOW's siblings.  */)
   (Lisp_Object window)
 {
@@ -516,8 +516,8 @@ DEFUN ("set-window-nest", Fset_window_nest, Sset_window_nest, 2, 2, 0,
        doc: /* Set nest status of window WINDOW to STATUS; return STATUS.
 If WINDOW is omitted or nil, it defaults to the selected window.
 
-If STATUS is nil, subwindows of WINDOW can be recombined with WINDOW's
-siblings.  STATUS non-nil means that subwindows of WINDOW are never
+If STATUS is nil, child windows of WINDOW can be recombined with WINDOW's
+siblings.  STATUS non-nil means that child windows of WINDOW are never
 \(re-)combined with WINDOW's siblings.  */)
   (Lisp_Object window, Lisp_Object status)
 {
@@ -539,27 +539,34 @@ selected one.  */)
   return decode_window (window)->use_time;
 }
 
-DEFUN ("window-total-size", Fwindow_total_size, Swindow_total_size, 0, 2, 0,
-       doc: /* Return the total number of lines of window WINDOW.
+DEFUN ("window-total-height", Fwindow_total_height, Swindow_total_height, 0, 1, 0,
+       doc: /* Return the total height, in lines, of window WINDOW.
 If WINDOW is omitted or nil, it defaults to the selected window.
 
-The return value includes WINDOW's mode line and header line, if any.
-If WINDOW is internal, the return value is the sum of the total number
-of lines of WINDOW's child windows if these are vertically combined
-and the height of WINDOW's first child otherwise.
-
-Optional argument HORIZONTAL non-nil means return the total number of
-columns of WINDOW.  In this case the return value includes any vertical
-dividers or scrollbars of WINDOW.  If WINDOW is internal, the return
-value is the sum of the total number of columns of WINDOW's child
-windows if they are horizontally combined and the width of WINDOW's
-first child otherwise.  */)
-  (Lisp_Object window, Lisp_Object horizontal)
+The return value includes the mode line and header line, if any.
+If WINDOW is an internal window, the total height is the height
+of the screen areas spanned by its children.
+
+On a graphical display, this total height is reported as an
+integer multiple of the default character height.  */)
+  (Lisp_Object window)
 {
-  if (NILP (horizontal))
-    return decode_any_window (window)->total_lines;
-  else
-    return decode_any_window (window)->total_cols;
+  return decode_any_window (window)->total_lines;
+}
+
+DEFUN ("window-total-width", Fwindow_total_width, Swindow_total_width, 0, 1, 0,
+       doc: /* Return the total width, in columns, of window WINDOW.
+If WINDOW is omitted or nil, it defaults to the selected window.
+
+The return value includes any vertical dividers or scroll bars
+belonging to WINDOW.  If WINDOW is an internal window, the total width
+is the width of the screen areas spanned by its children.
+
+On a graphical display, this total width is reported as an
+integer multiple of the default character width.  */)
+  (Lisp_Object window)
+{
+  return decode_any_window (window)->total_cols;
 }
 
 DEFUN ("window-new-total", Fwindow_new_total, Swindow_new_total, 0, 1, 0,
@@ -592,6 +599,10 @@ If WINDOW is omitted or nil, it defaults to the selected window.  */)
 
 DEFUN ("window-left-column", Fwindow_left_column, Swindow_left_column, 0, 1, 0,
        doc: /* Return left column of window WINDOW.
+This is the distance, in columns, between the left edge of WINDOW and
+the left edge of the frame's window area.  For instance, the return
+value is 0 if there is no window to the left of WINDOW.
+
 If WINDOW is omitted or nil, it defaults to the selected window.  */)
   (Lisp_Object window)
 {
@@ -600,6 +611,10 @@ If WINDOW is omitted or nil, it defaults to the selected window.  */)
 
 DEFUN ("window-top-line", Fwindow_top_line, Swindow_top_line, 0, 1, 0,
        doc: /* Return top line of window WINDOW.
+This is the distance, in lines, between the top of WINDOW and the top
+of the frame's window area.  For instance, the return value is 0 if
+there is no window above WINDOW.
+
 If WINDOW is omitted or nil, it defaults to the selected window.  */)
   (Lisp_Object window)
 {
@@ -655,34 +670,34 @@ window_body_cols (struct window *w)
   return width;
 }
 
-DEFUN ("window-body-size", Fwindow_body_size, Swindow_body_size, 0, 2, 0,
-       doc: /* Return the number of lines or columns of WINDOW's body.
-WINDOW must be a live window and defaults to the selected one.
+DEFUN ("window-body-height", Fwindow_body_height, Swindow_body_height, 0, 1, 0,
+       doc: /* Return the height, in lines, of WINDOW's text area.
+If WINDOW is omitted or nil, it defaults to the selected window.
+Signal an error if the window is not live.
 
-If the optional argument HORIZONTAL is omitted or nil, the function
-returns the number of WINDOW's lines, excluding the mode line and
-header line, if any.
-
-If HORIZONTAL is non-nil, the function returns the number of columns
-excluding any vertical dividers or scroll bars owned by WINDOW.  On a
-window-system the return value also excludes the number of columns
-used for WINDOW's fringes or display margins.
-
-Note that the return value is measured in canonical units, i.e. for
-the default frame's face.  If the window shows some characters with
-non-default face, e.g., if the font of some characters is larger or
-smaller than the default font, the value returned by this function
-will not match the actual number of lines or characters per line
-shown in the window.  To get the actual number of columns and lines,
-use `posn-at-point'.  */)
-  (Lisp_Object window, Lisp_Object horizontal)
+The returned height does not include the mode line or header line.
+On a graphical display, the height is expressed as an integer multiple
+of the default character height.  If a line at the bottom of the text
+area is only partially visible, that counts as a whole line; to
+exclude partially-visible lines, use `window-text-height'.  */)
+  (Lisp_Object window)
 {
-  struct window *w = decode_any_window (window);
+  struct window *w = decode_window (window);
+  return make_number (window_body_lines (w));
+}
 
-  if (NILP (horizontal))
-    return make_number (window_body_lines (w));
-  else
-    return make_number (window_body_cols (w));
+DEFUN ("window-body-width", Fwindow_body_width, Swindow_body_width, 0, 1, 0,
+       doc: /* Return the width, in columns, of WINDOW's text area.
+If WINDOW is omitted or nil, it defaults to the selected window.
+Signal an error if the window is not live.
+
+The return value does not include any vertical dividers, fringe or
+marginal areas, or scroll bars.  On a graphical display, the width is
+expressed as an integer multiple of the default character width.  */)
+  (Lisp_Object window)
+{
+  struct window *w = decode_window (window);
+  return make_number (window_body_cols (w));
 }
 
 DEFUN ("window-hscroll", Fwindow_hscroll, Swindow_hscroll, 0, 1, 0,
@@ -844,7 +859,7 @@ The inside edges do not include the space used by the WINDOW's scroll
 bar, display margins, fringes, header line, and/or mode line.  */)
   (Lisp_Object window)
 {
-  register struct window *w = decode_any_window (window);
+  register struct window *w = decode_window (window);
 
   return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w)
                              + WINDOW_LEFT_MARGIN_COLS (w)
@@ -859,9 +874,9 @@ bar, display margins, fringes, header line, and/or mode line.  */)
 }
 
 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges, Swindow_inside_pixel_edges, 0, 1, 0,
-       doc: /* Return a list of the edge pixel coordinates of WINDOW.
-The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
-the top left corner of the frame.
+       doc: /* Return a list of the edge pixel coordinates of WINDOW's text area.
+The list has the form (LEFT TOP RIGHT BOTTOM), all relative to (0,0)
+at the top left corner of the frame's window area.
 
 RIGHT is one more than the rightmost x position of WINDOW's text area.
 BOTTOM is one more than the bottommost y position of WINDOW's text area.
@@ -869,7 +884,7 @@ The inside edges do not include the space used by WINDOW's scroll bar,
 display margins, fringes, header line, and/or mode line.  */)
   (Lisp_Object window)
 {
-  register struct window *w = decode_any_window (window);
+  register struct window *w = decode_window (window);
 
   return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w)
                              + WINDOW_LEFT_MARGIN_WIDTH (w)
@@ -886,9 +901,9 @@ display margins, fringes, header line, and/or mode line.  */)
 DEFUN ("window-inside-absolute-pixel-edges",
        Fwindow_inside_absolute_pixel_edges,
        Swindow_inside_absolute_pixel_edges, 0, 1, 0,
-       doc: /* Return a list of the edge pixel coordinates of WINDOW.
-The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
-the top left corner of the display.
+       doc: /* Return a list of the edge pixel coordinates of WINDOW's text area.
+The list has the form (LEFT TOP RIGHT BOTTOM), all relative to (0,0)
+at the top left corner of the frame's window area.
 
 RIGHT is one more than the rightmost x position of WINDOW's text area.
 BOTTOM is one more than the bottommost y position of WINDOW's text area.
@@ -896,7 +911,7 @@ The inside edges do not include the space used by WINDOW's scroll bar,
 display margins, fringes, header line, and/or mode line.  */)
   (Lisp_Object window)
 {
-  register struct window *w = decode_any_window (window);
+  register struct window *w = decode_window (window);
   int add_x, add_y;
   calc_absolute_offset (w, &add_x, &add_y);
 
@@ -2571,9 +2586,9 @@ DEFUN ("delete-other-windows-internal", Fdelete_other_windows_internal,
 Only the frame WINDOW is on is affected.  WINDOW may be any window and
 defaults to the selected one.
 
-Optional argument ROOT, if non-nil, must specify an internal window
-containing WINDOW as a subwindow.  If this is the case, replace ROOT by
-WINDOW and leave alone any windows not contained in ROOT.
+Optional argument ROOT, if non-nil, must specify an internal window such
+that WINDOW is in its window subtree.  If this is the case, replace ROOT
+by WINDOW and leave alone any windows not part of ROOT's subtree.
 
 When WINDOW is live try to reduce display jumps by keeping the text
 previously visible in WINDOW in the same place on the frame.  Doing this
@@ -2637,10 +2652,10 @@ window-start value is reasonable when this function is called.  */)
     }
   else
     {
-      /* See if the frame's selected window is a subwindow of WINDOW, by
-         finding all the selected window's parents and comparing each
-         one with WINDOW.  If it isn't we need a new selected window for
-         this frame.  */
+      /* See if the frame's selected window is a part of the window
+         subtree rooted at WINDOW, by finding all the selected window's
+         parents and comparing each one with WINDOW.  If it isn't we
+         need a new selected window for this frame.  */
       swindow = FRAME_SELECTED_WINDOW (f);
       while (1)
         {
@@ -2676,7 +2691,7 @@ window-start value is reasonable when this function is called.  */)
 
   if (NILP (w->buffer))
     {
-      /* Resize subwindows vertically.  */
+      /* Resize child windows vertically.  */
       XSETINT (delta, XINT (r->total_lines) - XINT (w->total_lines));
       w->top_line = r->top_line;
       resize_root_window (window, delta, Qnil, Qnil);
@@ -2691,7 +2706,7 @@ window-start value is reasonable when this function is called.  */)
             resize_failed = 1;
         }
 
-      /* Resize subwindows horizontally.  */
+      /* Resize child windows horizontally.  */
       if (!resize_failed)
         {
           w->left_col = r->left_col;
@@ -2740,15 +2755,15 @@ window-start value is reasonable when this function is called.  */)
         XWINDOW (w->parent)->hchild = sibling;
     }
 
-  /* Delete ROOT and all subwindows of ROOT.  */
+  /* Delete ROOT and all child windows of ROOT.  */
   if (!NILP (r->vchild))
     {
-      delete_all_subwindows (r->vchild);
+      delete_all_child_windows (r->vchild);
       r->vchild = Qnil;
     }
   else if (!NILP (r->hchild))
     {
-      delete_all_subwindows (r->hchild);
+      delete_all_child_windows (r->hchild);
       r->hchild = Qnil;
     }
 
@@ -3349,7 +3364,7 @@ Return SIZE.
 Optional argument ADD non-nil means add SIZE to the new total size of
 WINDOW and return the sum.
 
-Note: This function does not operate on any subwindows of WINDOW.  */)
+Note: This function does not operate on any child windows of WINDOW.  */)
      (Lisp_Object window, Lisp_Object size, Lisp_Object add)
 {
   struct window *w = decode_any_window (window);
@@ -3367,7 +3382,7 @@ DEFUN ("set-window-new-normal", Fset_window_new_normal, Sset_window_new_normal,
        doc: /* Set new normal size of WINDOW to SIZE.
 Return SIZE.
 
-Note: This function does not operate on any subwindows of WINDOW.  */)
+Note: This function does not operate on any child windows of WINDOW.  */)
      (Lisp_Object window, Lisp_Object size)
 {
   struct window *w = decode_any_window (window);
@@ -3378,7 +3393,7 @@ Note: This function does not operate on any subwindows of WINDOW.  */)
 
 /* Return 1 if setting w->total_lines (w->total_cols if HORFLAG is
    non-zero) to w->new_total would result in correct heights (widths)
-   for window W and recursively all subwindows of W.
+   for window W and recursively all child windows of W.
 
    Note: This function does not check any of `window-fixed-size-p',
    `window-min-height' or `window-min-width'.  It does check that window
@@ -3393,7 +3408,7 @@ window_resize_check (struct window *w, int horflag)
     {
       c = XWINDOW (w->vchild);
       if (horflag)
-        /* All subwindows of W must have the same width as W.  */
+        /* All child windows of W must have the same width as W.  */
         {
           while (c)
             {
@@ -3405,8 +3420,8 @@ window_resize_check (struct window *w, int horflag)
           return 1;
         }
       else
-        /* The sum of the heights of the subwindows of W must equal W's
-           height.  */
+        /* The sum of the heights of the child windows of W must equal
+           W's height.  */
         {
           int sum_of_sizes = 0;
           while (c)
@@ -3424,7 +3439,7 @@ window_resize_check (struct window *w, int horflag)
     {
       c = XWINDOW (w->hchild);
       if (horflag)
-        /* The sum of the widths of the subwindows of W must equal W's
+        /* The sum of the widths of the child windows of W must equal W's
            width.  */
         {
           int sum_of_sizes = 0;
@@ -3438,7 +3453,7 @@ window_resize_check (struct window *w, int horflag)
           return (sum_of_sizes == XINT (w->new_total));
         }
       else
-        /* All subwindows of W must have the same height as W.  */
+        /* All child windows of W must have the same height as W.  */
         {
           while (c)
             {
@@ -3458,9 +3473,9 @@ window_resize_check (struct window *w, int horflag)
 }
 
 /* Set w->total_lines (w->total_cols if HORIZONTAL is non-zero) to
-   w->new_total for window W and recursively all subwindows of W.  Also
-   calculate and assign the new vertical (horizontal) start positions of
-   each of these windows.
+   w->new_total for window W and recursively all child windows of W.
+   Also calculate and assign the new vertical (horizontal) start
+   positions of each of these windows.
 
    This function does not perform any error checks.  Make sure you have
    run window_resize_check on W before applying this function.  */
@@ -3534,8 +3549,8 @@ Optional argument HORIZONTAL omitted or nil means apply requested height
 values.  HORIZONTAL non-nil means apply requested width values.
 
 This function checks whether the requested values sum up to a valid
-window layout, recursively assigns the new sizes of all subwindows and
-calculates and assigns the new start positions of these windows.
+window layout, recursively assigns the new sizes of all child windows
+and calculates and assigns the new start positions of these windows.
 
 Note: This function does not check any of `window-fixed-size-p',
 `window-min-height' or `window-min-width'.  All these checks have to
@@ -3931,12 +3946,12 @@ Signal an error when WINDOW is the only window on its frame.  */)
 
       if (!NILP (w->vchild))
         {
-          delete_all_subwindows (w->vchild);
+          delete_all_child_windows (w->vchild);
           w->vchild = Qnil;
         }
       else if (!NILP (w->hchild))
         {
-          delete_all_subwindows (w->hchild);
+          delete_all_child_windows (w->hchild);
           w->hchild = Qnil;
         }
       else if (!NILP (w->buffer))
@@ -5218,10 +5233,10 @@ and redisplay normally--don't erase and redraw the frame.  */)
 DEFUN ("window-text-height", Fwindow_text_height, Swindow_text_height,
        0, 1, 0,
        doc: /* Return the height in lines of the text display area of WINDOW.
-WINDOW defaults to the selected window.
+If WINDOW is omitted or nil, it defaults to the selected window.
 
-The return value does not include the mode line, any header line, nor
-any partial-height lines in the text display area.  */)
+The returned height does not include the mode line, any header line,
+nor any partial-height lines at the bottom of the text area.  */)
   (Lisp_Object window)
 {
   struct window *w = decode_window (window);
@@ -5515,7 +5530,7 @@ the return value is nil.  Otherwise the value is t.  */)
          Save their current buffers in their height fields, since we may
          need it later, if a buffer saved in the configuration is now
          dead.  */
-      delete_all_subwindows (FRAME_ROOT_WINDOW (f));
+      delete_all_child_windows (FRAME_ROOT_WINDOW (f));
 
       for (k = 0; k < saved_windows->header.size; k++)
         {
@@ -5729,10 +5744,10 @@ the return value is nil.  Otherwise the value is t.  */)
 }
 
 
-/* Delete all subwindows reachable via the next, vchild, and hchild
-   slots of WINDOW.  */
+/* Recursively delete all child windows reachable via the next, vchild,
+   and hchild slots of WINDOW.  */
 void
-delete_all_subwindows (Lisp_Object window)
+delete_all_child_windows (Lisp_Object window)
 {
   register struct window *w;
 
@@ -5740,18 +5755,18 @@ delete_all_subwindows (Lisp_Object window)
 
   if (!NILP (w->next))
     /* Delete WINDOW's siblings (we traverse postorderly).  */
-    delete_all_subwindows (w->next);
+    delete_all_child_windows (w->next);
 
   w->total_lines = w->buffer;       /* See Fset_window_configuration for excuse.  */
 
   if (!NILP (w->vchild))
     {
-      delete_all_subwindows (w->vchild);
+      delete_all_child_windows (w->vchild);
       w->vchild = Qnil;
     }
   else if (!NILP (w->hchild))
     {
-      delete_all_subwindows (w->hchild);
+      delete_all_child_windows (w->hchild);
       w->hchild = Qnil;
     }
   else if (!NILP (w->buffer))
@@ -6583,14 +6598,16 @@ function `window-nest' and altered by the function `set-window-nest'.  */);
   defsubr (&Swindow_use_time);
   defsubr (&Swindow_top_line);
   defsubr (&Swindow_left_column);
-  defsubr (&Swindow_total_size);
+  defsubr (&Swindow_total_height);
+  defsubr (&Swindow_total_width);
   defsubr (&Swindow_normal_size);
   defsubr (&Swindow_new_total);
   defsubr (&Swindow_new_normal);
   defsubr (&Sset_window_new_total);
   defsubr (&Sset_window_new_normal);
   defsubr (&Swindow_resize_apply);
-  defsubr (&Swindow_body_size);
+  defsubr (&Swindow_body_height);
+  defsubr (&Swindow_body_width);
   defsubr (&Swindow_hscroll);
   defsubr (&Sset_window_hscroll);
   defsubr (&Swindow_redisplay_end_trigger);
diff --git a/src/window.h b/src/window.h
index c6fa5e7a338..6a9641e3e6d 100644
--- a/src/window.h
+++ b/src/window.h
@@ -824,7 +824,7 @@ extern Lisp_Object window_from_coordinates (struct frame *, int, int,
                                             enum window_part *, int);
 EXFUN (Fwindow_dedicated_p, 1);
 extern void resize_frame_windows (struct frame *, int, int);
-extern void delete_all_subwindows (Lisp_Object);
+extern void delete_all_child_windows (Lisp_Object);
 extern void freeze_window_starts (struct frame *, int);
 extern void grow_mini_window (struct window *, int);
 extern void shrink_mini_window (struct window *);
diff --git a/src/xdisp.c b/src/xdisp.c
index 9bb2396c4a3..ae4db3906ba 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -954,7 +954,7 @@ static int coords_in_mouse_face_p (struct window *, int, int);
 
    This is the height of W minus the height of a mode line, if any.  */
 
-inline int
+int
 window_text_bottom_y (struct window *w)
 {
   int height = WINDOW_TOTAL_HEIGHT (w);
@@ -968,7 +968,7 @@ window_text_bottom_y (struct window *w)
    means return the total width of W, not including fringes to
    the left and right of the window.  */
 
-inline int
+int
 window_box_width (struct window *w, int area)
 {
   int cols = XFASTINT (w->total_cols);
@@ -1007,7 +1007,7 @@ window_box_width (struct window *w, int area)
 /* Return the pixel height of the display area of window W, not
    including mode lines of W, if any.  */
 
-inline int
+int
 window_box_height (struct window *w)
 {
   struct frame *f = XFRAME (w->frame);
@@ -1054,7 +1054,7 @@ window_box_height (struct window *w)
    area AREA of window W.  AREA < 0 means return the left edge of the
    whole window, to the right of the left fringe of W.  */
 
-inline int
+int
 window_box_left_offset (struct window *w, int area)
 {
   int x;
@@ -1086,7 +1086,7 @@ window_box_left_offset (struct window *w, int area)
    area AREA of window W.  AREA < 0 means return the right edge of the
    whole window, to the left of the right fringe of W.  */
 
-inline int
+int
 window_box_right_offset (struct window *w, int area)
 {
   return window_box_left_offset (w, area) + window_box_width (w, area);
@@ -1096,7 +1096,7 @@ window_box_right_offset (struct window *w, int area)
    area AREA of window W.  AREA < 0 means return the left edge of the
    whole window, to the right of the left fringe of W.  */
 
-inline int
+int
 window_box_left (struct window *w, int area)
 {
   struct frame *f = XFRAME (w->frame);
@@ -1116,7 +1116,7 @@ window_box_left (struct window *w, int area)
    area AREA of window W.  AREA < 0 means return the right edge of the
    whole window, to the left of the right fringe of W.  */
 
-inline int
+int
 window_box_right (struct window *w, int area)
 {
   return window_box_left (w, area) + window_box_width (w, area);
@@ -1129,7 +1129,7 @@ window_box_right (struct window *w, int area)
    coordinates of the upper-left corner of the box.  Return in
    *BOX_WIDTH, and *BOX_HEIGHT the pixel width and height of the box.  */
 
-inline void
+void
 window_box (struct window *w, int area, int *box_x, int *box_y,
             int *box_width, int *box_height)
 {
diff --git a/test/automated/compile-tests.el b/test/automated/compile-tests.el
index 1d9a266904c..419cc0e9116 100644
--- a/test/automated/compile-tests.el
+++ b/test/automated/compile-tests.el
@@ -71,7 +71,7 @@
     ;; caml
     ("File \"foobar.ml\", lines 5-8, characters 20-155: blah blah"
      1 (19 . 155) (5 . 8) "foobar.ml")
-    ("File \"F:\\ocaml\\sorting.ml\", line 65, characters 2-145:"
+    ("File \"F:\\ocaml\\sorting.ml\", line 65, characters 2-145:\nWarning 26: unused variable equ."
      1 (1 . 145) 65 "F:\\ocaml\\sorting.ml")
     ("File \"/usr/share/gdesklets/display/TargetGauge.py\", line 41, in add_children"
      1 nil 41 "/usr/share/gdesklets/display/TargetGauge.py")