@c -*-texinfo-*-@c This is part of the GNU Emacs Lisp Reference Manual.@c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000@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 a buffer.More precisely, a position identifies the place between two characters(or before the first character, or after the last character), so we canspeak of the character before or after a given position. However, weoften speak of the character ``at'' a position, meaning the characterafter that position. Positions are usually represented as integers starting from 1, but canalso be represented as @dfn{markers}---special objects that relocateautomatically when text is inserted or deleted so they stay with thesurrounding characters. @xref{Markers}. See also the ``field'' feature (@pxref{Fields}), which providesfunctions that are used by many cursur-motion commands.@menu* Point:: The special position where editing takes place.* Motion:: Changing point.* Excursions:: Temporary motion and buffer changes.* Narrowing:: Restricting editing to a portion of the buffer.@end menu@node Point@section Point@cindex point @dfn{Point} is a special buffer position used by many editingcommands, including the self-inserting typed characters and textinsertion functions. Other commands move point through the textto 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), ratherthan a particular character. Usually terminals display the cursor overthe character that immediately follows point; point is actually beforethe character on which the cursor sits.@cindex point with narrowing The value of point is a number no less than 1, and no greater than thebuffer size plus 1. If narrowing is in effect (@pxref{Narrowing}), thenpoint 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 thevalue 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 samebuffer. This is why point can have different values in various windowsthat 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 moredetails.@defun point@cindex current buffer positionThis function returns the value of point in the current buffer,as an integer.@need 700@example@group(point) @result{} 175@end group@end example@end defun@defun point-minThis function returns the minimum accessible value of point in thecurrent buffer. This is normally 1, but if narrowing is in effect, itis the position of the start of the region that you narrowed to.(@xref{Narrowing}.)@end defun@defun point-maxThis function returns the maximum accessible value of point in thecurrent buffer. This is @code{(1+ (buffer-size))}, unless narrowing isin effect, in which case it is the position of the end of the regionthat you narrowed to. (@xref{Narrowing}.)@end defun@defun buffer-end flagThis function returns @code{(point-min)} if @var{flag} is less than 1,@code{(point-max)} otherwise. The argument @var{flag} must be a number.@end defun@defun buffer-size &optional bufferThis function returns the total number of characters in the currentbuffer. 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 thesize of @var{buffer}.@example@group(buffer-size) @result{} 35@end group@group(point-max) @result{} 36@end group@end example@end defun@node Motion@section Motion Motion functions change the value of point, either relative to thecurrent value of point, relative to the beginning or end of the buffer,or relative to the edges of the selected window. @xref{Point}.@menu* Character Motion:: Moving in terms of characters.* Word Motion:: Moving in terms of words.* Buffer End Motion:: Moving to the beginning or end of the buffer.* Text Lines:: Moving in terms of lines of text.* Screen Lines:: Moving in terms of lines as displayed.* List Motion:: Moving by parsing lists and sexps.* Skipping Characters:: Skipping characters belonging to a certain set.@end menu@node Character Motion@subsection Motion by Characters These functions move point based on a count of characters.@code{goto-char} is the fundamental primitive; the other functions usethat.@deffn Command goto-char positionThis function sets point in the current buffer to the value@var{position}. If @var{position} is less than 1, it moves point to thebeginning of the buffer. If @var{position} is greater than the lengthof the buffer, it moves point to the end.If narrowing is in effect, @var{position} still counts from thebeginning of the buffer, but point cannot go outside the accessibleportion. If @var{position} is out of range, @code{goto-char} movespoint to the beginning or the end of the accessible portion.When this function is called interactively, @var{position} is thenumeric prefix argument, if provided; otherwise it is read from theminibuffer.@code{goto-char} returns @var{position}.@end deffn@deffn Command forward-char &optional count@c @kindex beginning-of-buffer@c @kindex end-of-bufferThis function moves point @var{count} characters forward, towards theend of the buffer (or backward, towards the beginning of the buffer, if@var{count} is negative). If the function attempts to move point pastthe beginning or end of the buffer (or the limits of the accessibleportion, when narrowing is in effect), an error is signaled with errorcode @code{beginning-of-buffer} or @code{end-of-buffer}.In an interactive call, @var{count} is the numeric prefix argument.@end deffn@deffn Command backward-char &optional countThis function moves point @var{count} characters backward, towards thebeginning of the buffer (or forward, towards the end of the buffer, if@var{count} is negative). If the function attempts to move point pastthe beginning or end of the buffer (or the limits of the accessibleportion, when narrowing is in effect), an error is signaled with errorcode @code{beginning-of-buffer} or @code{end-of-buffer}.In an interactive call, @var{count} is the numeric prefix argument.@end deffn@node Word Motion@subsection Motion by Words These functions for parsing words use the syntax table to decidewhether a given character is part of a word. @xref{Syntax Tables}.@deffn Command forward-word countThis function moves point forward @var{count} words (or backward if@var{count} is negative). ``Moving one word'' means moving until pointcrosses a word-constituent character and then encounters aword-separator character. However, this function cannot move point pastthe boundary of the accessible part of the buffer, or across a fieldboundary (@pxref{Fields}). The most common case of a field boundary isthe end of the prompt in the minibuffer.If it is possible to move @var{count} words, without being stoppedprematurely by the buffer boundary or a field boundary, the value is@code{t}. Otherwise, the return value is @code{nil} and point stops atthe 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 prefixargument.@end deffn@deffn Command backward-word countThis function is just like @code{forward-word}, except that it movesbackward until encountering the front of a word, rather than forward.In an interactive call, @var{count} is set to the numeric prefixargument.@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@c Emacs 19 featureThis variable affects the behavior of @code{forward-word} and everythingthat uses it. If it is non-@code{nil}, then characters in the``escape'' and ``character quote'' syntax classes count as part ofwords. Otherwise, they do not.@end defvar@defvar inhibit-field-text-motion@tindex inhibit-field-text-motionIf 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 To move point to the beginning of the buffer, write:@example@group(goto-char (point-min))@end group@end example@noindentLikewise, 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 aredocumented here to warn you not to use them in Lisp programs, becausethey set the mark and display messages in the echo area.@deffn Command beginning-of-buffer &optional nThis function moves point to the beginning of the buffer (or the limitsof the accessible portion, when narrowing is in effect), setting themark at the previous position. If @var{n} is non-@code{nil}, then itputs point @var{n} tenths of the way from the beginning of theaccessible portion of the buffer.In an interactive call, @var{n} is the numeric prefix argument,if provided; otherwise @var{n} defaults to @code{nil}.@strong{Warning:} Don't use this function in Lisp programs!@end deffn@deffn Command end-of-buffer &optional nThis function moves point to the end of the buffer (or the limits of theaccessible portion, when narrowing is in effect), setting the mark atthe 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 thebuffer.In an interactive call, @var{n} is the numeric prefix argument,if provided; otherwise @var{n} defaults to @code{nil}.@strong{Warning:} Don't use this function in Lisp programs!@end deffn@node Text Lines@subsection Motion by Text Lines@cindex lines Text lines are portions of the buffer delimited by newline characters,which are regarded as part of the previous line. The first text linebegins at the beginning of the buffer, and the last text line ends atthe 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 widthof the window, by line continuation in display, or by how tabs andcontrol characters are displayed.@deffn Command goto-line lineThis 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 lessthan 1, it moves point to the beginning of the buffer. If @var{line} isgreater than the number of lines in the buffer, it moves point to theend of the buffer---that is, the @emph{end of the last line} of thebuffer. This is the only case in which @code{goto-line} does notnecessarily move to the beginning of a line.If narrowing is in effect, then @var{line} still counts from thebeginning of the buffer, but point cannot go outside the accessibleportion. So @code{goto-line} moves point to the beginning or end of theaccessible portion, if the line number specifies an inaccessibleposition.The return value of @code{goto-line} is the difference between@var{line} and the line number of the line to which point actually wasable to move (in the full buffer, before taking account of narrowing).Thus, the value is positive if the scan encounters the real end of thebuffer before finding the specified line. The value is zero if scanencounters the end of the accessible portion but not the real end of thebuffer.In an interactive call, @var{line} is the numeric prefix argument ifone has been provided. Otherwise @var{line} is read in the minibuffer.@end deffn@deffn Command beginning-of-line &optional countThis function moves point to the beginning of the current line. With anargument @var{count} not @code{nil} or 1, it moves forward@var{count}@minus{}1 lines and then to the beginning of the line.If this function reaches the end of the buffer (or of the accessibleportion, if narrowing is in effect), it positions point there. No erroris signaled.@end deffn@defun line-beginning-position &optional count@tindex line-beginning-positionReturn the position that @code{(beginning-of-line @var{count})}would move to.@end defun@deffn Command end-of-line &optional countThis function moves point to the end of the current line. With anargument @var{count} not @code{nil} or 1, it moves forward@var{count}@minus{}1 lines and then to the end of the line.If this function reaches the end of the buffer (or of the accessibleportion, if narrowing is in effect), it positions point there. No erroris signaled.@end deffn@defun line-end-position &optional count@tindex line-end-positionReturn the position that @code{(end-of-line @var{count})}would move to.@end defun@deffn Command forward-line &optional count@cindex beginning of lineThis function moves point forward @var{count} lines, to the beginning ofthe 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 currentline.If @code{forward-line} encounters the beginning or end of the buffer (orof the accessible portion) before finding that many lines, it sets pointthere. No error is signaled.@code{forward-line} returns the difference between @var{count} and thenumber of lines actually moved. If you attempt to move down five linesfrom the beginning of a buffer that has only three lines, point stops atthe end of the last line, and the value will be 2.In an interactive call, @var{count} is the numeric prefix argument.@end deffn@defun count-lines start end@cindex lines in regionThis 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 least1, even if @var{start} and @var{end} are on the same line. This isbecause the text between them, considered in isolation, must contain atleast one line unless it is empty.Here is an example of using @code{count-lines}:@example@group(defun current-line () "Return the vertical position of point@dots{}" (+ (count-lines (window-start) (point)) (if (= (current-column) 0) 1 0) -1))@end group@end example@end defun@ignore@c ================The @code{previous-line} and @code{next-line} commands are functionsthat should not be used in programs. They are for users and arementioned here only for completeness.@deffn Command previous-line count@cindex goal columnThis 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 currentcolumn, point is positioned after the character in that line whichspans 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 clippedregion), then point is positioned in the goal column in the top orbottom line. No error is signaled.In an interactive call, @var{count} will be the numericprefix argument.The command @code{set-goal-column} can be used to create a semipermanentgoal column to which this command always moves. Then it does not try tomove 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 easierto use and more reliable (no dependence on goal column, etc.).@end deffn@deffn Command next-line countThis 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 currentcolumn, point is positioned after the character in that line whichspans 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 clippedregion), then point is positioned in the goal column in the top orbottom line. No error is signaled.In the case where the @var{count} is 1, and point is on the lastline of the buffer (or clipped region), a new empty line is inserted at theend of the buffer (or clipped region) and point moved there.In an interactive call, @var{count} will be the numericprefix argument.The command @code{set-goal-column} can be used to create a semipermanentgoal column to which this command always moves. Then it does not try tomove vertically.If you are thinking of using this in a Lisp program, consider using@code{forward-line} instead. It is usually easierto 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 thebeginning or end of a line.@node Screen Lines@subsection Motion by Screen Lines The line functions in the previous section count text lines, delimitedonly by newline characters. By contrast, these functions count screenlines, which are defined by the way the text appears on the screen. Atext line is a single screen line if it is short enough to fit the widthof the selected window, but otherwise it may occupy several screenlines. In some cases, text lines are truncated on the screen rather thancontinued 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 controlthe appearance of certain characters, @code{vertical-motion} behavesdifferently, for a given piece of text, depending on the buffer it isin, and even on the selected window (because the width, the truncationflag, and display table may vary between windows). @xref{UsualDisplay}. These functions scan text to determine where screen lines break, andthus take time proportional to the distance scanned. If you intend touse them heavily, Emacs provides caches which may improve theperformance of your code. @xref{Truncation, cache-long-line-scans}.@defun vertical-motion count &optional windowThis 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 screen lines over which itmoved 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 thewidth, the horizontal scrolling, and the display table. But@code{vertical-motion} always operates on the current buffer, even if@var{window} currently displays some other buffer.@end defun@deffn Command move-to-window-line countThis function moves point with respect to the text currently displayedin the selected window. It moves point to the beginning of the screenline @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 thebuffer, if the buffer ends above the specified screen position).If @var{count} is @code{nil}, then point moves to the beginning of theline 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 placethat would appear on that screen line if the window were tall enough.This will probably cause the next redisplay to scroll to bring thatlocation 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, withthe top line in the window numbered 0.@end deffn@defun count-screen-lines &optional beg end count-final-newline windowThis function returns the number of the screen lines occupied by thetext between positions @var{beg} and @var{end}. These arguments defaultto the beginning and end of the accessible portion of the buffer.If region ends with a newline, it is significant if@var{count-final-newline} is non-@code{nil}. Otherwise it is ignored.The argument @var{window} specifies the window used for obtainingparameters such as width, horizontal scrolling, and so on. The defaultis the selected window.Like @code{vertical-motion}, @code{count-screen-lines} always uses thecurrent 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@defun compute-motion from frompos to topos width offsets windowThis function scans the current buffer, calculating screen positions.It scans the buffer forward from position @var{from}, assuming that isat screen coordinates @var{frompos}, to position @var{to} or coordinates@var{topos}, whichever comes first. It returns the ending bufferposition and screen coordinates.The coordinate arguments @var{frompos} and @var{topos} are cons cells ofthe form @code{(@var{hpos} . @var{vpos})}.The argument @var{width} is the number of columns available to displaytext; this affects handling of continuation lines. Use the valuereturned 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 theform @code{(@var{hscroll} . @var{tab-offset})}. Here @var{hscroll} isthe number of columns not being displayed at the left margin; mostcallers get this by calling @code{window-hscroll}. Meanwhile,@var{tab-offset} is the offset between column numbers on the screen andcolumn numbers in the buffer. This can be nonzero in a continuationline, when the previous screen lines' widths do not add up to a multipleof @code{tab-width}. It is always zero in a non-continuation line.The window @var{window} serves only to specify which display table touse. @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@noindentHere @var{pos} is the buffer position where the scan stopped, @var{vpos}is the vertical screen position, and @var{hpos} is the horizontal screenposition.The result @var{prevhpos} is the horizontal position one character backfrom @var{pos}. The result @var{contin} is @code{t} if the last linewas continued after (or within) the previous character.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 locationas @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 tothe 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 exampleWhen you use @code{compute-motion} for the minibuffer, you need to use@code{minibuffer-prompt-width} to get the horizontal position of thebeginning of the first screen line. @xref{Minibuffer Misc}.@end defun@node List Motion@comment node-name, next, previous, up@subsection Moving over Balanced Expressions @cindex sexp motion@cindex Lisp expression motion@cindex list motion Here are several functions concerned with balanced-parenthesisexpressions (also called @dfn{sexps} in connection with moving acrossthem in Emacs). The syntax table controls how these functions interpretvarious characters; see @ref{Syntax Tables}. @xref{ParsingExpressions}, for lower-level primitives for scanning sexps or parts ofsexps. For user-level commands, see @ref{Lists Commands,,, emacs, The GNUEmacs Manual}.@deffn Command forward-list &optional argThis function moves forward across @var{arg} (default 1) balanced groups ofparentheses. (Other syntactic entities such as words or paired stringquotes are ignored.)@end deffn@deffn Command backward-list &optional argThis function moves backward across @var{arg} (default 1) balanced groups ofparentheses. (Other syntactic entities such as words or paired stringquotes are ignored.)@end deffn@deffn Command up-list &optional argThis 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 &optional argThis function moves forward into @var{arg} (default 1) levels of parentheses. Anegative argument means move backward but still godeeper in parentheses (@minus{}@var{arg} levels).@end deffn@deffn Command forward-sexp &optional argThis function moves forward across @var{arg} (default 1) balanced expressions.Balanced expressions include both those delimited by parentheses andother kinds, such as words and string constants. 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 argThis function moves backward across @var{arg} (default 1) balanced expressions.@end deffn@deffn Command beginning-of-defun argThis function moves back to the @var{arg}th beginning of a defun. If@var{arg} is negative, this actually moves forward, but it still movesto the beginning of a defun, not to the end of one.@end deffn@deffn Command end-of-defun argThis function moves forward to the @var{arg}th end of a defun. If@var{arg} is negative, this actually moves backward, but it still movesto the end of a defun, not to the beginning of one.@end deffn@defopt defun-prompt-regexpIf non-@code{nil}, this variable holds a regular expression thatspecifies what text can appear before the open-parenthesis that starts adefun. That is to say, a defun begins on a line that starts with amatch for this regular expression, followed by a character withopen-parenthesis syntax.@end defopt@defvar beginning-of-defun-function@tindex beginning-of-defun-functionIf non-@code{nil}, this variable holds a function for finding thebeginning 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-functionIf non-@code{nil}, this variable holds a function for finding the end ofa defun. The function @code{end-of-defun} calls this function insteadof using its normal method.@end defvar@node Skipping Characters@comment node-name, next, previous, up@subsection Skipping Characters@cindex skipping characters The following two functions move point over a specified set ofcharacters. For example, they are often used to skip whitespace. Forrelated functions, see @ref{Motion and Syntax}.@defun skip-chars-forward character-set &optional limitThis function moves point in the current buffer forward, skipping over agiven set of characters. It examines the character following point,then advances point if the character matches @var{character-set}. Thiscontinues until it reaches a character that does not match. Thefunction 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 neverspecial and @samp{\} quotes @samp{^}, @samp{-} or @samp{\}. Thus,@code{"a-zA-Z"} skips over all letters, stopping before the firstnonletter, and @code{"^a-zA-Z"} skips nonletters stopping before thefirst letter. @xref{Regular Expressions}.If @var{limit} is supplied (it must be a number or a marker), itspecifies the maximum position in the buffer that point can be skippedto. 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 ofthat line (between the @samp{t} of @samp{hat} and the newline). Thefunction skips all letters and spaces, but not newlines.@example@group---------- Buffer: foo ----------I read "@point{}The cat in the hatcomes 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 limitThis function moves point backward, skipping characters that match@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 thatis zero or less.@end defun@node Excursions@section Excursions@cindex excursion It is often useful to move point ``temporarily'' within a localizedportion of the program, or to switch buffers temporarily. This iscalled an @dfn{excursion}, and it is done with the @code{save-excursion}special form. This construct initially remembers the identity of thecurrent buffer, and its values of point and the mark, and restores themafter the completion of the excursion. The forms for saving and restoring the configuration of windows aredescribed elsewhere (see @ref{Window Configurations}, and @pxref{FrameConfigurations}).@defspec save-excursion forms@dots{}@cindex mark excursion@cindex point excursion@cindex current buffer excursionThe @code{save-excursion} special form saves the identity of the currentbuffer and the values of point and the mark in it, evaluates@var{forms}, and finally restores the buffer and its saved values ofpoint and the mark. All three saved values are restored even in case ofan abnormal exit via @code{throw} or error (@pxref{Nonlocal Exits}).The @code{save-excursion} special form is the standard way to switchbuffers or move point within one part of a program and avoid affectingthe rest of the program. It is used more than 4000 times in the Lispsources of Emacs.@code{save-excursion} does not save the values of point and the mark forother buffers, so changes in other buffers remain in effect after@code{save-excursion} exits.@cindex window excursionsLikewise, @code{save-excursion} does not restore window-buffercorrespondences altered by functions such as @code{switch-to-buffer}.One way to restore these correspondences, and the selected window, is touse @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))@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 savedpoint value relocates the saved value, just as it relocates all markers.Therefore, when the saved point value is restored, it normally comesbefore the inserted text. Although @code{save-excursion} saves the location of the mark, it doesnot prevent functions which modify the buffer from setting@code{deactivate-mark}, and thus causing the deactivation of the markafter the command finishes. @xref{The Mark}.@node Narrowing@section Narrowing@cindex narrowing@cindex restriction (in a buffer)@cindex accessible portion (of a buffer) @dfn{Narrowing} means limiting the text addressable by Emacs editingcommands to a limited range of characters in a buffer. The text thatremains addressable is called the @dfn{accessible portion} of thebuffer. Narrowing is specified with two buffer positions which become thebeginning and end of the accessible portion. For most editing commandsand most Emacs primitives, these positions replace the values of thebeginning and end of the buffer. While narrowing is in effect, no textoutside the accessible portion is displayed, and point cannot moveoutside the accessible portion. Values such as positions or line numbers, which usually count from thebeginning of the buffer, do so despite narrowing, but the functionswhich use them refuse to operate on text that is inaccessible. The commands for saving buffers are unaffected by narrowing; they savethe entire buffer regardless of any narrowing.@deffn Command narrow-to-region start endThis function sets the accessible portion of the current buffer to startat @var{start} and end at @var{end}. Both arguments should be characterpositions.In an interactive call, @var{start} and @var{end} are set to the boundsof the current region (point and the mark, with the smallest first).@end deffn@deffn Command narrow-to-page move-countThis function sets the accessible portion of the current buffer toinclude 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 to one page. 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 prefixargument.@end deffn@deffn Command widen@cindex wideningThis function cancels any narrowing in the current buffer, so that theentire 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@end deffn@defspec save-restriction body@dots{}This special form saves the current bounds of the accessible portion,evaluates the @var{body} forms, and finally restores the saved bounds,thus restoring the same state of narrowing (or absence thereof) formerlyin effect. The state of narrowing is restored even in the event of anabnormal 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 thelast 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 herebefore you try it.If @var{body} changes the current buffer, @code{save-restriction} stillrestores the restrictions on the original buffer (the buffer whoserestrictions it saved from), but it does not restore the identity of thecurrent 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 comefirst (on the outside). Otherwise, the old point value would berestored with temporary narrowing still in effect. If the old pointvalue were outside the limits of the temporary narrowing, this wouldfail to restore it accurately.Here is a simple example of correct use of @code{save-restriction}:@example@group---------- Buffer: foo ----------This is the contents of fooThis is the contents of fooThis 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 barThis is the contents of barThis is the contents of foo@point{}---------- Buffer: foo ----------@end group@end example@end defspec