2 @c This is part of the XEmacs Lisp Reference Manual.
3 @c Copyright (C) 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
4 @c See the file lispref.texi for copying conditions.
5 @setfilename ../../info/positions.info
6 @node Positions, Markers, Consoles and Devices, Top
8 @cindex position (in buffer)
10 A @dfn{position} is the index of a character in the text of a buffer.
11 More precisely, a position identifies the place between two characters
12 (or before the first character, or after the last character), so we can
13 speak of the character before or after a given position. However, we
14 often speak of the character ``at'' a position, meaning the character
17 Positions are usually represented as integers starting from 1, but can
18 also be represented as @dfn{markers}---special objects that relocate
19 automatically when text is inserted or deleted so they stay with the
20 surrounding characters. @xref{Markers}.
23 * Point:: The special position where editing takes place.
24 * Motion:: Changing point.
25 * Excursions:: Temporary motion and buffer changes.
26 * Narrowing:: Restricting editing to a portion of the buffer.
33 @dfn{Point} is a special buffer position used by many editing
34 commands, including the self-inserting typed characters and text
35 insertion functions. Other commands move point through the text
36 to allow editing and insertion at different places.
38 Like other positions, point designates a place between two characters
39 (or before the first character, or after the last character), rather
40 than a particular character. Usually terminals display the cursor over
41 the character that immediately follows point; point is actually before
42 the character on which the cursor sits.
44 @cindex point with narrowing
45 The value of point is a number between 1 and the buffer size plus 1.
46 If narrowing is in effect (@pxref{Narrowing}), then point is constrained
47 to fall within the accessible portion of the buffer (possibly at one end
50 Each buffer has its own value of point, which is independent of the
51 value of point in other buffers. Each window also has a value of point,
52 which is independent of the value of point in other windows on the same
53 buffer. This is why point can have different values in various windows
54 that display the same buffer. When a buffer appears in only one window,
55 the buffer's point and the window's point normally have the same value,
56 so the distinction is rarely important. @xref{Window Point}, for more
59 @defun point &optional buffer
60 @cindex current buffer position
61 This function returns the value of point in @var{buffer}, as an integer.
62 @var{buffer} defaults to the current buffer if omitted.
73 @defun point-min &optional buffer
74 This function returns the minimum accessible value of point in
75 @var{buffer}. This is normally 1, but if narrowing is in effect, it is
76 the position of the start of the region that you narrowed to.
77 (@xref{Narrowing}.) @var{buffer} defaults to the current buffer if
81 @defun point-max &optional buffer
82 This function returns the maximum accessible value of point in
83 @var{buffer}. This is @code{(1+ (buffer-size buffer))}, unless
84 narrowing is in effect, in which case it is the position of the end of
85 the region that you narrowed to. (@pxref{Narrowing}). @var{buffer}
86 defaults to the current buffer if omitted.
89 @defun buffer-end flag &optional buffer
90 This function returns @code{(point-min buffer)} if @var{flag} is less
91 than 1, @code{(point-max buffer)} otherwise. The argument @var{flag}
92 must be a number. @var{buffer} defaults to the current buffer if
96 @defun buffer-size &optional buffer
97 This function returns the total number of characters in @var{buffer}.
98 In the absence of any narrowing (@pxref{Narrowing}), @code{point-max}
99 returns a value one larger than this. @var{buffer} defaults to the
100 current buffer if omitted.
114 @defvar buffer-saved-size
115 The value of this buffer-local variable is the former length of the
116 current buffer, as of the last time it was read in, saved or auto-saved.
122 Motion functions change the value of point, either relative to the
123 current value of point, relative to the beginning or end of the buffer,
124 or relative to the edges of the selected window. @xref{Point}.
127 * Character Motion:: Moving in terms of characters.
128 * Word Motion:: Moving in terms of words.
129 * Buffer End Motion:: Moving to the beginning or end of the buffer.
130 * Text Lines:: Moving in terms of lines of text.
131 * Screen Lines:: Moving in terms of lines as displayed.
132 * List Motion:: Moving by parsing lists and sexps.
133 * Skipping Characters:: Skipping characters belonging to a certain set.
136 @node Character Motion
137 @subsection Motion by Characters
139 These functions move point based on a count of characters.
140 @code{goto-char} is the fundamental primitive; the other functions use
143 @deffn Command goto-char position &optional buffer
144 This function sets point in @code{buffer} to the value @var{position}.
145 If @var{position} is less than 1, it moves point to the beginning of the
146 buffer. If @var{position} is greater than the length of the buffer, it
147 moves point to the end. @var{buffer} defaults to the current buffer if
150 If narrowing is in effect, @var{position} still counts from the
151 beginning of the buffer, but point cannot go outside the accessible
152 portion. If @var{position} is out of range, @code{goto-char} moves
153 point to the beginning or the end of the accessible portion.
155 When this function is called interactively, @var{position} is the
156 numeric prefix argument, if provided; otherwise it is read from the
159 @code{goto-char} returns @var{position}.
162 @deffn Command forward-char &optional count buffer
163 @c @kindex beginning-of-buffer
164 @c @kindex end-of-buffer
165 This function moves point @var{count} characters forward, towards the
166 end of the buffer (or backward, towards the beginning of the buffer, if
167 @var{count} is negative). If the function attempts to move point past
168 the beginning or end of the buffer (or the limits of the accessible
169 portion, when narrowing is in effect), an error is signaled with error
170 code @code{beginning-of-buffer} or @code{end-of-buffer}. @var{buffer}
171 defaults to the current buffer if omitted.
174 In an interactive call, @var{count} is the numeric prefix argument.
177 @deffn Command backward-char &optional count buffer
178 This function moves point @var{count} characters backward, towards the
179 beginning of the buffer (or forward, towards the end of the buffer, if
180 @var{count} is negative). If the function attempts to move point past
181 the beginning or end of the buffer (or the limits of the accessible
182 portion, when narrowing is in effect), an error is signaled with error
183 code @code{beginning-of-buffer} or @code{end-of-buffer}. @var{buffer}
184 defaults to the current buffer if omitted.
187 In an interactive call, @var{count} is the numeric prefix argument.
191 @subsection Motion by Words
193 These functions for parsing words use the syntax table to decide
194 whether a given character is part of a word. @xref{Syntax Tables}.
196 @deffn Command forward-word count &optional buffer
197 This function moves point forward @var{count} words (or backward if
198 @var{count} is negative). Normally it returns @code{t}. If this motion
199 encounters the beginning or end of the buffer, or the limits of the
200 accessible portion when narrowing is in effect, point stops there and
201 the value is @code{nil}. @var{buffer} defaults to the current buffer if
204 In an interactive call, @var{count} is set to the numeric prefix
208 @deffn Command backward-word count &optional buffer
209 This function is just like @code{forward-word}, except that it moves
210 backward until encountering the front of a word, rather than forward.
211 @var{buffer} defaults to the current buffer if omitted.
213 In an interactive call, @var{count} is set to the numeric prefix
216 This function is rarely used in programs, as it is more efficient to
217 call @code{forward-word} with a negative argument.
220 @defvar words-include-escapes
222 This variable affects the behavior of @code{forward-word} and everything
223 that uses it. If it is non-@code{nil}, then characters in the
224 ``escape'' and ``character quote'' syntax classes count as part of
225 words. Otherwise, they do not.
228 @node Buffer End Motion
229 @subsection Motion to an End of the Buffer
231 To move point to the beginning of the buffer, write:
235 (goto-char (point-min))
240 Likewise, to move to the end of the buffer, use:
244 (goto-char (point-max))
248 Here are two commands that users use to do these things. They are
249 documented here to warn you not to use them in Lisp programs, because
250 they set the mark and display messages in the echo area.
252 @deffn Command beginning-of-buffer &optional count
253 This function moves point to the beginning of the buffer (or the limits
254 of the accessible portion, when narrowing is in effect), setting the
255 mark at the previous position. If @var{count} is non-@code{nil}, then it
256 puts point @var{count} tenths of the way from the beginning of the buffer.
258 In an interactive call, @var{count} is the numeric prefix argument,
259 if provided; otherwise @var{count} defaults to @code{nil}.
261 Don't use this function in Lisp programs!
264 @deffn Command end-of-buffer &optional count
265 This function moves point to the end of the buffer (or the limits of
266 the accessible portion, when narrowing is in effect), setting the mark
267 at the previous position. If @var{count} is non-@code{nil}, then it puts
268 point @var{count} tenths of the way from the end of the buffer.
270 In an interactive call, @var{count} is the numeric prefix argument,
271 if provided; otherwise @var{count} defaults to @code{nil}.
273 Don't use this function in Lisp programs!
277 @subsection Motion by Text Lines
280 Text lines are portions of the buffer delimited by newline characters,
281 which are regarded as part of the previous line. The first text line
282 begins at the beginning of the buffer, and the last text line ends at
283 the end of the buffer whether or not the last character is a newline.
284 The division of the buffer into text lines is not affected by the width
285 of the window, by line continuation in display, or by how tabs and
286 control characters are displayed.
288 @deffn Command goto-line line
289 This function moves point to the front of the @var{line}th line,
290 counting from line 1 at beginning of the buffer. If @var{line} is less
291 than 1, it moves point to the beginning of the buffer. If @var{line} is
292 greater than the number of lines in the buffer, it moves point to the
293 end of the buffer---that is, the @emph{end of the last line} of the
294 buffer. This is the only case in which @code{goto-line} does not
295 necessarily move to the beginning of a line.
297 If narrowing is in effect, then @var{line} still counts from the
298 beginning of the buffer, but point cannot go outside the accessible
299 portion. So @code{goto-line} moves point to the beginning or end of the
300 accessible portion, if the line number specifies an inaccessible
303 The return value of @code{goto-line} is the difference between
304 @var{line} and the line number of the line to which point actually was
305 able to move (in the full buffer, before taking account of narrowing).
306 Thus, the value is positive if the scan encounters the real end of the
307 buffer. The value is zero if scan encounters the end of the accessible
308 portion but not the real end of the buffer.
310 In an interactive call, @var{line} is the numeric prefix argument if
311 one has been provided. Otherwise @var{line} is read in the minibuffer.
314 @deffn Command beginning-of-line &optional count buffer
315 This function moves point to the beginning of the current line. With an
316 argument @var{count} not @code{nil} or 1, it moves forward
317 @var{count}@minus{}1 lines and then to the beginning of the line.
318 @var{buffer} defaults to the current buffer if omitted.
320 If this function reaches the end of the buffer (or of the accessible
321 portion, if narrowing is in effect), it positions point there. No error
325 @deffn Command end-of-line &optional count buffer
326 This function moves point to the end of the current line. With an
327 argument @var{count} not @code{nil} or 1, it moves forward
328 @var{count}@minus{}1 lines and then to the end of the line.
329 @var{buffer} defaults to the current buffer if omitted.
331 If this function reaches the end of the buffer (or of the accessible
332 portion, if narrowing is in effect), it positions point there. No error
336 @deffn Command forward-line &optional count buffer
337 @cindex beginning of line
338 This function moves point forward @var{count} lines, to the beginning of
339 the line. If @var{count} is negative, it moves point
340 @minus{}@var{count} lines backward, to the beginning of a line. If
341 @var{count} is zero, it moves point to the beginning of the current
342 line. @var{buffer} defaults to the current buffer if omitted.
344 If @code{forward-line} encounters the beginning or end of the buffer (or
345 of the accessible portion) before finding that many lines, it sets point
346 there. No error is signaled.
348 @code{forward-line} returns the difference between @var{count} and the
349 number of lines actually moved. If you attempt to move down five lines
350 from the beginning of a buffer that has only three lines, point stops at
351 the end of the last line, and the value will be 2.
353 In an interactive call, @var{count} is the numeric prefix argument.
356 @defun count-lines start end &optional ignore-invisible-lines-flag
357 @cindex lines in region
358 This function returns the number of lines between the positions
359 @var{start} and @var{end} in the current buffer. If @var{start} and
360 @var{end} are equal, then it returns 0. Otherwise it returns at least
361 1, even if @var{start} and @var{end} are on the same line. This is
362 because the text between them, considered in isolation, must contain at
363 least one line unless it is empty.
365 With optional @var{ignore-invisible-lines-flag} non-@code{nil}, lines
366 collapsed with selective-display are excluded from the line count.
368 @strong{Note:} The expression to return the current line number is not
372 (1+ (count-lines 1 (point-at-bol)))
375 Here is an example of using @code{count-lines}:
379 (defun current-line ()
380 "Return the vertical position of point@dots{}"
381 (+ (count-lines (window-start) (point))
382 (if (= (current-column) 0) 1 0)
390 The @code{previous-line} and @code{next-line} commands are functions
391 that should not be used in programs. They are for users and are
392 mentioned here only for completeness.
394 @deffn Command previous-line count
396 This function moves point up @var{count} lines (down if @var{count}
397 is negative). In moving, it attempts to keep point in the ``goal column''
398 (normally the same column that it was at the beginning of the move).
400 If there is no character in the target line exactly under the current
401 column, point is positioned after the character in that line which
402 spans this column, or at the end of the line if it is not long enough.
404 If it attempts to move beyond the top or bottom of the buffer (or clipped
405 region), then point is positioned in the goal column in the top or
406 bottom line. No error is signaled.
408 In an interactive call, @var{count} will be the numeric
411 The command @code{set-goal-column} can be used to create a semipermanent
412 goal column to which this command always moves. Then it does not try to
415 If you are thinking of using this in a Lisp program, consider using
416 @code{forward-line} with a negative argument instead. It is usually easier
417 to use and more reliable (no dependence on goal column, etc.).
420 @deffn Command next-line count
421 This function moves point down @var{count} lines (up if @var{count}
422 is negative). In moving, it attempts to keep point in the ``goal column''
423 (normally the same column that it was at the beginning of the move).
425 If there is no character in the target line exactly under the current
426 column, point is positioned after the character in that line which
427 spans this column, or at the end of the line if it is not long enough.
429 If it attempts to move beyond the top or bottom of the buffer (or clipped
430 region), then point is positioned in the goal column in the top or
431 bottom line. No error is signaled.
433 In the case where the @var{count} is 1, and point is on the last
434 line of the buffer (or clipped region), a new empty line is inserted at the
435 end of the buffer (or clipped region) and point moved there.
437 In an interactive call, @var{count} will be the numeric
440 The command @code{set-goal-column} can be used to create a semipermanent
441 goal column to which this command always moves. Then it does not try to
444 If you are thinking of using this in a Lisp program, consider using
445 @code{forward-line} instead. It is usually easier
446 to use and more reliable (no dependence on goal column, etc.).
452 Also see the functions @code{bolp} and @code{eolp} in @ref{Near Point}.
453 These functions do not move point, but test whether it is already at the
454 beginning or end of a line.
457 @subsection Motion by Screen Lines
459 The line functions in the previous section count text lines, delimited
460 only by newline characters. By contrast, these functions count screen
461 lines, which are defined by the way the text appears on the screen. A
462 text line is a single screen line if it is short enough to fit the width
463 of the selected window, but otherwise it may occupy several screen
466 In some cases, text lines are truncated on the screen rather than
467 continued onto additional screen lines. In these cases,
468 @code{vertical-motion} moves point much like @code{forward-line}.
471 Because the width of a given string depends on the flags that control
472 the appearance of certain characters, @code{vertical-motion} behaves
473 differently, for a given piece of text, depending on the buffer it is
474 in, and even on the selected window (because the width, the truncation
475 flag, and display table may vary between windows). @xref{Usual
478 These functions scan text to determine where screen lines break, and
479 thus take time proportional to the distance scanned. If you intend to
480 use them heavily, Emacs provides caches which may improve the
481 performance of your code. @xref{Text Lines, cache-long-line-scans}.
484 @defun vertical-motion count &optional window pixels
485 This function moves point to the start of the frame line @var{count}
486 frame lines down from the frame line containing point. If @var{count}
487 is negative, it moves up instead. The optional second argument
488 @var{window} may be used to specify a window other than the
489 selected window in which to perform the motion.
491 Normally, @code{vertical-motion} returns the number of lines moved. The
492 value may be less in absolute value than @var{count} if the beginning or
493 end of the buffer was reached. If the optional third argument,
494 @var{pixels} is non-@code{nil}, the vertical pixel height of the motion
495 which took place is returned instead of the actual number of lines
496 moved. A motion of zero lines returns the height of the current line.
498 Note that @code{vertical-motion} sets @var{window}'s buffer's point, not
499 @var{window}'s point. (This differs from FSF Emacs, which buggily always
500 sets current buffer's point, regardless of @var{window}.)
503 @defun vertical-motion-pixels count &optional window how
504 This function moves point to the start of the frame line @var{pixels}
505 vertical pixels down from the frame line containing point, or up if
506 @var{pixels} is negative. The optional second argument @var{window} is
507 the window to move in, and defaults to the selected window. The
508 optional third argument @var{how} specifies the stopping condition. A
509 negative integer indicates that the motion should be no more
510 than @var{pixels}. A positive value indicates that the
511 motion should be at least @var{pixels}. Any other value indicates
512 that the motion should be as close as possible to @var{pixels}.
515 @deffn Command move-to-window-line count &optional window
516 This function moves point with respect to the text currently displayed
517 in @var{window}, which defaults to the selected window. It moves point
518 to the beginning of the screen line @var{count} screen lines from the
519 top of the window. If @var{count} is negative, that specifies a
520 position @w{@minus{}@var{count}} lines from the bottom (or the last line
521 of the buffer, if the buffer ends above the specified screen position).
523 If @var{count} is @code{nil}, then point moves to the beginning of the
524 line in the middle of the window. If the absolute value of @var{count}
525 is greater than the size of the window, then point moves to the place
526 that would appear on that screen line if the window were tall enough.
527 This will probably cause the next redisplay to scroll to bring that
528 location onto the screen.
530 In an interactive call, @var{count} is the numeric prefix argument.
532 The value returned is the window line number point has moved to, with
533 the top line in the window numbered 0.
536 @ignore Not in XEmacs
537 @defun compute-motion from frompos to topos width offsets window
538 This function scans the current buffer, calculating screen positions.
539 It scans the buffer forward from position @var{from}, assuming that is
540 at screen coordinates @var{frompos}, to position @var{to} or coordinates
541 @var{topos}, whichever comes first. It returns the ending buffer
542 position and screen coordinates.
544 The coordinate arguments @var{frompos} and @var{topos} are cons cells of
545 the form @code{(@var{hpos} . @var{vpos})}.
547 The argument @var{width} is the number of columns available to display
548 text; this affects handling of continuation lines. Use the value
549 returned by @code{window-width} for the window of your choice;
550 normally, use @code{(window-width @var{window})}.
552 The argument @var{offsets} is either @code{nil} or a cons cell of the
553 form @code{(@var{hscroll} . @var{tab-offset})}. Here @var{hscroll} is
554 the number of columns not being displayed at the left margin; most
555 callers get this from @code{window-hscroll}. Meanwhile,
556 @var{tab-offset} is the offset between column numbers on the screen and
557 column numbers in the buffer. This can be nonzero in a continuation
558 line, when the previous screen lines' widths do not add up to a multiple
559 of @code{tab-width}. It is always zero in a non-continuation line.
561 The window @var{window} serves only to specify which display table to
562 use. @code{compute-motion} always operates on the current buffer,
563 regardless of what buffer is displayed in @var{window}.
565 The return value is a list of five elements:
568 (@var{pos} @var{vpos} @var{hpos} @var{prevhpos} @var{contin})
572 Here @var{pos} is the buffer position where the scan stopped, @var{vpos}
573 is the vertical screen position, and @var{hpos} is the horizontal screen
576 The result @var{prevhpos} is the horizontal position one character back
577 from @var{pos}. The result @var{contin} is @code{t} if the last line
578 was continued after (or within) the previous character.
580 For example, to find the buffer position of column @var{col} of line
581 @var{line} of a certain window, pass the window's display start location
582 as @var{from} and the window's upper-left coordinates as @var{frompos}.
583 Pass the buffer's @code{(point-max)} as @var{to}, to limit the scan to
584 the end of the accessible portion of the buffer, and pass @var{line} and
585 @var{col} as @var{topos}. Here's a function that does this:
588 (defun coordinates-of-position (col line)
589 (car (compute-motion (window-start)
594 (cons (window-hscroll) 0)
598 When you use @code{compute-motion} for the minibuffer, you need to use
599 @code{minibuffer-prompt-width} to get the horizontal position of the
600 beginning of the first screen line. @xref{Minibuffer Misc}.
605 @subsection Moving over Balanced Expressions
607 @cindex Lisp expression motion
610 Here are several functions concerned with balanced-parenthesis
611 expressions (also called @dfn{sexps} in connection with moving across
612 them in XEmacs). The syntax table controls how these functions interpret
613 various characters; see @ref{Syntax Tables}. @xref{Parsing
614 Expressions}, for lower-level primitives for scanning sexps or parts of
615 sexps. For user-level commands, see @ref{Lists and Sexps,,, emacs, XEmacs
618 @deffn Command forward-list &optional arg
619 This function moves forward across @var{arg} balanced groups of
620 parentheses. (Other syntactic entities such as words or paired string
621 quotes are ignored.) @var{arg} defaults to 1 if omitted. If @var{arg}
622 is negative, move backward across that many groups of parentheses.
625 @deffn Command backward-list &optional count
626 This function moves backward across @var{count} balanced groups of
627 parentheses. (Other syntactic entities such as words or paired string
628 quotes are ignored.) @var{count} defaults to 1 if omitted. If
629 @var{count} is negative, move forward across that many groups of
633 @deffn Command up-list &optional count
634 This function moves forward out of @var{count} levels of parentheses.
635 A negative argument means move backward but still to a less deep spot.
638 @deffn Command down-list &optional count
639 This function moves forward into @var{count} levels of parentheses.
640 A negative argument means move backward but still go deeper in
641 parentheses (@minus{}@var{count} levels).
644 @deffn Command forward-sexp &optional count
645 This function moves forward across @var{count} balanced expressions.
646 Balanced expressions include both those delimited by parentheses and
647 other kinds, such as words and string constants. @var{count} defaults to
648 1 if omitted. If @var{count} is negative, move backward across that many
649 balanced expressions. For example,
653 ---------- Buffer: foo ----------
654 (concat@point{} "foo " (car x) y z)
655 ---------- Buffer: foo ----------
662 ---------- Buffer: foo ----------
663 (concat "foo " (car x) y@point{} z)
664 ---------- Buffer: foo ----------
669 @deffn Command backward-sexp &optional count
670 This function moves backward across @var{count} balanced expressions.
671 @var{count} defaults to 1 if omitted. If @var{count} is negative, move
672 forward across that many balanced expressions.
675 @deffn Command beginning-of-defun &optional count
676 This function moves back to the @var{count}th beginning of a defun.
677 If @var{count} is negative, this actually moves forward, but it still
678 moves to the beginning of a defun, not to the end of one. @var{count}
679 defaults to 1 if omitted.
682 @deffn Command end-of-defun &optional count
683 This function moves forward to the @var{count}th end of a defun.
684 If @var{count} is negative, this actually moves backward, but it still
685 moves to the end of a defun, not to the beginning of one. @var{count}
686 defaults to 1 if omitted.
689 @defopt defun-prompt-regexp
690 If non-@code{nil}, this variable holds a regular expression that
691 specifies what text can appear before the open-parenthesis that starts a
692 defun. That is to say, a defun begins on a line that starts with a
693 match for this regular expression, followed by a character with
694 open-parenthesis syntax.
697 @node Skipping Characters
698 @subsection Skipping Characters
699 @cindex skipping characters
701 The following two functions move point over a specified set of
702 characters. For example, they are often used to skip whitespace. For
703 related functions, see @ref{Motion and Syntax}.
705 @defun skip-chars-forward character-set &optional limit buffer
706 This function moves point in @var{buffer} forward, skipping over a
707 given set of characters. It examines the character following point,
708 then advances point if the character matches @var{character-set}. This
709 continues until it reaches a character that does not match. The
710 function returns @code{nil}. @var{buffer} defaults to the current
713 The argument @var{character-set} is like the inside of a
714 @samp{[@dots{}]} in a regular expression except that @samp{]} is never
715 special and @samp{\} quotes @samp{^}, @samp{-} or @samp{\}. Thus,
716 @code{"a-zA-Z"} skips over all letters, stopping before the first
717 non-letter, and @code{"^a-zA-Z}" skips non-letters stopping before the
718 first letter. @xref{Regular Expressions}.
720 If @var{limit} is supplied (it must be a number or a marker), it
721 specifies the maximum position in the buffer that point can be skipped
722 to. Point will stop at or before @var{limit}.
724 In the following example, point is initially located directly before the
725 @samp{T}. After the form is evaluated, point is located at the end of
726 that line (between the @samp{t} of @samp{hat} and the newline). The
727 function skips all letters and spaces, but not newlines.
731 ---------- Buffer: foo ----------
732 I read "@point{}The cat in the hat
734 ---------- Buffer: foo ----------
738 (skip-chars-forward "a-zA-Z ")
741 ---------- Buffer: foo ----------
742 I read "The cat in the hat@point{}
744 ---------- Buffer: foo ----------
749 @defun skip-chars-backward character-set &optional limit buffer
750 This function moves point backward, skipping characters that match
751 @var{character-set}, until @var{limit}. It just like
752 @code{skip-chars-forward} except for the direction of motion.
759 It is often useful to move point ``temporarily'' within a localized
760 portion of the program, or to switch buffers temporarily. This is
761 called an @dfn{excursion}, and it is done with the @code{save-excursion}
762 special form. This construct saves the current buffer and its values of
763 point and the mark so they can be restored after the completion of the
766 The forms for saving and restoring the configuration of windows are
767 described elsewhere (see @ref{Window Configurations} and @pxref{Frame
770 @defspec save-excursion forms@dots{}
771 @cindex mark excursion
772 @cindex point excursion
773 @cindex current buffer excursion
774 The @code{save-excursion} special form saves the identity of the current
775 buffer and the values of point and the mark in it, evaluates
776 @var{forms}, and finally restores the buffer and its saved values of
777 point and the mark. All three saved values are restored even in case of
778 an abnormal exit via @code{throw} or error (@pxref{Nonlocal Exits}).
780 The @code{save-excursion} special form is the standard way to switch
781 buffers or move point within one part of a program and avoid affecting
782 the rest of the program. It is used more than 500 times in the Lisp
785 @code{save-excursion} does not save the values of point and the mark for
786 other buffers, so changes in other buffers remain in effect after
787 @code{save-excursion} exits.
789 @cindex window excursions
790 Likewise, @code{save-excursion} does not restore window-buffer
791 correspondences altered by functions such as @code{switch-to-buffer}.
792 One way to restore these correspondences, and the selected window, is to
793 use @code{save-window-excursion} inside @code{save-excursion}
794 (@pxref{Window Configurations}).
796 The value returned by @code{save-excursion} is the result of the last of
797 @var{forms}, or @code{nil} if no @var{forms} are given.
804 (let ((old-buf (current-buffer))
805 (old-pnt (point-marker))
806 (old-mark (copy-marker (mark-marker))))
811 (set-marker (mark-marker) old-mark)))
816 @defspec save-current-buffer forms@dots{}
817 This special form is similar to @code{save-excursion} but it only
818 saves and restores the current buffer. Beginning with XEmacs 20.3,
819 @code{save-current-buffer} is a primitive.
822 @defspec with-current-buffer buffer forms@dots{}
823 This special form evaluates @var{forms} with @var{buffer} as the current
824 buffer. It returns the value of the last form.
827 @defspec with-temp-file filename forms@dots{}
828 This special form creates a new buffer, evaluates @var{forms} there, and
829 writes the buffer to @var{filename}. It returns the value of the last form
833 @defspec save-selected-window forms@dots{}
834 This special form is similar to @code{save-excursion} but it saves and
835 restores the selected window and nothing else.
841 @cindex restriction (in a buffer)
842 @cindex accessible portion (of a buffer)
844 @dfn{Narrowing} means limiting the text addressable by XEmacs editing
845 commands to a limited range of characters in a buffer. The text that
846 remains addressable is called the @dfn{accessible portion} of the
849 Narrowing is specified with two buffer positions which become the
850 beginning and end of the accessible portion. For most editing commands
851 and most Emacs primitives, these positions replace the values of the
852 beginning and end of the buffer. While narrowing is in effect, no text
853 outside the accessible portion is displayed, and point cannot move
854 outside the accessible portion.
856 Values such as positions or line numbers, which usually count from the
857 beginning of the buffer, do so despite narrowing, but the functions
858 which use them refuse to operate on text that is inaccessible.
860 The commands for saving buffers are unaffected by narrowing; they save
861 the entire buffer regardless of any narrowing.
863 @deffn Command narrow-to-region start end &optional buffer
864 This function sets the accessible portion of @var{buffer} to start at
865 @var{start} and end at @var{end}. Both arguments should be character
866 positions. @var{buffer} defaults to the current buffer if omitted.
868 In an interactive call, @var{start} and @var{end} are set to the bounds
869 of the current region (point and the mark, with the smallest first).
872 @deffn Command narrow-to-page &optional move-count
873 This function sets the accessible portion of the current buffer to
874 include just the current page. An optional first argument
875 @var{move-count} non-@code{nil} means to move forward or backward by
876 @var{move-count} pages and then narrow. The variable
877 @code{page-delimiter} specifies where pages start and end
878 (@pxref{Standard Regexps}).
880 In an interactive call, @var{move-count} is set to the numeric prefix
884 @deffn Command widen &optional buffer
886 This function cancels any narrowing in @var{buffer}, so that the
887 entire contents are accessible. This is called @dfn{widening}.
888 It is equivalent to the following expression:
891 (narrow-to-region 1 (1+ (buffer-size)))
894 @var{buffer} defaults to the current buffer if omitted.
897 @defspec save-restriction body@dots{}
898 This special form saves the current bounds of the accessible portion,
899 evaluates the @var{body} forms, and finally restores the saved bounds,
900 thus restoring the same state of narrowing (or absence thereof) formerly
901 in effect. The state of narrowing is restored even in the event of an
902 abnormal exit via @code{throw} or error (@pxref{Nonlocal Exits}).
903 Therefore, this construct is a clean way to narrow a buffer temporarily.
905 The value returned by @code{save-restriction} is that returned by the
906 last form in @var{body}, or @code{nil} if no body forms were given.
908 @c Wordy to avoid overfull hbox. --rjc 16mar92
909 @strong{Caution:} it is easy to make a mistake when using the
910 @code{save-restriction} construct. Read the entire description here
913 If @var{body} changes the current buffer, @code{save-restriction} still
914 restores the restrictions on the original buffer (the buffer whose
915 restrictions it saved from), but it does not restore the identity of the
918 @code{save-restriction} does @emph{not} restore point and the mark; use
919 @code{save-excursion} for that. If you use both @code{save-restriction}
920 and @code{save-excursion} together, @code{save-excursion} should come
921 first (on the outside). Otherwise, the old point value would be
922 restored with temporary narrowing still in effect. If the old point
923 value were outside the limits of the temporary narrowing, this would
924 fail to restore it accurately.
926 The @code{save-restriction} special form records the values of the
927 beginning and end of the accessible portion as distances from the
928 beginning and end of the buffer. In other words, it records the amount
929 of inaccessible text before and after the accessible portion.
931 This method yields correct results if @var{body} does further narrowing.
932 However, @code{save-restriction} can become confused if the body widens
933 and then make changes outside the range of the saved narrowing. When
934 this is what you want to do, @code{save-restriction} is not the right
935 tool for the job. Here is what you must use instead:
939 (let ((start (point-min-marker))
940 (end (point-max-marker)))
944 (set-buffer (marker-buffer start))
945 (narrow-to-region start end))))
949 Here is a simple example of correct use of @code{save-restriction}:
953 ---------- Buffer: foo ----------
954 This is the contents of foo
955 This is the contents of foo
956 This is the contents of foo@point{}
957 ---------- Buffer: foo ----------
965 (narrow-to-region 1 (point))
966 (goto-char (point-min))
967 (replace-string "foo" "bar")))
969 ---------- Buffer: foo ----------
970 This is the contents of bar
971 This is the contents of bar
972 This is the contents of foo@point{}
973 ---------- Buffer: foo ----------