@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
@chapter Positions
@cindex position (in buffer)
- A @dfn{position} is the index of a character in the text of 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, the
-we often speak of the character ``at'' a position, meaning the character
+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 which relocate
+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}.
+surrounding characters. Functions that expect an argument to be a
+position (an integer), but accept a marker as a substitute, normally
+ignore the marker buffer. Of course, markers used this way usually
+point to a position in the buffer that the function operates on, but
+that is entirely the programmer's responsibility. @xref{Markers}.
+
+ See also the ``field'' feature (@pxref{Fields}), which provides
+functions that are used by many cursor-motion commands.
@menu
* Point:: The special position where editing takes place.
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. Many terminals display the cursor over the
-character that immediately follows point; on such terminals, point is
-actually before the character on which the cursor sits.
+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).
+ 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,
@defun point
@cindex current buffer position
- This function returns the position of point in the current buffer,
+This function returns the value of point in the current buffer,
as an integer.
@need 700
@end defun
@defun point-min
- This function returns the minimum accessible value of point in the
-current buffer. This is 1, unless narrowing is in effect, in
-which case it is the position of the start of the region that you
-narrowed to. (@xref{Narrowing}.)
+This function returns the minimum accessible value of point in the
+current 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}.)
@end defun
@defun point-max
- This function returns the maximum accessible value of point in the
+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
- This function returns @code{(point-min)} if @var{flag} is less than 1,
-@code{(point-max)} otherwise. The argument @var{flag} must be a number.
+This function returns @code{(point-max)} if @var{flag} is greater than
+0, @code{(point-min)} otherwise. The argument @var{flag} must be a
+number.
@end defun
-@defun buffer-size
- This function returns the total number of characters in the current
+@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)
* 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.
-* Vertical Motion:: Implementation of @code{next-line} and
- @code{previous-line}.
* List Motion:: Moving by parsing lists and sexps.
* Skipping Characters:: Skipping characters belonging to a certain set.
@end menu
@subsection Motion by Characters
These functions move point based on a count of characters.
-@code{goto-char} is the fundamental primitive; the functions others use
+@code{goto-char} is the fundamental primitive; the other functions use
that.
@deffn Command goto-char position
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
+@deffn Command forward-word &optional 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
-argument.
+@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. If @var{count} is omitted or @code{nil}, it defaults to 1.
@end deffn
-@deffn Command backward-word count
-This function just like @code{forward-word}, except that it moves
+@deffn Command backward-word &optional count
+This function is just like @code{forward-word}, except that it moves
backward until encountering the front of a word, rather than forward.
-
-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 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
@end group
@end example
- Here are two commands which users use to do these things. They are
+ 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.
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.
+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
@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 buffer. If @var{line} is less than
-1, it moves point to the beginning of the buffer. If @var{line} is
+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
-@emph{end of the last line} of the buffer.
+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
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 move (in the full buffer, disregarding any narrowing). Thus, the
-value is positive if the scan encounters the real end of the buffer.
+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 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 at the end of
-the buffer. No error is signaled.
+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 at the end of
-the buffer. No error is signaled.
+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
the line. If @var{count} is negative, it moves point
-@minus{}@var{count} lines backward, to the beginning of the line.
+@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.
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
(defun current-line ()
"Return the vertical position of point@dots{}"
(+ (count-lines (window-start) (point))
- (if (= (current-column) 0) 1 0)
- -1))
+ (if (= (current-column) 0) 1 0)))
@end group
@end example
@end defun
+@defun line-number-at-pos &optional pos
+@cindex line number
+This function returns the line number in the current buffer
+corresponding the buffer position @var{pos}. If @var{pos} is @code{nil}
+or omitted, the current buffer position is used.
+@end defun
+
@ignore
@c ================
The @code{previous-line} and @code{next-line} commands are functions
@code{vertical-motion} moves point much like @code{forward-line}.
@xref{Truncation}.
- Because the width of a given string depends on the flags which control
+ 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{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
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 else the last line of
-the buffer, if the buffer ends above the specified screen 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
-which would appear on that screen line if the window were tall enough.
+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, with the top line in the
-window numbered 0.
+The value returned is the window line number point has moved to, with
+the top line in the window numbered 0.
@end deffn
@defun compute-motion from frompos to topos width offsets window
-This function scan through the current buffer, calculating screen
-position. It scans the current 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.
+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.
+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,
+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
of @code{tab-width}. It is always zero in a non-continuation line.
-The window @var{window} serves to specify which display table to use;
-that is its only effect. @code{compute-motion} always operates on the
-current buffer, regardless of what buffer is displayed in @var{window}.
+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})
+(@var{pos} @var{hpos} @var{vpos} @var{prevhpos} @var{contin})
@end example
@noindent
Here @var{pos} is the buffer position where the scan stopped, @var{vpos}
-is the vertical position, and @var{hpos} is the horizontal position.
+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 a line was
-continued after (or within) the previous character.
+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
-the end of the visible section of the buffer, and pass @var{line} and
+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)
+ (point-max)
(cons col line)
(window-width)
- (cons (window-hscroll) 0))))
+ (cons (window-hscroll) 0)
+ (selected-window))))
@end example
When you use @code{compute-motion} for the minibuffer, you need to use
beginning of the first screen line. @xref{Minibuffer Misc}.
@end defun
-@node Vertical Motion
-@comment node-name, next, previous, up
-@subsection The User-Level Vertical Motion Commands
-@cindex goal column
-@cindex vertical text line motion
-@findex next-line
-@findex previous-line
-
- A goal column is useful if you want to edit text such as a table in
-which you want to move point to a certain column on each line. The goal
-column affects the vertical text line motion commands, @code{next-line}
-and @code{previous-line}. @xref{Basic,, Basic Editing Commands, emacs,
-The GNU Emacs Manual}.
-
-@defopt goal-column
-This variable holds an explicitly specified goal column for vertical
-line motion commands. If it is an integer, it specifies a column, and
-these commands try to move to that column on each line. If it is
-@code{nil}, then the commands set their own goal columns. Any other
-value is invalid.
-@end defopt
-
-@defvar temporary-goal-column
-This variable holds the temporary goal column during a sequence of
-consecutive vertical line motion commands. It is overridden by
-@code{goal-column} if that is non-@code{nil}. It is set each time a
-vertical motion command is invoked, unless the previous command was also
-a vertical motion command.
-@end defvar
-
-@defopt track-eol
-This variable controls how the vertical line motion commands operate
-when starting at the end of a line. If @code{track-eol} is
-non-@code{nil}, then vertical motion starting at the end of a line will
-keep to the ends of lines. This means moving to the end of each line
-moved onto. The value of @code{track-eol} has no effect if point is not
-at the end of a line when the first vertical motion command is given.
-
-@code{track-eol} has its effect by telling line motion commands to set
-@code{temporary-goal-column} to 9999 instead of to the current column.
-@end defopt
-
@node List Motion
@comment node-name, next, previous, up
-@subsection Moving over Balanced Expressions
+@subsection Moving over Balanced Expressions
@cindex sexp motion
@cindex Lisp expression motion
@cindex list motion
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
-Emacs Manual}.
+sexps. For user-level commands, see @ref{Parentheses,, Commands for
+Editing with Parentheses, 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 down @var{arg} levels of parentheses. A
-negative argument means move backward but still go down @var{arg}
-levels.
+@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
+@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.
@end deffn
-@deffn Command end-of-defun arg
-Move 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.
+@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.
@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, the a defun begins on a line which starts
-with a match for this regular expression, followed by a character
-with open-parenthesis syntax.
+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
+@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
characters. For example, they are often used to skip whitespace. For
related functions, see @ref{Motion and Syntax}.
+These functions convert the set string to multibyte if the buffer is
+multibyte, and they convert it to unibyte if the buffer is unibyte, as
+the search functions do (@pxref{Searching and Matching}).
+
@defun skip-chars-forward character-set &optional limit
This function moves point in the current 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}.
+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
special and @samp{\} quotes @samp{^}, @samp{-} or @samp{\}. Thus,
@code{"a-zA-Z"} skips over all letters, stopping before the first
-nonletter, and @code{"^a-zA-Z}" skips nonletters stopping before the
+nonletter, and @code{"^a-zA-Z"} skips nonletters stopping before the
first letter. @xref{Regular Expressions}.
If @var{limit} is supplied (it must be a number or a marker), it
---------- Buffer: foo ----------
@end group
@end example
+
+Note that char classes are not currently supported in
+@var{character-set}; they will be treated as literals. Thus you
+cannot use @code{"[:alpha:]"} instead of @code{"a-zA-Z"} to include
+non-@acronym{ASCII} letters. A way to skip forward over all letters is:
+
+@example
+(re-search-forward "\\=[[:alpha:]]*" nil t)
+@end example
@end defun
@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
@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 throw or error (@pxref{Nonlocal Exits}).
+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
+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.
+More precisely, the saved value is a marker with insertion type
+@code{nil}. @xref{Marker Insertion Types}. 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
outside the accessible portion is displayed, and point cannot move
outside the accessible portion.
- Values such as positions or line numbers, that usually count from the
+ 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 the any narrowing.
+the entire buffer regardless of any narrowing.
@deffn Command narrow-to-region start end
This function sets the accessible portion of the current buffer to start
of the current region (point and the mark, with the smallest first).
@end deffn
-@deffn Command narrow-to-page move-count
+@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
+@var{move-count} pages and then narrow to one page. The variable
@code{page-delimiter} specifies where pages start and end
(@pxref{Standard Regexps}).
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 throw or error (@pxref{Nonlocal Exits}). Therefore,
-this construct is a clean way to narrow a buffer temporarily.
+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.
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
@end group
@end example
@end defspec
+
+@ignore
+ arch-tag: 56e8ff26-4ffe-4832-a141-7e991a2d0f87
+@end ignore
HCoop / bpt / emacs.git / blobdiff