--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/man/lispref/positions.texi	Mon Aug 13 11:28:15 2007 +0200
@@ -0,0 +1,965 @@
+@c -*-texinfo-*-
+@c This is part of the XEmacs Lisp Reference Manual.
+@c Copyright (C) 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc. 
+@c See the file lispref.texi for copying conditions.
+@setfilename ../../info/positions.info
+@node Positions, Markers, Consoles and Devices, Top
+@chapter Positions
+@cindex position (in buffer)
+
+  A @dfn{position} is the index of a character in the text of a buffer.
+More precisely, a position identifies the place between two characters
+(or before the first character, or after the last character), so we can
+speak of the character before or after a given position.  However, we
+often speak of the character ``at'' a position, meaning the character
+after that position.
+
+  Positions are usually represented as integers starting from 1, but can
+also be represented as @dfn{markers}---special objects that relocate
+automatically when text is inserted or deleted so they stay with the
+surrounding characters.  @xref{Markers}.
+
+@menu
+* Point::         The special position where editing takes place.
+* Motion::        Changing point.
+* Excursions::    Temporary motion and buffer changes.
+* Narrowing::     Restricting editing to a portion of the buffer.
+@end menu
+
+@node Point
+@section Point
+@cindex point
+
+  @dfn{Point} is a special buffer position used by many editing
+commands, including the self-inserting typed characters and text
+insertion functions.  Other commands move point through the text
+to allow editing and insertion at different places.
+
+  Like other positions, point designates a place between two characters
+(or before the first character, or after the last character), rather
+than a particular character.  Usually terminals display the cursor over
+the character that immediately follows point; point is actually before
+the character on which the cursor sits.
+
+@cindex point with narrowing
+  The value of point is a number between 1 and the buffer size plus 1.
+If narrowing is in effect (@pxref{Narrowing}), then point is constrained
+to fall within the accessible portion of the buffer (possibly at one end
+of it).
+
+  Each buffer has its own value of point, which is independent of the
+value of point in other buffers.  Each window also has a value of point,
+which is independent of the value of point in other windows on the same
+buffer.  This is why point can have different values in various windows
+that display the same buffer.  When a buffer appears in only one window,
+the buffer's point and the window's point normally have the same value,
+so the distinction is rarely important.  @xref{Window Point}, for more
+details.
+
+@defun point &optional buffer
+@cindex current buffer position
+This function returns the value of point in @var{buffer}, as an integer.
+@var{buffer} defaults to the current buffer if omitted.
+
+@need 700
+@example
+@group
+(point)
+     @result{} 175
+@end group
+@end example
+@end defun
+
+@defun point-min &optional buffer
+This function returns the minimum accessible value of point in
+@var{buffer}.  This is normally 1, but if narrowing is in effect, it is
+the position of the start of the region that you narrowed to.
+(@xref{Narrowing}.) @var{buffer} defaults to the current buffer if
+omitted.
+@end defun
+
+@defun point-max &optional buffer
+This function returns the maximum accessible value of point in
+@var{buffer}.  This is @code{(1+ (buffer-size buffer))}, unless
+narrowing is in effect, in which case it is the position of the end of
+the region that you narrowed to. (@pxref{Narrowing}).  @var{buffer}
+defaults to the current buffer if omitted.
+@end defun
+
+@defun buffer-end flag &optional buffer
+This function returns @code{(point-min buffer)} if @var{flag} is less
+than 1, @code{(point-max buffer)} otherwise.  The argument @var{flag}
+must be a number.  @var{buffer} defaults to the current buffer if
+omitted.
+@end defun
+
+@defun buffer-size &optional buffer
+This function returns the total number of characters in @var{buffer}.
+In the absence of any narrowing (@pxref{Narrowing}), @code{point-max}
+returns a value one larger than this.  @var{buffer} defaults to the
+current buffer if omitted.
+
+@example
+@group
+(buffer-size)
+     @result{} 35
+@end group
+@group
+(point-max)
+     @result{} 36
+@end group
+@end example
+@end defun
+
+@defvar buffer-saved-size
+  The value of this buffer-local variable is the former length of the
+current buffer, as of the last time it was read in, saved or auto-saved.
+@end defvar
+
+@node Motion
+@section Motion
+
+  Motion functions change the value of point, either relative to the
+current value of point, relative to the beginning or end of the buffer,
+or relative to the edges of the selected window.  @xref{Point}.
+
+@menu
+* Character Motion::       Moving in terms of characters.
+* Word Motion::            Moving in terms of words.
+* Buffer End Motion::      Moving to the beginning or end of the buffer.
+* Text Lines::             Moving in terms of lines of text.
+* Screen Lines::           Moving in terms of lines as displayed.
+* List Motion::            Moving by parsing lists and sexps.
+* Skipping Characters::    Skipping characters belonging to a certain set.
+@end menu
+
+@node Character Motion
+@subsection Motion by Characters
+
+  These functions move point based on a count of characters.
+@code{goto-char} is the fundamental primitive; the other functions use
+that.
+
+@deffn Command goto-char position &optional buffer
+This function sets point in @code{buffer} to the value @var{position}.
+If @var{position} is less than 1, it moves point to the beginning of the
+buffer.  If @var{position} is greater than the length of the buffer, it
+moves point to the end.  @var{buffer} defaults to the current buffer if
+omitted.
+
+If narrowing is in effect, @var{position} still counts from the
+beginning of the buffer, but point cannot go outside the accessible
+portion.  If @var{position} is out of range, @code{goto-char} moves
+point to the beginning or the end of the accessible portion.
+
+When this function is called interactively, @var{position} is the
+numeric prefix argument, if provided; otherwise it is read from the
+minibuffer.
+
+@code{goto-char} returns @var{position}.
+@end deffn
+
+@deffn Command forward-char &optional count buffer
+@c @kindex beginning-of-buffer
+@c @kindex end-of-buffer
+This function moves point @var{count} characters forward, towards the
+end of the buffer (or backward, towards the beginning of the buffer, if
+@var{count} is negative).  If the function attempts to move point past
+the beginning or end of the buffer (or the limits of the accessible
+portion, when narrowing is in effect), an error is signaled with error
+code @code{beginning-of-buffer} or @code{end-of-buffer}.  @var{buffer}
+defaults to the current buffer if omitted.
+
+
+In an interactive call, @var{count} is the numeric prefix argument.
+@end deffn
+
+@deffn Command backward-char &optional count buffer
+This function moves point @var{count} characters backward, towards the
+beginning of the buffer (or forward, towards the end of the buffer, if
+@var{count} is negative).  If the function attempts to move point past
+the beginning or end of the buffer (or the limits of the accessible
+portion, when narrowing is in effect), an error is signaled with error
+code @code{beginning-of-buffer} or @code{end-of-buffer}.  @var{buffer}
+defaults to the current buffer if omitted.
+
+
+In an interactive call, @var{count} is the numeric prefix argument.
+@end deffn
+
+@node Word Motion
+@subsection Motion by Words
+
+  These functions for parsing words use the syntax table to decide
+whether a given character is part of a word.  @xref{Syntax Tables}.
+
+@deffn Command forward-word count &optional buffer
+This function moves point forward @var{count} words (or backward if
+@var{count} is negative).  Normally it returns @code{t}.  If this motion
+encounters the beginning or end of the buffer, or the limits of the
+accessible portion when narrowing is in effect, point stops there and
+the value is @code{nil}.  @var{buffer} defaults to the current buffer if
+omitted.
+
+In an interactive call, @var{count} is set to the numeric prefix
+argument.
+@end deffn
+
+@deffn Command backward-word count &optional buffer
+This function is just like @code{forward-word}, except that it moves
+backward until encountering the front of a word, rather than forward.
+@var{buffer} defaults to the current buffer if omitted.
+
+In an interactive call, @var{count} is set to the numeric prefix
+argument.
+
+This function is rarely used in programs, as it is more efficient to
+call @code{forward-word} with a negative argument.
+@end deffn
+
+@defvar words-include-escapes
+@c Emacs 19 feature
+This variable affects the behavior of @code{forward-word} and everything
+that uses it.  If it is non-@code{nil}, then characters in the
+``escape'' and ``character quote'' syntax classes count as part of
+words.  Otherwise, they do not.
+@end defvar
+
+@node Buffer End Motion
+@subsection Motion to an End of the Buffer
+
+  To move point to the beginning of the buffer, write:
+
+@example
+@group
+(goto-char (point-min))
+@end group
+@end example
+
+@noindent
+Likewise, to move to the end of the buffer, use:
+
+@example
+@group
+(goto-char (point-max))
+@end group
+@end example
+
+  Here are two commands that users use to do these things.  They are
+documented here to warn you not to use them in Lisp programs, because
+they set the mark and display messages in the echo area.
+
+@deffn Command beginning-of-buffer &optional n
+This function moves point to the beginning of the buffer (or the limits
+of the accessible portion, when narrowing is in effect), setting the
+mark at the previous position.  If @var{n} is non-@code{nil}, then it
+puts point @var{n} tenths of the way from the beginning of the buffer.
+
+In an interactive call, @var{n} is the numeric prefix argument,
+if provided; otherwise @var{n} defaults to @code{nil}.
+
+Don't use this function in Lisp programs!
+@end deffn
+
+@deffn Command end-of-buffer &optional n
+This function moves point to the end of the buffer (or the limits of
+the accessible portion, when narrowing is in effect), setting the mark
+at the previous position.  If @var{n} is non-@code{nil}, then it puts
+point @var{n} tenths of the way from the end of the buffer.
+
+In an interactive call, @var{n} is the numeric prefix argument,
+if provided; otherwise @var{n} defaults to @code{nil}.
+
+Don't use this function in Lisp programs!
+@end deffn
+
+@node Text Lines
+@subsection Motion by Text Lines
+@cindex lines
+
+  Text lines are portions of the buffer delimited by newline characters,
+which are regarded as part of the previous line.  The first text line
+begins at the beginning of the buffer, and the last text line ends at
+the end of the buffer whether or not the last character is a newline.
+The division of the buffer into text lines is not affected by the width
+of the window, by line continuation in display, or by how tabs and
+control characters are displayed.
+
+@deffn Command goto-line line
+This function moves point to the front of the @var{line}th line,
+counting from line 1 at beginning of the buffer.  If @var{line} is less
+than 1, it moves point to the beginning of the buffer.  If @var{line} is
+greater than the number of lines in the buffer, it moves point to the
+end of the buffer---that is, the @emph{end of the last line} of the
+buffer.  This is the only case in which @code{goto-line} does not
+necessarily move to the beginning of a line.
+
+If narrowing is in effect, then @var{line} still counts from the
+beginning of the buffer, but point cannot go outside the accessible
+portion.  So @code{goto-line} moves point to the beginning or end of the
+accessible portion, if the line number specifies an inaccessible
+position.
+
+The return value of @code{goto-line} is the difference between
+@var{line} and the line number of the line to which point actually was
+able to move (in the full buffer, before taking account of narrowing).
+Thus, the value is positive if the scan encounters the real end of the
+buffer.  The value is zero if scan encounters the end of the accessible
+portion but not the real end of the buffer.
+
+In an interactive call, @var{line} is the numeric prefix argument if
+one has been provided.  Otherwise @var{line} is read in the minibuffer.
+@end deffn
+
+@deffn Command beginning-of-line &optional count buffer
+This function moves point to the beginning of the current line.  With an
+argument @var{count} not @code{nil} or 1, it moves forward
+@var{count}@minus{}1 lines and then to the beginning of the line.
+@var{buffer} defaults to the current buffer if omitted.
+
+If this function reaches the end of the buffer (or of the accessible
+portion, if narrowing is in effect), it positions point there.  No error
+is signaled.
+@end deffn
+
+@deffn Command end-of-line &optional count buffer
+This function moves point to the end of the current line.  With an
+argument @var{count} not @code{nil} or 1, it moves forward
+@var{count}@minus{}1 lines and then to the end of the line.
+@var{buffer} defaults to the current buffer if omitted.
+
+If this function reaches the end of the buffer (or of the accessible
+portion, if narrowing is in effect), it positions point there.  No error
+is signaled.
+@end deffn
+
+@deffn Command forward-line &optional count buffer
+@cindex beginning of line
+This function moves point forward @var{count} lines, to the beginning of
+the line.  If @var{count} is negative, it moves point
+@minus{}@var{count} lines backward, to the beginning of a line.  If
+@var{count} is zero, it moves point to the beginning of the current
+line.  @var{buffer} defaults to the current buffer if omitted.
+
+If @code{forward-line} encounters the beginning or end of the buffer (or
+of the accessible portion) before finding that many lines, it sets point
+there.  No error is signaled.
+
+@code{forward-line} returns the difference between @var{count} and the
+number of lines actually moved.  If you attempt to move down five lines
+from the beginning of a buffer that has only three lines, point stops at
+the end of the last line, and the value will be 2.
+
+In an interactive call, @var{count} is the numeric prefix argument.
+@end deffn
+
+@defun count-lines start end
+@cindex lines in region
+This function returns the number of lines between the positions
+@var{start} and @var{end} in the current buffer.  If @var{start} and
+@var{end} are equal, then it returns 0.  Otherwise it returns at least
+1, even if @var{start} and @var{end} are on the same line.  This is
+because the text between them, considered in isolation, must contain at
+least one line unless it is empty.
+
+Here is an example of using @code{count-lines}:
+
+@example
+@group
+(defun current-line ()
+  "Return the vertical position of point@dots{}"
+  (+ (count-lines (window-start) (point))
+     (if (= (current-column) 0) 1 0)
+     -1))
+@end group
+@end example
+@end defun
+
+@ignore
+@c ================
+The @code{previous-line} and @code{next-line} commands are functions
+that should not be used in programs.  They are for users and are
+mentioned here only for completeness.
+
+@deffn Command previous-line count
+@cindex goal column
+This function moves point up @var{count} lines (down if @var{count}
+is negative).  In moving, it attempts to keep point in the ``goal column''
+(normally the same column that it was at the beginning of the move).
+
+If there is no character in the target line exactly under the current
+column, point is positioned after the character in that line which
+spans this column, or at the end of the line if it is not long enough.
+
+If it attempts to move beyond the top or bottom of the buffer (or clipped
+region), then point is positioned in the goal column in the top or
+bottom line.  No error is signaled.
+
+In an interactive call, @var{count} will be the numeric
+prefix argument.
+
+The command @code{set-goal-column} can be used to create a semipermanent
+goal column to which this command always moves.  Then it does not try to
+move vertically.
+
+If you are thinking of using this in a Lisp program, consider using
+@code{forward-line} with a negative argument instead.  It is usually easier
+to use and more reliable (no dependence on goal column, etc.).
+@end deffn
+
+@deffn Command next-line count
+This function moves point down @var{count} lines (up if @var{count}
+is negative).  In moving, it attempts to keep point in the ``goal column''
+(normally the same column that it was at the beginning of the move).
+
+If there is no character in the target line exactly under the current
+column, point is positioned after the character in that line which
+spans this column, or at the end of the line if it is not long enough.
+
+If it attempts to move beyond the top or bottom of the buffer (or clipped
+region), then point is positioned in the goal column in the top or
+bottom line.  No error is signaled.
+
+In the case where the @var{count} is 1, and point is on the last
+line of the buffer (or clipped region), a new empty line is inserted at the
+end of the buffer (or clipped region) and point moved there.
+
+In an interactive call, @var{count} will be the numeric
+prefix argument.
+
+The command @code{set-goal-column} can be used to create a semipermanent
+goal column to which this command always moves.  Then it does not try to
+move vertically.
+
+If you are thinking of using this in a Lisp program, consider using
+@code{forward-line} instead.  It is usually easier
+to use and more reliable (no dependence on goal column, etc.).
+@end deffn
+
+@c ================
+@end ignore
+
+  Also see the functions @code{bolp} and @code{eolp} in @ref{Near Point}.
+These functions do not move point, but test whether it is already at the
+beginning or end of a line.
+
+@node Screen Lines
+@subsection Motion by Screen Lines
+
+  The line functions in the previous section count text lines, delimited
+only by newline characters.  By contrast, these functions count screen
+lines, which are defined by the way the text appears on the screen.  A
+text line is a single screen line if it is short enough to fit the width
+of the selected window, but otherwise it may occupy several screen
+lines.
+
+  In some cases, text lines are truncated on the screen rather than
+continued onto additional screen lines.  In these cases,
+@code{vertical-motion} moves point much like @code{forward-line}.
+@xref{Truncation}.
+
+  Because the width of a given string depends on the flags that control
+the appearance of certain characters, @code{vertical-motion} behaves
+differently, for a given piece of text, depending on the buffer it is
+in, and even on the selected window (because the width, the truncation
+flag, and display table may vary between windows).  @xref{Usual
+Display}.
+
+  These functions scan text to determine where screen lines break, and
+thus take time proportional to the distance scanned.  If you intend to
+use them heavily, Emacs provides caches which may improve the
+performance of your code.  @xref{Text Lines, cache-long-line-scans}.
+
+
+@defun vertical-motion count &optional window pixels
+This function moves point to the start of the frame line @var{count}
+frame lines down from the frame line containing point.  If @var{count}
+is negative, it moves up instead.  The optional second argument
+@var{window} may be used to specify a window other than the 
+selected window in which to perform the motion.
+
+Normally, @code{vertical-motion} returns the number of lines moved.  The
+value may be less in absolute value than @var{count} if the beginning or
+end of the buffer was reached.  If the optional third argument,
+@var{pixels} is non-@code{nil}, the vertical pixel height of the motion
+which took place is returned instead of the actual number of lines
+moved.  A motion of zero lines returns the height of the current line.
+
+Note that @code{vertical-motion} sets @var{window}'s buffer's point, not
+@var{window}'s point. (This differs from FSF Emacs, which buggily always
+sets current buffer's point, regardless of @var{window}.)
+@end defun
+
+@defun vertical-motion-pixels count &optional window how
+This function moves point to the start of the frame line @var{pixels}
+vertical pixels down from the frame line containing point, or up if
+@var{pixels} is negative.  The optional second argument @var{window} is
+the window to move in, and defaults to the selected window.  The
+optional third argument @var{how} specifies the stopping condition.  A
+negative integer indicates that the motion should be no more
+than @var{pixels}.  A positive value indicates that the
+motion should be at least @var{pixels}.  Any other value indicates
+that the motion should be as close as possible to @var{pixels}.
+@end defun
+
+@deffn Command move-to-window-line count &optional window
+This function moves point with respect to the text currently displayed
+in @var{window}, which defaults to the selected window.  It moves point
+to the beginning of the screen line @var{count} screen lines from the
+top of the window.  If @var{count} is negative, that specifies a
+position @w{@minus{}@var{count}} lines from the bottom (or the last line
+of the buffer, if the buffer ends above the specified screen position).
+
+If @var{count} is @code{nil}, then point moves to the beginning of the
+line in the middle of the window.  If the absolute value of @var{count}
+is greater than the size of the window, then point moves to the place
+that would appear on that screen line if the window were tall enough.
+This will probably cause the next redisplay to scroll to bring that
+location onto the screen.
+
+In an interactive call, @var{count} is the numeric prefix argument.
+
+The value returned is the window line number point has moved to, with
+the top line in the window numbered 0.
+@end deffn
+
+@ignore Not in XEmacs
+@defun compute-motion from frompos to topos width offsets window
+This function scans the current buffer, calculating screen positions.
+It scans the buffer forward from position @var{from}, assuming that is
+at screen coordinates @var{frompos}, to position @var{to} or coordinates
+@var{topos}, whichever comes first.  It returns the ending buffer
+position and screen coordinates.
+
+The coordinate arguments @var{frompos} and @var{topos} are cons cells of
+the form @code{(@var{hpos} . @var{vpos})}.
+
+The argument @var{width} is the number of columns available to display
+text; this affects handling of continuation lines.  Use the value
+returned by @code{window-width} for the window of your choice;
+normally, use @code{(window-width @var{window})}.
+
+The argument @var{offsets} is either @code{nil} or a cons cell of the
+form @code{(@var{hscroll} . @var{tab-offset})}.  Here @var{hscroll} is
+the number of columns not being displayed at the left margin; most
+callers get this from @code{window-hscroll}.  Meanwhile,
+@var{tab-offset} is the offset between column numbers on the screen and
+column numbers in the buffer.  This can be nonzero in a continuation
+line, when the previous screen lines' widths do not add up to a multiple
+of @code{tab-width}.  It is always zero in a non-continuation line.
+
+The window @var{window} serves only to specify which display table to
+use.  @code{compute-motion} always operates on the current buffer,
+regardless of what buffer is displayed in @var{window}.
+
+The return value is a list of five elements:
+
+@example
+(@var{pos} @var{vpos} @var{hpos} @var{prevhpos} @var{contin})
+@end example
+
+@noindent
+Here @var{pos} is the buffer position where the scan stopped, @var{vpos}
+is the vertical screen position, and @var{hpos} is the horizontal screen
+position.
+
+The result @var{prevhpos} is the horizontal position one character back
+from @var{pos}.  The result @var{contin} is @code{t} if the last line
+was continued after (or within) the previous character.
+
+For example, to find the buffer position of column @var{col} of line
+@var{line} of a certain window, pass the window's display start location
+as @var{from} and the window's upper-left coordinates as @var{frompos}.
+Pass the buffer's @code{(point-max)} as @var{to}, to limit the scan to
+the end of the accessible portion of the buffer, and pass @var{line} and
+@var{col} as @var{topos}.  Here's a function that does this:
+
+@example
+(defun coordinates-of-position (col line)
+  (car (compute-motion (window-start)
+                       '(0 . 0)
+                       (point-max)
+                       (cons col line)
+                       (window-width)
+                       (cons (window-hscroll) 0)
+                       (selected-window))))
+@end example
+
+When you use @code{compute-motion} for the minibuffer, you need to use
+@code{minibuffer-prompt-width} to get the horizontal position of the
+beginning of the first screen line.  @xref{Minibuffer Misc}.
+@end defun
+@end ignore
+
+@node List Motion
+@subsection Moving over Balanced Expressions 
+@cindex sexp motion
+@cindex Lisp expression motion
+@cindex list motion
+
+  Here are several functions concerned with balanced-parenthesis
+expressions (also called @dfn{sexps} in connection with moving across
+them in XEmacs).  The syntax table controls how these functions interpret
+various characters; see @ref{Syntax Tables}.  @xref{Parsing
+Expressions}, for lower-level primitives for scanning sexps or parts of
+sexps.  For user-level commands, see @ref{Lists and Sexps,,, emacs, XEmacs
+Reference Manual}.
+
+@deffn Command forward-list &optional arg
+This function moves forward across @var{arg} balanced groups of
+parentheses. (Other syntactic entities such as words or paired string
+quotes are ignored.) @var{arg} defaults to 1 if omitted.  If @var{arg}
+is negative, move backward across that many groups of parentheses.
+@end deffn
+
+@deffn Command backward-list &optional arg
+This function moves backward across @var{arg} balanced groups of
+parentheses. (Other syntactic entities such as words or paired string
+quotes are ignored.) @var{arg} defaults to 1 if omitted.  If @var{arg}
+is negative, move forward across that many groups of parentheses.
+@end deffn
+
+@deffn Command up-list arg
+This function moves forward out of @var{arg} levels of parentheses.
+A negative argument means move backward but still to a less deep spot.
+@end deffn
+
+@deffn Command down-list arg
+This function moves forward into @var{arg} levels of parentheses.  A
+negative argument means move backward but still go
+deeper in parentheses (@minus{}@var{arg} levels).
+@end deffn
+
+@deffn Command forward-sexp &optional arg
+This function moves forward across @var{arg} balanced expressions.
+Balanced expressions include both those delimited by parentheses and
+other kinds, such as words and string constants.  @var{arg} defaults to
+1 if omitted.  If @var{arg} is negative, move backward across that many
+balanced expressions.  For example,
+
+@example
+@group
+---------- Buffer: foo ----------
+(concat@point{} "foo " (car x) y z)
+---------- Buffer: foo ----------
+@end group
+
+@group
+(forward-sexp 3)
+     @result{} nil
+
+---------- Buffer: foo ----------
+(concat "foo " (car x) y@point{} z)
+---------- Buffer: foo ----------
+@end group
+@end example
+@end deffn
+
+@deffn Command backward-sexp &optional arg
+This function moves backward across @var{arg} balanced expressions.
+@var{arg} defaults to 1 if omitted.  If @var{arg} is negative, move
+forward across that many balanced expressions.
+@end deffn
+
+@deffn Command beginning-of-defun &optional arg
+This function moves back to the @var{arg}th beginning of a defun.  If
+@var{arg} is negative, this actually moves forward, but it still moves
+to the beginning of a defun, not to the end of one.  @var{arg} defaults
+to 1 if omitted.
+@end deffn
+
+@deffn Command end-of-defun &optional arg
+This function moves forward to the @var{arg}th end of a defun.  If
+@var{arg} is negative, this actually moves backward, but it still moves
+to the end of a defun, not to the beginning of one.  @var{arg} defaults
+to 1 if omitted.
+@end deffn
+
+@defopt defun-prompt-regexp
+If non-@code{nil}, this variable holds a regular expression that
+specifies what text can appear before the open-parenthesis that starts a
+defun.  That is to say, a defun begins on a line that starts with a
+match for this regular expression, followed by a character with
+open-parenthesis syntax.
+@end defopt
+
+@node Skipping Characters
+@subsection Skipping Characters
+@cindex skipping characters
+
+  The following two functions move point over a specified set of
+characters.  For example, they are often used to skip whitespace.  For
+related functions, see @ref{Motion and Syntax}.
+
+@defun skip-chars-forward character-set &optional limit buffer
+This function moves point in @var{buffer} forward, skipping over a
+given set of characters.  It examines the character following point,
+then advances point if the character matches @var{character-set}.  This
+continues until it reaches a character that does not match.  The
+function returns @code{nil}.  @var{buffer} defaults to the current
+buffer if omitted.
+
+The argument @var{character-set} is like the inside of a
+@samp{[@dots{}]} in a regular expression except that @samp{]} is never
+special and @samp{\} quotes @samp{^}, @samp{-} or @samp{\}.  Thus,
+@code{"a-zA-Z"} skips over all letters, stopping before the first
+non-letter, and @code{"^a-zA-Z}" skips non-letters stopping before the
+first letter.  @xref{Regular Expressions}.
+
+If @var{limit} is supplied (it must be a number or a marker), it
+specifies the maximum position in the buffer that point can be skipped
+to.  Point will stop at or before @var{limit}.
+
+In the following example, point is initially located directly before the
+@samp{T}.  After the form is evaluated, point is located at the end of
+that line (between the @samp{t} of @samp{hat} and the newline).  The
+function skips all letters and spaces, but not newlines.
+
+@example
+@group
+---------- Buffer: foo ----------
+I read "@point{}The cat in the hat
+comes back" twice.
+---------- Buffer: foo ----------
+@end group
+
+@group
+(skip-chars-forward "a-zA-Z ")
+     @result{} nil
+
+---------- Buffer: foo ----------
+I read "The cat in the hat@point{}
+comes back" twice.
+---------- Buffer: foo ----------
+@end group
+@end example
+@end defun
+
+@defun skip-chars-backward character-set &optional limit buffer
+This function moves point backward, skipping characters that match
+@var{character-set}, until @var{limit}.  It just like
+@code{skip-chars-forward} except for the direction of motion.
+@end defun
+
+@node Excursions
+@section Excursions
+@cindex excursion
+
+  It is often useful to move point ``temporarily'' within a localized
+portion of the program, or to switch buffers temporarily.  This is
+called an @dfn{excursion}, and it is done with the @code{save-excursion}
+special form.  This construct saves the current buffer and its values of
+point and the mark so they can be restored after the completion of the
+excursion.
+
+  The forms for saving and restoring the configuration of windows are
+described elsewhere (see @ref{Window Configurations} and @pxref{Frame
+Configurations}).
+
+@defspec save-excursion forms@dots{}
+@cindex mark excursion
+@cindex point excursion
+@cindex current buffer excursion
+The @code{save-excursion} special form saves the identity of the current
+buffer and the values of point and the mark in it, evaluates
+@var{forms}, and finally restores the buffer and its saved values of
+point and the mark.  All three saved values are restored even in case of
+an abnormal exit via @code{throw} or error (@pxref{Nonlocal Exits}).
+
+The @code{save-excursion} special form is the standard way to switch
+buffers or move point within one part of a program and avoid affecting
+the rest of the program.  It is used more than 500 times in the Lisp
+sources of XEmacs.
+
+@code{save-excursion} does not save the values of point and the mark for
+other buffers, so changes in other buffers remain in effect after
+@code{save-excursion} exits.
+
+@cindex window excursions
+Likewise, @code{save-excursion} does not restore window-buffer
+correspondences altered by functions such as @code{switch-to-buffer}.
+One way to restore these correspondences, and the selected window, is to
+use @code{save-window-excursion} inside @code{save-excursion}
+(@pxref{Window Configurations}).
+
+The value returned by @code{save-excursion} is the result of the last of
+@var{forms}, or @code{nil} if no @var{forms} are given.
+
+@example
+@group
+(save-excursion
+  @var{forms})
+@equiv{}
+(let ((old-buf (current-buffer))
+      (old-pnt (point-marker))
+      (old-mark (copy-marker (mark-marker))))
+  (unwind-protect
+      (progn @var{forms})
+    (set-buffer old-buf)
+    (goto-char old-pnt)
+    (set-marker (mark-marker) old-mark)))
+@end group
+@end example
+@end defspec
+
+@defspec save-current-buffer forms@dots{}
+This special form is similar to @code{save-excursion} but it only
+saves and restores the current buffer.  Beginning with XEmacs 20.3,
+@code{save-current-buffer} is a primitive.
+@end defspec
+
+@defspec with-current-buffer buffer forms@dots{}
+This special form evaluates @var{forms} with @var{buffer} as the current
+buffer.  It returns the value of the last form.
+@end defspec
+
+@defspec with-temp-file file forms@dots{}
+This special form creates a new buffer, evaluates @var{forms} there, and
+writes the buffer to @var{file}.  It returns the value of the last form
+evaluated.
+@end defspec
+
+@defspec save-selected-window forms@dots{}
+This special form is similar to @code{save-excursion} but it saves and
+restores the selected window and nothing else.
+@end defspec
+
+@node Narrowing
+@section Narrowing
+@cindex narrowing
+@cindex restriction (in a buffer)
+@cindex accessible portion (of a buffer)
+
+  @dfn{Narrowing} means limiting the text addressable by XEmacs editing
+commands to a limited range of characters in a buffer.  The text that
+remains addressable is called the @dfn{accessible portion} of the
+buffer.
+
+  Narrowing is specified with two buffer positions which become the
+beginning and end of the accessible portion.  For most editing commands
+and most Emacs primitives, these positions replace the values of the
+beginning and end of the buffer.  While narrowing is in effect, no text
+outside the accessible portion is displayed, and point cannot move
+outside the accessible portion.
+
+  Values such as positions or line numbers, which usually count from the
+beginning of the buffer, do so despite narrowing, but the functions
+which use them refuse to operate on text that is inaccessible.
+
+  The commands for saving buffers are unaffected by narrowing; they save
+the entire buffer regardless of any narrowing.
+
+@deffn Command narrow-to-region start end &optional buffer
+This function sets the accessible portion of @var{buffer} to start at
+@var{start} and end at @var{end}.  Both arguments should be character
+positions.  @var{buffer} defaults to the current buffer if omitted.
+
+In an interactive call, @var{start} and @var{end} are set to the bounds
+of the current region (point and the mark, with the smallest first).
+@end deffn
+
+@deffn Command narrow-to-page &optional move-count
+This function sets the accessible portion of the current buffer to
+include just the current page.  An optional first argument
+@var{move-count} non-@code{nil} means to move forward or backward by
+@var{move-count} pages and then narrow.  The variable
+@code{page-delimiter} specifies where pages start and end
+(@pxref{Standard Regexps}).
+
+In an interactive call, @var{move-count} is set to the numeric prefix
+argument.
+@end deffn
+
+@deffn Command widen &optional buffer
+@cindex widening
+This function cancels any narrowing in @var{buffer}, so that the
+entire contents are accessible.  This is called @dfn{widening}.
+It is equivalent to the following expression:
+
+@example
+(narrow-to-region 1 (1+ (buffer-size)))
+@end example
+
+@var{buffer} defaults to the current buffer if omitted.
+@end deffn
+
+@defspec save-restriction body@dots{}
+This special form saves the current bounds of the accessible portion,
+evaluates the @var{body} forms, and finally restores the saved bounds,
+thus restoring the same state of narrowing (or absence thereof) formerly
+in effect.  The state of narrowing is restored even in the event of an
+abnormal exit via @code{throw} or error (@pxref{Nonlocal Exits}).
+Therefore, this construct is a clean way to narrow a buffer temporarily.
+
+The value returned by @code{save-restriction} is that returned by the
+last form in @var{body}, or @code{nil} if no body forms were given.
+
+@c Wordy to avoid overfull hbox.  --rjc 16mar92
+@strong{Caution:} it is easy to make a mistake when using the
+@code{save-restriction} construct.  Read the entire description here
+before you try it.
+
+If @var{body} changes the current buffer, @code{save-restriction} still
+restores the restrictions on the original buffer (the buffer whose
+restrictions it saved from), but it does not restore the identity of the
+current buffer.
+
+@code{save-restriction} does @emph{not} restore point and the mark; use
+@code{save-excursion} for that.  If you use both @code{save-restriction}
+and @code{save-excursion} together, @code{save-excursion} should come
+first (on the outside).  Otherwise, the old point value would be
+restored with temporary narrowing still in effect.  If the old point
+value were outside the limits of the temporary narrowing, this would
+fail to restore it accurately.
+
+The @code{save-restriction} special form records the values of the
+beginning and end of the accessible portion as distances from the
+beginning and end of the buffer.  In other words, it records the amount
+of inaccessible text before and after the accessible portion.
+
+This method yields correct results if @var{body} does further narrowing.
+However, @code{save-restriction} can become confused if the body widens
+and then make changes outside the range of the saved narrowing.  When
+this is what you want to do, @code{save-restriction} is not the right
+tool for the job.  Here is what you must use instead:
+
+@example
+@group
+(let ((beg (point-min-marker))
+      (end (point-max-marker)))
+  (unwind-protect
+      (progn @var{body})
+    (save-excursion
+      (set-buffer (marker-buffer beg))
+      (narrow-to-region beg end))))
+@end group
+@end example
+
+Here is a simple example of correct use of @code{save-restriction}:
+
+@example
+@group
+---------- Buffer: foo ----------
+This is the contents of foo
+This is the contents of foo
+This is the contents of foo@point{}
+---------- Buffer: foo ----------
+@end group
+
+@group
+(save-excursion
+  (save-restriction
+    (goto-char 1)
+    (forward-line 2)
+    (narrow-to-region 1 (point))
+    (goto-char (point-min))
+    (replace-string "foo" "bar")))
+
+---------- Buffer: foo ----------
+This is the contents of bar
+This is the contents of bar
+This is the contents of foo@point{}
+---------- Buffer: foo ----------
+@end group
+@end example
+@end defspec