@c -*-texinfo-*-
@c This is part of the GNU Emacs Lisp Reference Manual.
-@c Copyright (C) 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
+@c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000, 2001
+@c Free Software Foundation, Inc.
@c See the file elisp.texi for copying conditions.
@setfilename ../info/positions
@node Positions, Markers, Frames, Top
automatically when text is inserted or deleted so they stay with the
surrounding characters. @xref{Markers}.
+ See also the ``field'' feature (@pxref{Fields}), which provides
+functions that are used by many cursur-motion commands.
+
@menu
* Point:: The special position where editing takes place.
* Motion:: Changing point.
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).
+ The value of point is a number no less than 1, and no greater than 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,
This function returns the maximum accessible value of point in the
current buffer. This is @code{(1+ (buffer-size))}, unless narrowing is
in effect, in which case it is the position of the end of the region
-that you narrowed to. (@xref{Narrowing}).
+that you narrowed to. (@xref{Narrowing}.)
@end defun
@defun buffer-end flag
@code{(point-max)} otherwise. The argument @var{flag} must be a number.
@end defun
-@defun buffer-size
+@defun buffer-size &optional buffer
This function returns the total number of characters in the current
buffer. In the absence of any narrowing (@pxref{Narrowing}),
@code{point-max} returns a value one larger than this.
+If you specify a buffer, @var{buffer}, then the value is the
+size of @var{buffer}.
+
@example
@group
(buffer-size)
@deffn Command forward-word count
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}.
-
-In an interactive call, @var{count} is set to the numeric prefix
+@var{count} is negative). ``Moving one word'' means moving until point
+crosses a word-constituent character and then encounters a
+word-separator character. However, this function cannot move point past
+the boundary of the accessible portion of the buffer, or across a field
+boundary (@pxref{Fields}). The most common case of a field boundary is
+the end of the prompt in the minibuffer.
+
+If it is possible to move @var{count} words, without being stopped
+prematurely by the buffer boundary or a field boundary, the value is
+@code{t}. Otherwise, the return value is @code{nil} and point stops at
+the buffer boundary or field boundary.
+
+If @code{inhibit-field-text-motion} is non-@code{nil},
+this function ignores field boundaries.
+
+In an interactive call, @var{count} is specified by the numeric prefix
argument.
@end deffn
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.
+@c [Now optimized by compiler.]
+@c This function is rarely used in programs, as it is more efficient to
+@c call @code{forward-word} with a negative argument.
@end deffn
@defvar words-include-escapes
words. Otherwise, they do not.
@end defvar
+@defvar inhibit-field-text-motion
+@tindex inhibit-field-text-motion
+If this variable is non-@code{nil}, certain motion functions including
+@code{forward-word}, @code{forward-sentence}, and
+@code{forward-paragraph} ignore field boundaries.
+@end defvar
+
@node Buffer End Motion
@subsection Motion to an End of the Buffer
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.
+puts point @var{n} tenths of the way from the beginning of the
+accessible portion 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!
+@strong{Warning:} 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.
+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 accessible portion 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!
+@strong{Warning:} Don't use this function in Lisp programs!
@end deffn
@node Text Lines
@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.
+buffer before finding the specified line. 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.
argument @var{count} not @code{nil} or 1, it moves forward
@var{count}@minus{}1 lines and then to the beginning of the line.
+This function does not move point across a field boundary
+(@pxref{Fields}) unless doing so would move beyond there to a
+different line; therefore, if @var{count} is @code{nil} or 1, and
+point starts at a field boundary, point does not move. To ignore
+field boundaries, either bind @code{inhibit-field-text-motion} to
+@code{t}, or use the @code{forward-line} function instead. For
+instance, @code{(forward-line 0)} does the same thing as
+@code{(beginning-of-line)}, except that it ignores field boundaries.
+
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
+@defun line-beginning-position &optional count
+@tindex line-beginning-position
+Return the position that @code{(beginning-of-line @var{count})}
+would move to.
+@end defun
+
@deffn Command end-of-line &optional count
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.
+This function does not move point across a field boundary
+(@pxref{Fields}) unless doing so would move beyond there to a
+different line; therefore, if @var{count} is @code{nil} or 1, and
+point starts at a field boundary, point does not move. To ignore
+field boundaries, bind @code{inhibit-field-text-motion} to @code{t}.
+
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
+@defun line-end-position &optional count
+@tindex line-end-position
+Return the position that @code{(end-of-line @var{count})}
+would move to.
+@end defun
+
@deffn Command forward-line &optional count
@cindex beginning of line
This function moves point forward @var{count} lines, to the beginning of
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}.
-
+performance of your code. @xref{Truncation, cache-long-line-scans}.
@defun vertical-motion count &optional window
This function moves point to the start of the screen line @var{count}
screen lines down from the screen line containing point. If @var{count}
is negative, it moves up instead.
-@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.
+@code{vertical-motion} returns the number of screen lines over which it
+moved point. The value may be less in absolute value than @var{count}
+if the beginning or end of the buffer was reached.
The window @var{window} is used for obtaining parameters such as the
width, the horizontal scrolling, and the display table. But
@var{window} currently displays some other buffer.
@end defun
+@defun count-screen-lines &optional beg end count-final-newline window
+This function returns the number of screen lines in the text from
+@var{beg} to @var{end}. The number of screen lines may be different
+from the number of actual lines, due to line continuation, the display
+table, etc. If @var{beg} and @var{end} are @code{nil} or omitted,
+they default to the beginning and end of the accessible portion of the
+buffer.
+
+If the region ends with a newline, that is ignored unless the optional
+third argument @var{count-final-newline} is non-@code{nil}.
+
+The optional fourth argument @var{window} specifies the window for
+obtaining parameters such as width, horizontal scrolling, and so on.
+The default is to use the selected window's parameters.
+
+Like @code{vertical-motion}, @code{count-screen-lines} always uses the
+current buffer, regardless of which buffer is displayed in
+@var{window}. This makes possible to use @code{count-screen-lines} in
+any buffer, whether or not it is currently displayed in some window.
+@end defun
+
@deffn Command move-to-window-line count
This function moves point with respect to the text currently displayed
in the selected window. It moves point to the beginning of the screen
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,
+callers get this by calling @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
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
+For example, to find the buffer position of column @var{col} of screen 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
them in Emacs). 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, GNU
+sexps. For user-level commands, see @ref{Lists Commands,,, emacs, The GNU
Emacs Manual}.
-@deffn Command forward-list arg
-This function moves forward across @var{arg} balanced groups of
+@deffn Command forward-list &optional arg
+This function moves forward across @var{arg} (default 1) balanced groups of
parentheses. (Other syntactic entities such as words or paired string
quotes are ignored.)
@end deffn
-@deffn Command backward-list arg
-This function moves backward across @var{arg} balanced groups of
+@deffn Command backward-list &optional arg
+This function moves backward across @var{arg} (default 1) balanced groups of
parentheses. (Other syntactic entities such as words or paired string
quotes are ignored.)
@end deffn
-@deffn Command up-list arg
-This function moves forward out of @var{arg} levels of parentheses.
+@deffn Command up-list &optional arg
+This function moves forward out of @var{arg} (default 1) 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
+@deffn Command down-list &optional arg
+This function moves forward into @var{arg} (default 1) 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 arg
-This function moves forward across @var{arg} balanced expressions.
+@deffn Command forward-sexp &optional arg
+This function moves forward across @var{arg} (default 1) balanced expressions.
Balanced expressions include both those delimited by parentheses and
-other kinds, such as words and string constants. For example,
+other kinds, such as words and string constants
+@xref{Parsing Expressions}. For example,
@example
@group
@end example
@end deffn
-@deffn Command backward-sexp arg
-This function moves backward across @var{arg} balanced expressions.
+@deffn Command backward-sexp &optional arg
+This function moves backward across @var{arg} (default 1) balanced expressions.
@end deffn
@deffn Command beginning-of-defun arg
open-parenthesis syntax.
@end defopt
+@defopt open-paren-in-column-0-is-defun-start
+If this variable's value is non-@code{nil}, an open parenthesis in
+column 0 is considered to be the start of a defun. If it is
+@code{nil}, an open parenthesis in column 0 has no special meaning.
+The default is @code{t}.
+@end defopt
+
+@defvar beginning-of-defun-function
+@tindex beginning-of-defun-function
+If non-@code{nil}, this variable holds a function for finding the
+beginning of a defun. The function @code{beginning-of-defun}
+calls this function instead of using its normal method.
+@end defvar
+
+@defvar end-of-defun-function
+@tindex end-of-defun-function
+If non-@code{nil}, this variable holds a function for finding the end of
+a defun. The function @code{end-of-defun} calls this function instead
+of using its normal method.
+@end defvar
+
@node Skipping Characters
@comment node-name, next, previous, up
@subsection Skipping Characters
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}.
+function returns the number of characters moved over.
The argument @var{character-set} is like the inside of a
@samp{[@dots{}]} in a regular expression except that @samp{]} is never
@defun skip-chars-backward character-set &optional limit
This function moves point backward, skipping characters that match
-@var{character-set}, until @var{limit}. It just like
+@var{character-set}, until @var{limit}. It is just like
@code{skip-chars-forward} except for the direction of motion.
+
+The return value indicates the distance traveled. It is an integer that
+is zero or less.
@end defun
@node Excursions
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.
+special form. This construct initially remembers the identity of the
+current buffer, and its values of point and the mark, and restores them
+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
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
+the rest of the program. It is used more than 4000 times in the Lisp
sources of Emacs.
@code{save-excursion} does not save the values of point and the mark for
@example
@group
-(save-excursion
- @var{forms})
+(save-excursion @var{forms})
@equiv{}
(let ((old-buf (current-buffer))
(old-pnt (point-marker))
+@end group
(old-mark (copy-marker (mark-marker))))
(unwind-protect
(progn @var{forms})
(set-buffer old-buf)
+@group
(goto-char old-pnt)
(set-marker (mark-marker) old-mark)))
@end group
@end example
@end defspec
+ @strong{Warning:} Ordinary insertion of text adjacent to the saved
+point value relocates the saved value, just as it relocates all markers.
+Therefore, when the saved point value is restored, it normally comes
+before the inserted text.
+
+ Although @code{save-excursion} saves the location of the mark, it does
+not prevent functions which modify the buffer from setting
+@code{deactivate-mark}, and thus causing the deactivation of the mark
+after the command finishes. @xref{The Mark}.
+
@node Narrowing
@section Narrowing
@cindex narrowing
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
+@var{move-count} pages and then narrow to one page. The variable
@code{page-delimiter} specifies where pages start and end
(@pxref{Standard Regexps}).
If @var{body} changes the current buffer, @code{save-restriction} still
restores the restrictions on the original buffer (the buffer whose
-restructions it saved from), but it does not restore the identity of the
+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
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