@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, Motion, Positions, Positions
@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, Excursions, Point, Positions
@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, Word Motion, Motion, 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, Buffer End Motion, Character Motion, 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 &optional count 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{count} defaults to @code{1} and @var{buffer} defaults to the
current buffer.

In an interactive call, @var{count} is set to the numeric prefix
argument.
@end deffn

@deffn Command backward-word &optional count 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.
@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, Text Lines, Word Motion, 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 count
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{count} is non-@code{nil}, then it
puts point @var{count} tenths of the way from the beginning of the buffer.

In an interactive call, @var{count} is the numeric prefix argument,
if provided; otherwise @var{count} defaults to @code{nil}.

Don't use this function in Lisp programs!
@end deffn

@deffn Command end-of-buffer &optional count
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{count} is non-@code{nil}, then it puts
point @var{count} tenths of the way from the end of the buffer.

In an interactive call, @var{count} is the numeric prefix argument,
if provided; otherwise @var{count} defaults to @code{nil}.

Don't use this function in Lisp programs!
@end deffn

@node Text Lines, Screen Lines, Buffer End Motion, Motion
@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 &optional ignore-invisible-lines-flag
@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.

With optional @var{ignore-invisible-lines-flag} non-@code{nil}, lines
collapsed with selective-display are excluded from the line count.

@strong{N.B.} The expression to return the current line number is not
obvious:

@example
(1+ (count-lines 1 (point-at-bol)))
@end example

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, List Motion, Text Lines, Motion
@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 fixnum 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, Skipping Characters, Screen Lines, 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,,, xemacs, 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 count
This function moves backward across @var{count} balanced groups of
parentheses. (Other syntactic entities such as words or paired string
quotes are ignored.) @var{count} defaults to 1 if omitted.  If
@var{count} is negative, move forward across that many groups of
parentheses.
@end deffn

@deffn Command up-list &optional count
This function moves forward out of @var{count} levels of parentheses.
A negative argument means move backward but still to a less deep spot.
@end deffn

@deffn Command down-list &optional count
This function moves forward into @var{count} levels of parentheses.
A negative argument means move backward but still go deeper in
parentheses (@minus{}@var{count} levels).
@end deffn

@deffn Command forward-sexp &optional count
This function moves forward across @var{count} balanced expressions.
Balanced expressions include both those delimited by parentheses and
other kinds, such as words and string constants.  @var{count} defaults to
1 if omitted.  If @var{count} 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 count
This function moves backward across @var{count} balanced expressions.
@var{count} defaults to 1 if omitted.  If @var{count} is negative, move
forward across that many balanced expressions.
@end deffn

@deffn Command beginning-of-defun &optional count
This function moves back to the @var{count}th beginning of a defun.
If @var{count} is negative, this actually moves forward, but it still
moves to the beginning of a defun, not to the end of one.  @var{count}
defaults to 1 if omitted.
@end deffn

@deffn Command end-of-defun &optional count
This function moves forward to the @var{count}th end of a defun.
If @var{count} is negative, this actually moves backward, but it still
moves to the end of a defun, not to the beginning of one.  @var{count}
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,  , List Motion, Motion
@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, Narrowing, Motion, Positions
@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 operator.  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}).

@deffn {Special Operator} save-excursion forms@dots{}
@cindex mark excursion
@cindex point excursion
@cindex current buffer excursion
The @code{save-excursion} special operator 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 operator 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 deffn

@deffn {Special Operator} save-current-buffer forms@dots{}
This special operator 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 deffn

@defmac with-current-buffer buffer forms@dots{}
This macro evaluates @var{forms} with @var{buffer} as the current
buffer.  It returns the value of the last form.
@end defmac

@defmac with-temp-file filename forms@dots{}
This macro creates a new buffer, evaluates @var{forms} there, and
writes the buffer to @var{filename}.  It returns the value of the last form
evaluated.
@end defmac

@defmac save-selected-window forms@dots{}
This macro is similar to @code{save-excursion} but it saves and
restores the selected window and nothing else.
@end defmac

@node Narrowing,  , Excursions, Positions
@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

@deffn {Special Operator} save-restriction body@dots{}
This special operator 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 operator 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 ((start (point-min-marker))
      (end (point-max-marker)))
  (unwind-protect
      (progn @var{body})
    (save-excursion
      (set-buffer (marker-buffer start))
      (narrow-to-region start 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 deffn
