Commit | Line | Data |
---|---|---|
b8d4c8d0 GM |
1 | @c -*-texinfo-*- |
2 | @c This is part of the GNU Emacs Lisp Reference Manual. | |
ab422c4d | 3 | @c Copyright (C) 1990-1995, 1998-2013 Free Software Foundation, Inc. |
b8d4c8d0 | 4 | @c See the file elisp.texi for copying conditions. |
ecc6530d | 5 | @node Positions |
b8d4c8d0 GM |
6 | @chapter Positions |
7 | @cindex position (in buffer) | |
8 | ||
9 | A @dfn{position} is the index of a character in the text of a buffer. | |
10 | More precisely, a position identifies the place between two characters | |
11 | (or before the first character, or after the last character), so we can | |
12 | speak of the character before or after a given position. However, we | |
13 | often speak of the character ``at'' a position, meaning the character | |
14 | after that position. | |
15 | ||
16 | Positions are usually represented as integers starting from 1, but | |
17 | can also be represented as @dfn{markers}---special objects that | |
18 | relocate automatically when text is inserted or deleted so they stay | |
19 | with the surrounding characters. Functions that expect an argument to | |
20 | be a position (an integer), but accept a marker as a substitute, | |
21 | normally ignore which buffer the marker points into; they convert the | |
22 | marker to an integer, and use that integer, exactly as if you had | |
23 | passed the integer as the argument, even if the marker points to the | |
24 | ``wrong'' buffer. A marker that points nowhere cannot convert to an | |
25 | integer; using it instead of an integer causes an error. | |
26 | @xref{Markers}. | |
27 | ||
28 | See also the ``field'' feature (@pxref{Fields}), which provides | |
29 | functions that are used by many cursor-motion commands. | |
30 | ||
31 | @menu | |
32 | * Point:: The special position where editing takes place. | |
33 | * Motion:: Changing point. | |
34 | * Excursions:: Temporary motion and buffer changes. | |
35 | * Narrowing:: Restricting editing to a portion of the buffer. | |
36 | @end menu | |
37 | ||
38 | @node Point | |
39 | @section Point | |
40 | @cindex point | |
41 | ||
42 | @dfn{Point} is a special buffer position used by many editing | |
43 | commands, including the self-inserting typed characters and text | |
44 | insertion functions. Other commands move point through the text | |
45 | to allow editing and insertion at different places. | |
46 | ||
47 | Like other positions, point designates a place between two characters | |
48 | (or before the first character, or after the last character), rather | |
49 | than a particular character. Usually terminals display the cursor over | |
50 | the character that immediately follows point; point is actually before | |
51 | the character on which the cursor sits. | |
52 | ||
53 | @cindex point with narrowing | |
54 | The value of point is a number no less than 1, and no greater than the | |
55 | buffer size plus 1. If narrowing is in effect (@pxref{Narrowing}), then | |
56 | point is constrained to fall within the accessible portion of the buffer | |
57 | (possibly at one end of it). | |
58 | ||
59 | Each buffer has its own value of point, which is independent of the | |
60 | value of point in other buffers. Each window also has a value of point, | |
61 | which is independent of the value of point in other windows on the same | |
62 | buffer. This is why point can have different values in various windows | |
63 | that display the same buffer. When a buffer appears in only one window, | |
64 | the buffer's point and the window's point normally have the same value, | |
65 | so the distinction is rarely important. @xref{Window Point}, for more | |
66 | details. | |
67 | ||
68 | @defun point | |
69 | @cindex current buffer position | |
70 | This function returns the value of point in the current buffer, | |
71 | as an integer. | |
72 | ||
73 | @need 700 | |
74 | @example | |
75 | @group | |
76 | (point) | |
77 | @result{} 175 | |
78 | @end group | |
79 | @end example | |
80 | @end defun | |
81 | ||
82 | @defun point-min | |
83 | This function returns the minimum accessible value of point in the | |
84 | current buffer. This is normally 1, but if narrowing is in effect, it | |
85 | is the position of the start of the region that you narrowed to. | |
86 | (@xref{Narrowing}.) | |
87 | @end defun | |
88 | ||
89 | @defun point-max | |
90 | This function returns the maximum accessible value of point in the | |
91 | current buffer. This is @code{(1+ (buffer-size))}, unless narrowing is | |
92 | in effect, in which case it is the position of the end of the region | |
93 | that you narrowed to. (@xref{Narrowing}.) | |
94 | @end defun | |
95 | ||
96 | @defun buffer-end flag | |
97 | This function returns @code{(point-max)} if @var{flag} is greater than | |
98 | 0, @code{(point-min)} otherwise. The argument @var{flag} must be a | |
99 | number. | |
100 | @end defun | |
101 | ||
102 | @defun buffer-size &optional buffer | |
103 | This function returns the total number of characters in the current | |
104 | buffer. In the absence of any narrowing (@pxref{Narrowing}), | |
105 | @code{point-max} returns a value one larger than this. | |
106 | ||
107 | If you specify a buffer, @var{buffer}, then the value is the | |
108 | size of @var{buffer}. | |
109 | ||
110 | @example | |
111 | @group | |
112 | (buffer-size) | |
113 | @result{} 35 | |
114 | @end group | |
115 | @group | |
116 | (point-max) | |
117 | @result{} 36 | |
118 | @end group | |
119 | @end example | |
120 | @end defun | |
121 | ||
122 | @node Motion | |
123 | @section Motion | |
124 | @cindex motion by chars, words, lines, lists | |
125 | ||
126 | Motion functions change the value of point, either relative to the | |
127 | current value of point, relative to the beginning or end of the buffer, | |
128 | or relative to the edges of the selected window. @xref{Point}. | |
129 | ||
130 | @menu | |
131 | * Character Motion:: Moving in terms of characters. | |
132 | * Word Motion:: Moving in terms of words. | |
133 | * Buffer End Motion:: Moving to the beginning or end of the buffer. | |
134 | * Text Lines:: Moving in terms of lines of text. | |
135 | * Screen Lines:: Moving in terms of lines as displayed. | |
136 | * List Motion:: Moving by parsing lists and sexps. | |
137 | * Skipping Characters:: Skipping characters belonging to a certain set. | |
138 | @end menu | |
139 | ||
140 | @node Character Motion | |
141 | @subsection Motion by Characters | |
142 | ||
143 | These functions move point based on a count of characters. | |
144 | @code{goto-char} is the fundamental primitive; the other functions use | |
145 | that. | |
146 | ||
147 | @deffn Command goto-char position | |
148 | This function sets point in the current buffer to the value | |
149 | @var{position}. If @var{position} is less than 1, it moves point to the | |
150 | beginning of the buffer. If @var{position} is greater than the length | |
151 | of the buffer, it moves point to the end. | |
152 | ||
153 | If narrowing is in effect, @var{position} still counts from the | |
154 | beginning of the buffer, but point cannot go outside the accessible | |
155 | portion. If @var{position} is out of range, @code{goto-char} moves | |
156 | point to the beginning or the end of the accessible portion. | |
157 | ||
158 | When this function is called interactively, @var{position} is the | |
159 | numeric prefix argument, if provided; otherwise it is read from the | |
160 | minibuffer. | |
161 | ||
162 | @code{goto-char} returns @var{position}. | |
163 | @end deffn | |
164 | ||
165 | @deffn Command forward-char &optional count | |
166 | @c @kindex beginning-of-buffer | |
167 | @c @kindex end-of-buffer | |
168 | This function moves point @var{count} characters forward, towards the | |
169 | end of the buffer (or backward, towards the beginning of the buffer, if | |
170 | @var{count} is negative). If @var{count} is @code{nil}, the default | |
171 | is 1. | |
172 | ||
173 | If this attempts to move past the beginning or end of the buffer (or | |
174 | the limits of the accessible portion, when narrowing is in effect), it | |
175 | signals an error with error symbol @code{beginning-of-buffer} or | |
176 | @code{end-of-buffer}. | |
177 | ||
178 | In an interactive call, @var{count} is the numeric prefix argument. | |
179 | @end deffn | |
180 | ||
181 | @deffn Command backward-char &optional count | |
182 | This is just like @code{forward-char} except that it moves | |
183 | in the opposite direction. | |
184 | @end deffn | |
185 | ||
186 | @node Word Motion | |
187 | @subsection Motion by Words | |
188 | ||
189 | These functions for parsing words use the syntax table to decide | |
190 | whether a given character is part of a word. @xref{Syntax Tables}. | |
191 | ||
192 | @deffn Command forward-word &optional count | |
193 | This function moves point forward @var{count} words (or backward if | |
194 | @var{count} is negative). If @var{count} is @code{nil}, it moves | |
195 | forward one word. | |
196 | ||
197 | ``Moving one word'' means moving until point crosses a | |
198 | word-constituent character and then encounters a word-separator | |
199 | character. However, this function cannot move point past the boundary | |
200 | of the accessible portion of the buffer, or across a field boundary | |
201 | (@pxref{Fields}). The most common case of a field boundary is the end | |
202 | of the prompt in the minibuffer. | |
203 | ||
204 | If it is possible to move @var{count} words, without being stopped | |
205 | prematurely by the buffer boundary or a field boundary, the value is | |
206 | @code{t}. Otherwise, the return value is @code{nil} and point stops at | |
207 | the buffer boundary or field boundary. | |
208 | ||
209 | If @code{inhibit-field-text-motion} is non-@code{nil}, | |
210 | this function ignores field boundaries. | |
211 | ||
212 | In an interactive call, @var{count} is specified by the numeric prefix | |
213 | argument. If @var{count} is omitted or @code{nil}, it defaults to 1. | |
214 | @end deffn | |
215 | ||
216 | @deffn Command backward-word &optional count | |
217 | This function is just like @code{forward-word}, except that it moves | |
218 | backward until encountering the front of a word, rather than forward. | |
219 | @end deffn | |
220 | ||
01f17ae2 | 221 | @defopt words-include-escapes |
b8d4c8d0 GM |
222 | @c Emacs 19 feature |
223 | This variable affects the behavior of @code{forward-word} and everything | |
224 | that uses it. If it is non-@code{nil}, then characters in the | |
225 | ``escape'' and ``character quote'' syntax classes count as part of | |
226 | words. Otherwise, they do not. | |
01f17ae2 | 227 | @end defopt |
b8d4c8d0 GM |
228 | |
229 | @defvar inhibit-field-text-motion | |
230 | If this variable is non-@code{nil}, certain motion functions including | |
231 | @code{forward-word}, @code{forward-sentence}, and | |
232 | @code{forward-paragraph} ignore field boundaries. | |
233 | @end defvar | |
234 | ||
235 | @node Buffer End Motion | |
236 | @subsection Motion to an End of the Buffer | |
237 | @cindex move to beginning or end of buffer | |
238 | ||
239 | To move point to the beginning of the buffer, write: | |
240 | ||
241 | @example | |
242 | @group | |
243 | (goto-char (point-min)) | |
244 | @end group | |
245 | @end example | |
246 | ||
247 | @noindent | |
248 | Likewise, to move to the end of the buffer, use: | |
249 | ||
250 | @example | |
251 | @group | |
252 | (goto-char (point-max)) | |
253 | @end group | |
254 | @end example | |
255 | ||
256 | Here are two commands that users use to do these things. They are | |
257 | documented here to warn you not to use them in Lisp programs, because | |
258 | they set the mark and display messages in the echo area. | |
259 | ||
260 | @deffn Command beginning-of-buffer &optional n | |
261 | This function moves point to the beginning of the buffer (or the limits | |
262 | of the accessible portion, when narrowing is in effect), setting the | |
263 | mark at the previous position (except in Transient Mark mode, if | |
264 | the mark is already active, it does not set the mark.) | |
265 | ||
266 | If @var{n} is non-@code{nil}, then it puts point @var{n} tenths of the | |
267 | way from the beginning of the accessible portion of the buffer. In an | |
268 | interactive call, @var{n} is the numeric prefix argument, if provided; | |
269 | otherwise @var{n} defaults to @code{nil}. | |
270 | ||
271 | @strong{Warning:} Don't use this function in Lisp programs! | |
272 | @end deffn | |
273 | ||
274 | @deffn Command end-of-buffer &optional n | |
275 | This function moves point to the end of the buffer (or the limits of | |
276 | the accessible portion, when narrowing is in effect), setting the mark | |
277 | at the previous position (except in Transient Mark mode when the mark | |
278 | is already active). If @var{n} is non-@code{nil}, then it puts point | |
279 | @var{n} tenths of the way from the end of the accessible portion of | |
280 | the buffer. | |
281 | ||
282 | In an interactive call, @var{n} is the numeric prefix argument, | |
283 | if provided; otherwise @var{n} defaults to @code{nil}. | |
284 | ||
285 | @strong{Warning:} Don't use this function in Lisp programs! | |
286 | @end deffn | |
287 | ||
288 | @node Text Lines | |
289 | @subsection Motion by Text Lines | |
290 | @cindex lines | |
291 | ||
292 | Text lines are portions of the buffer delimited by newline characters, | |
293 | which are regarded as part of the previous line. The first text line | |
294 | begins at the beginning of the buffer, and the last text line ends at | |
295 | the end of the buffer whether or not the last character is a newline. | |
296 | The division of the buffer into text lines is not affected by the width | |
297 | of the window, by line continuation in display, or by how tabs and | |
298 | control characters are displayed. | |
299 | ||
b8d4c8d0 GM |
300 | @deffn Command beginning-of-line &optional count |
301 | This function moves point to the beginning of the current line. With an | |
302 | argument @var{count} not @code{nil} or 1, it moves forward | |
303 | @var{count}@minus{}1 lines and then to the beginning of the line. | |
304 | ||
305 | This function does not move point across a field boundary | |
306 | (@pxref{Fields}) unless doing so would move beyond there to a | |
307 | different line; therefore, if @var{count} is @code{nil} or 1, and | |
308 | point starts at a field boundary, point does not move. To ignore | |
309 | field boundaries, either bind @code{inhibit-field-text-motion} to | |
310 | @code{t}, or use the @code{forward-line} function instead. For | |
311 | instance, @code{(forward-line 0)} does the same thing as | |
312 | @code{(beginning-of-line)}, except that it ignores field boundaries. | |
313 | ||
314 | If this function reaches the end of the buffer (or of the accessible | |
315 | portion, if narrowing is in effect), it positions point there. No error | |
316 | is signaled. | |
317 | @end deffn | |
318 | ||
319 | @defun line-beginning-position &optional count | |
320 | Return the position that @code{(beginning-of-line @var{count})} | |
321 | would move to. | |
322 | @end defun | |
323 | ||
324 | @deffn Command end-of-line &optional count | |
325 | This function moves point to the end of the current line. With an | |
326 | argument @var{count} not @code{nil} or 1, it moves forward | |
327 | @var{count}@minus{}1 lines and then to the end of the line. | |
328 | ||
329 | This function does not move point across a field boundary | |
330 | (@pxref{Fields}) unless doing so would move beyond there to a | |
331 | different line; therefore, if @var{count} is @code{nil} or 1, and | |
332 | point starts at a field boundary, point does not move. To ignore | |
333 | field boundaries, bind @code{inhibit-field-text-motion} to @code{t}. | |
334 | ||
335 | If this function reaches the end of the buffer (or of the accessible | |
336 | portion, if narrowing is in effect), it positions point there. No error | |
337 | is signaled. | |
338 | @end deffn | |
339 | ||
340 | @defun line-end-position &optional count | |
341 | Return the position that @code{(end-of-line @var{count})} | |
342 | would move to. | |
343 | @end defun | |
344 | ||
345 | @deffn Command forward-line &optional count | |
346 | @cindex beginning of line | |
347 | This function moves point forward @var{count} lines, to the beginning of | |
348 | the line. If @var{count} is negative, it moves point | |
349 | @minus{}@var{count} lines backward, to the beginning of a line. If | |
350 | @var{count} is zero, it moves point to the beginning of the current | |
351 | line. If @var{count} is @code{nil}, that means 1. | |
352 | ||
353 | If @code{forward-line} encounters the beginning or end of the buffer (or | |
354 | of the accessible portion) before finding that many lines, it sets point | |
355 | there. No error is signaled. | |
356 | ||
357 | @code{forward-line} returns the difference between @var{count} and the | |
358 | number of lines actually moved. If you attempt to move down five lines | |
359 | from the beginning of a buffer that has only three lines, point stops at | |
360 | the end of the last line, and the value will be 2. | |
361 | ||
362 | In an interactive call, @var{count} is the numeric prefix argument. | |
363 | @end deffn | |
364 | ||
365 | @defun count-lines start end | |
366 | @cindex lines in region | |
367 | @anchor{Definition of count-lines} | |
368 | This function returns the number of lines between the positions | |
369 | @var{start} and @var{end} in the current buffer. If @var{start} and | |
370 | @var{end} are equal, then it returns 0. Otherwise it returns at least | |
371 | 1, even if @var{start} and @var{end} are on the same line. This is | |
372 | because the text between them, considered in isolation, must contain at | |
373 | least one line unless it is empty. | |
ef959d3a | 374 | @end defun |
b8d4c8d0 | 375 | |
ef959d3a CY |
376 | @deffn Command count-words start end |
377 | @cindex words in region | |
378 | This function returns the number of words between the positions | |
379 | @var{start} and @var{end} in the current buffer. | |
b8d4c8d0 | 380 | |
ef959d3a CY |
381 | This function can also be called interactively. In that case, it |
382 | prints a message reporting the number of lines, words, and characters | |
383 | in the buffer, or in the region if the region is active. | |
384 | @end deffn | |
b8d4c8d0 GM |
385 | |
386 | @defun line-number-at-pos &optional pos | |
387 | @cindex line number | |
388 | This function returns the line number in the current buffer | |
389 | corresponding to the buffer position @var{pos}. If @var{pos} is @code{nil} | |
390 | or omitted, the current buffer position is used. | |
391 | @end defun | |
392 | ||
393 | @ignore | |
394 | @c ================ | |
395 | The @code{previous-line} and @code{next-line} commands are functions | |
396 | that should not be used in programs. They are for users and are | |
397 | mentioned here only for completeness. | |
398 | ||
399 | @deffn Command previous-line count | |
400 | @cindex goal column | |
401 | This function moves point up @var{count} lines (down if @var{count} | |
402 | is negative). In moving, it attempts to keep point in the ``goal column'' | |
403 | (normally the same column that it was at the beginning of the move). | |
404 | ||
405 | If there is no character in the target line exactly under the current | |
406 | column, point is positioned after the character in that line which | |
407 | spans this column, or at the end of the line if it is not long enough. | |
408 | ||
409 | If it attempts to move beyond the top or bottom of the buffer (or clipped | |
410 | region), then point is positioned in the goal column in the top or | |
411 | bottom line. No error is signaled. | |
412 | ||
413 | In an interactive call, @var{count} will be the numeric | |
414 | prefix argument. | |
415 | ||
416 | The command @code{set-goal-column} can be used to create a semipermanent | |
417 | goal column to which this command always moves. Then it does not try to | |
418 | move vertically. | |
419 | ||
420 | If you are thinking of using this in a Lisp program, consider using | |
421 | @code{forward-line} with a negative argument instead. It is usually easier | |
422 | to use and more reliable (no dependence on goal column, etc.). | |
423 | @end deffn | |
424 | ||
425 | @deffn Command next-line count | |
426 | This function moves point down @var{count} lines (up if @var{count} | |
427 | is negative). In moving, it attempts to keep point in the ``goal column'' | |
428 | (normally the same column that it was at the beginning of the move). | |
429 | ||
430 | If there is no character in the target line exactly under the current | |
431 | column, point is positioned after the character in that line which | |
432 | spans this column, or at the end of the line if it is not long enough. | |
433 | ||
434 | If it attempts to move beyond the top or bottom of the buffer (or clipped | |
435 | region), then point is positioned in the goal column in the top or | |
436 | bottom line. No error is signaled. | |
437 | ||
438 | In the case where the @var{count} is 1, and point is on the last | |
439 | line of the buffer (or clipped region), a new empty line is inserted at the | |
440 | end of the buffer (or clipped region) and point moved there. | |
441 | ||
442 | In an interactive call, @var{count} will be the numeric | |
443 | prefix argument. | |
444 | ||
445 | The command @code{set-goal-column} can be used to create a semipermanent | |
446 | goal column to which this command always moves. Then it does not try to | |
447 | move vertically. | |
448 | ||
449 | If you are thinking of using this in a Lisp program, consider using | |
450 | @code{forward-line} instead. It is usually easier | |
451 | to use and more reliable (no dependence on goal column, etc.). | |
452 | @end deffn | |
453 | ||
454 | @c ================ | |
455 | @end ignore | |
456 | ||
457 | Also see the functions @code{bolp} and @code{eolp} in @ref{Near Point}. | |
458 | These functions do not move point, but test whether it is already at the | |
459 | beginning or end of a line. | |
460 | ||
461 | @node Screen Lines | |
462 | @subsection Motion by Screen Lines | |
463 | ||
464 | The line functions in the previous section count text lines, delimited | |
465 | only by newline characters. By contrast, these functions count screen | |
466 | lines, which are defined by the way the text appears on the screen. A | |
467 | text line is a single screen line if it is short enough to fit the width | |
468 | of the selected window, but otherwise it may occupy several screen | |
469 | lines. | |
470 | ||
471 | In some cases, text lines are truncated on the screen rather than | |
472 | continued onto additional screen lines. In these cases, | |
473 | @code{vertical-motion} moves point much like @code{forward-line}. | |
474 | @xref{Truncation}. | |
475 | ||
476 | Because the width of a given string depends on the flags that control | |
477 | the appearance of certain characters, @code{vertical-motion} behaves | |
478 | differently, for a given piece of text, depending on the buffer it is | |
479 | in, and even on the selected window (because the width, the truncation | |
480 | flag, and display table may vary between windows). @xref{Usual | |
481 | Display}. | |
482 | ||
483 | These functions scan text to determine where screen lines break, and | |
484 | thus take time proportional to the distance scanned. If you intend to | |
485 | use them heavily, Emacs provides caches which may improve the | |
486 | performance of your code. @xref{Truncation, cache-long-line-scans}. | |
487 | ||
488 | @defun vertical-motion count &optional window | |
489 | This function moves point to the start of the screen line @var{count} | |
490 | screen lines down from the screen line containing point. If @var{count} | |
491 | is negative, it moves up instead. | |
492 | ||
ea30ce4f CY |
493 | The @var{count} argument can be a cons cell, @code{(@var{cols} |
494 | . @var{lines})}, instead of an integer. Then the function moves by | |
495 | @var{lines} screen lines, and puts point @var{cols} columns from the | |
496 | start of that screen line. | |
497 | ||
498 | The return value is the number of screen lines over which point was | |
499 | moved. The value may be less in absolute value than @var{count} if | |
500 | the beginning or end of the buffer was reached. | |
b8d4c8d0 GM |
501 | |
502 | The window @var{window} is used for obtaining parameters such as the | |
503 | width, the horizontal scrolling, and the display table. But | |
504 | @code{vertical-motion} always operates on the current buffer, even if | |
505 | @var{window} currently displays some other buffer. | |
506 | @end defun | |
507 | ||
508 | @defun count-screen-lines &optional beg end count-final-newline window | |
509 | This function returns the number of screen lines in the text from | |
510 | @var{beg} to @var{end}. The number of screen lines may be different | |
511 | from the number of actual lines, due to line continuation, the display | |
512 | table, etc. If @var{beg} and @var{end} are @code{nil} or omitted, | |
513 | they default to the beginning and end of the accessible portion of the | |
514 | buffer. | |
515 | ||
516 | If the region ends with a newline, that is ignored unless the optional | |
517 | third argument @var{count-final-newline} is non-@code{nil}. | |
518 | ||
519 | The optional fourth argument @var{window} specifies the window for | |
520 | obtaining parameters such as width, horizontal scrolling, and so on. | |
521 | The default is to use the selected window's parameters. | |
522 | ||
523 | Like @code{vertical-motion}, @code{count-screen-lines} always uses the | |
524 | current buffer, regardless of which buffer is displayed in | |
525 | @var{window}. This makes possible to use @code{count-screen-lines} in | |
526 | any buffer, whether or not it is currently displayed in some window. | |
527 | @end defun | |
528 | ||
529 | @deffn Command move-to-window-line count | |
530 | This function moves point with respect to the text currently displayed | |
531 | in the selected window. It moves point to the beginning of the screen | |
532 | line @var{count} screen lines from the top of the window. If | |
533 | @var{count} is negative, that specifies a position | |
534 | @w{@minus{}@var{count}} lines from the bottom (or the last line of the | |
535 | buffer, if the buffer ends above the specified screen position). | |
536 | ||
537 | If @var{count} is @code{nil}, then point moves to the beginning of the | |
538 | line in the middle of the window. If the absolute value of @var{count} | |
539 | is greater than the size of the window, then point moves to the place | |
540 | that would appear on that screen line if the window were tall enough. | |
541 | This will probably cause the next redisplay to scroll to bring that | |
542 | location onto the screen. | |
543 | ||
544 | In an interactive call, @var{count} is the numeric prefix argument. | |
545 | ||
546 | The value returned is the window line number point has moved to, with | |
547 | the top line in the window numbered 0. | |
548 | @end deffn | |
549 | ||
550 | @defun compute-motion from frompos to topos width offsets window | |
551 | This function scans the current buffer, calculating screen positions. | |
552 | It scans the buffer forward from position @var{from}, assuming that is | |
553 | at screen coordinates @var{frompos}, to position @var{to} or coordinates | |
554 | @var{topos}, whichever comes first. It returns the ending buffer | |
555 | position and screen coordinates. | |
556 | ||
557 | The coordinate arguments @var{frompos} and @var{topos} are cons cells of | |
558 | the form @code{(@var{hpos} . @var{vpos})}. | |
559 | ||
560 | The argument @var{width} is the number of columns available to display | |
561 | text; this affects handling of continuation lines. @code{nil} means | |
562 | the actual number of usable text columns in the window, which is | |
563 | equivalent to the value returned by @code{(window-width window)}. | |
564 | ||
565 | The argument @var{offsets} is either @code{nil} or a cons cell of the | |
566 | form @code{(@var{hscroll} . @var{tab-offset})}. Here @var{hscroll} is | |
567 | the number of columns not being displayed at the left margin; most | |
568 | callers get this by calling @code{window-hscroll}. Meanwhile, | |
569 | @var{tab-offset} is the offset between column numbers on the screen and | |
570 | column numbers in the buffer. This can be nonzero in a continuation | |
571 | line, when the previous screen lines' widths do not add up to a multiple | |
572 | of @code{tab-width}. It is always zero in a non-continuation line. | |
573 | ||
574 | The window @var{window} serves only to specify which display table to | |
575 | use. @code{compute-motion} always operates on the current buffer, | |
576 | regardless of what buffer is displayed in @var{window}. | |
577 | ||
578 | The return value is a list of five elements: | |
579 | ||
580 | @example | |
581 | (@var{pos} @var{hpos} @var{vpos} @var{prevhpos} @var{contin}) | |
582 | @end example | |
583 | ||
584 | @noindent | |
585 | Here @var{pos} is the buffer position where the scan stopped, @var{vpos} | |
586 | is the vertical screen position, and @var{hpos} is the horizontal screen | |
587 | position. | |
588 | ||
589 | The result @var{prevhpos} is the horizontal position one character back | |
590 | from @var{pos}. The result @var{contin} is @code{t} if the last line | |
591 | was continued after (or within) the previous character. | |
592 | ||
593 | For example, to find the buffer position of column @var{col} of screen line | |
594 | @var{line} of a certain window, pass the window's display start location | |
595 | as @var{from} and the window's upper-left coordinates as @var{frompos}. | |
596 | Pass the buffer's @code{(point-max)} as @var{to}, to limit the scan to | |
597 | the end of the accessible portion of the buffer, and pass @var{line} and | |
598 | @var{col} as @var{topos}. Here's a function that does this: | |
599 | ||
600 | @example | |
601 | (defun coordinates-of-position (col line) | |
602 | (car (compute-motion (window-start) | |
603 | '(0 . 0) | |
604 | (point-max) | |
605 | (cons col line) | |
606 | (window-width) | |
607 | (cons (window-hscroll) 0) | |
608 | (selected-window)))) | |
609 | @end example | |
610 | ||
611 | When you use @code{compute-motion} for the minibuffer, you need to use | |
612 | @code{minibuffer-prompt-width} to get the horizontal position of the | |
613 | beginning of the first screen line. @xref{Minibuffer Contents}. | |
614 | @end defun | |
615 | ||
616 | @node List Motion | |
b8d4c8d0 GM |
617 | @subsection Moving over Balanced Expressions |
618 | @cindex sexp motion | |
619 | @cindex Lisp expression motion | |
620 | @cindex list motion | |
621 | @cindex balanced parenthesis motion | |
622 | ||
623 | Here are several functions concerned with balanced-parenthesis | |
624 | expressions (also called @dfn{sexps} in connection with moving across | |
625 | them in Emacs). The syntax table controls how these functions interpret | |
626 | various characters; see @ref{Syntax Tables}. @xref{Parsing | |
627 | Expressions}, for lower-level primitives for scanning sexps or parts of | |
628 | sexps. For user-level commands, see @ref{Parentheses,, Commands for | |
629 | Editing with Parentheses, emacs, The GNU Emacs Manual}. | |
630 | ||
631 | @deffn Command forward-list &optional arg | |
632 | This function moves forward across @var{arg} (default 1) balanced groups of | |
633 | parentheses. (Other syntactic entities such as words or paired string | |
634 | quotes are ignored.) | |
635 | @end deffn | |
636 | ||
637 | @deffn Command backward-list &optional arg | |
638 | This function moves backward across @var{arg} (default 1) balanced groups of | |
639 | parentheses. (Other syntactic entities such as words or paired string | |
640 | quotes are ignored.) | |
641 | @end deffn | |
642 | ||
643 | @deffn Command up-list &optional arg | |
644 | This function moves forward out of @var{arg} (default 1) levels of parentheses. | |
645 | A negative argument means move backward but still to a less deep spot. | |
646 | @end deffn | |
647 | ||
648 | @deffn Command down-list &optional arg | |
649 | This function moves forward into @var{arg} (default 1) levels of | |
650 | parentheses. A negative argument means move backward but still go | |
651 | deeper in parentheses (@minus{}@var{arg} levels). | |
652 | @end deffn | |
653 | ||
654 | @deffn Command forward-sexp &optional arg | |
655 | This function moves forward across @var{arg} (default 1) balanced expressions. | |
656 | Balanced expressions include both those delimited by parentheses and | |
657 | other kinds, such as words and string constants. | |
658 | @xref{Parsing Expressions}. For example, | |
659 | ||
660 | @example | |
661 | @group | |
662 | ---------- Buffer: foo ---------- | |
663 | (concat@point{} "foo " (car x) y z) | |
664 | ---------- Buffer: foo ---------- | |
665 | @end group | |
666 | ||
667 | @group | |
668 | (forward-sexp 3) | |
669 | @result{} nil | |
670 | ||
671 | ---------- Buffer: foo ---------- | |
672 | (concat "foo " (car x) y@point{} z) | |
673 | ---------- Buffer: foo ---------- | |
674 | @end group | |
675 | @end example | |
676 | @end deffn | |
677 | ||
678 | @deffn Command backward-sexp &optional arg | |
679 | This function moves backward across @var{arg} (default 1) balanced expressions. | |
680 | @end deffn | |
681 | ||
682 | @deffn Command beginning-of-defun &optional arg | |
683 | This function moves back to the @var{arg}th beginning of a defun. If | |
684 | @var{arg} is negative, this actually moves forward, but it still moves | |
685 | to the beginning of a defun, not to the end of one. @var{arg} defaults | |
686 | to 1. | |
687 | @end deffn | |
688 | ||
689 | @deffn Command end-of-defun &optional arg | |
690 | This function moves forward to the @var{arg}th end of a defun. If | |
691 | @var{arg} is negative, this actually moves backward, but it still moves | |
692 | to the end of a defun, not to the beginning of one. @var{arg} defaults | |
693 | to 1. | |
694 | @end deffn | |
695 | ||
696 | @defopt defun-prompt-regexp | |
697 | If non-@code{nil}, this buffer-local variable holds a regular | |
698 | expression that specifies what text can appear before the | |
699 | open-parenthesis that starts a defun. That is to say, a defun begins | |
700 | on a line that starts with a match for this regular expression, | |
701 | followed by a character with open-parenthesis syntax. | |
702 | @end defopt | |
703 | ||
704 | @defopt open-paren-in-column-0-is-defun-start | |
705 | If this variable's value is non-@code{nil}, an open parenthesis in | |
706 | column 0 is considered to be the start of a defun. If it is | |
707 | @code{nil}, an open parenthesis in column 0 has no special meaning. | |
708 | The default is @code{t}. | |
709 | @end defopt | |
710 | ||
711 | @defvar beginning-of-defun-function | |
712 | If non-@code{nil}, this variable holds a function for finding the | |
713 | beginning of a defun. The function @code{beginning-of-defun} | |
52441368 EZ |
714 | calls this function instead of using its normal method, passing it its |
715 | optional argument. If the argument is non-@code{nil}, the function | |
716 | should move back by that many functions, like | |
717 | @code{beginning-of-defun} does. | |
b8d4c8d0 GM |
718 | @end defvar |
719 | ||
720 | @defvar end-of-defun-function | |
721 | If non-@code{nil}, this variable holds a function for finding the end of | |
722 | a defun. The function @code{end-of-defun} calls this function instead | |
723 | of using its normal method. | |
724 | @end defvar | |
725 | ||
726 | @node Skipping Characters | |
b8d4c8d0 GM |
727 | @subsection Skipping Characters |
728 | @cindex skipping characters | |
729 | ||
730 | The following two functions move point over a specified set of | |
731 | characters. For example, they are often used to skip whitespace. For | |
732 | related functions, see @ref{Motion and Syntax}. | |
733 | ||
734 | These functions convert the set string to multibyte if the buffer is | |
735 | multibyte, and they convert it to unibyte if the buffer is unibyte, as | |
736 | the search functions do (@pxref{Searching and Matching}). | |
737 | ||
738 | @defun skip-chars-forward character-set &optional limit | |
739 | This function moves point in the current buffer forward, skipping over a | |
740 | given set of characters. It examines the character following point, | |
741 | then advances point if the character matches @var{character-set}. This | |
742 | continues until it reaches a character that does not match. The | |
743 | function returns the number of characters moved over. | |
744 | ||
745 | The argument @var{character-set} is a string, like the inside of a | |
746 | @samp{[@dots{}]} in a regular expression except that @samp{]} does not | |
747 | terminate it, and @samp{\} quotes @samp{^}, @samp{-} or @samp{\}. | |
748 | Thus, @code{"a-zA-Z"} skips over all letters, stopping before the | |
749 | first nonletter, and @code{"^a-zA-Z"} skips nonletters stopping before | |
750 | the first letter. See @xref{Regular Expressions}. Character classes | |
1df7defd | 751 | can also be used, e.g., @code{"[:alnum:]"}. See @pxref{Char Classes}. |
b8d4c8d0 GM |
752 | |
753 | If @var{limit} is supplied (it must be a number or a marker), it | |
754 | specifies the maximum position in the buffer that point can be skipped | |
755 | to. Point will stop at or before @var{limit}. | |
756 | ||
757 | In the following example, point is initially located directly before the | |
758 | @samp{T}. After the form is evaluated, point is located at the end of | |
759 | that line (between the @samp{t} of @samp{hat} and the newline). The | |
760 | function skips all letters and spaces, but not newlines. | |
761 | ||
762 | @example | |
763 | @group | |
764 | ---------- Buffer: foo ---------- | |
765 | I read "@point{}The cat in the hat | |
766 | comes back" twice. | |
767 | ---------- Buffer: foo ---------- | |
768 | @end group | |
769 | ||
770 | @group | |
771 | (skip-chars-forward "a-zA-Z ") | |
5c8ad206 | 772 | @result{} 18 |
b8d4c8d0 GM |
773 | |
774 | ---------- Buffer: foo ---------- | |
775 | I read "The cat in the hat@point{} | |
776 | comes back" twice. | |
777 | ---------- Buffer: foo ---------- | |
778 | @end group | |
779 | @end example | |
780 | @end defun | |
781 | ||
782 | @defun skip-chars-backward character-set &optional limit | |
783 | This function moves point backward, skipping characters that match | |
784 | @var{character-set}, until @var{limit}. It is just like | |
785 | @code{skip-chars-forward} except for the direction of motion. | |
786 | ||
787 | The return value indicates the distance traveled. It is an integer that | |
788 | is zero or less. | |
789 | @end defun | |
790 | ||
791 | @node Excursions | |
792 | @section Excursions | |
793 | @cindex excursion | |
794 | ||
795 | It is often useful to move point ``temporarily'' within a localized | |
c1bcd0d5 CY |
796 | portion of the program. This is called an @dfn{excursion}, and it is |
797 | done with the @code{save-excursion} special form. This construct | |
798 | remembers the initial identity of the current buffer, and its values | |
799 | of point and the mark, and restores them after the excursion | |
800 | completes. It is the standard way to move point within one part of a | |
801 | program and avoid affecting the rest of the program, and is used | |
802 | thousands of times in the Lisp sources of Emacs. | |
803 | ||
804 | If you only need to save and restore the identity of the current | |
805 | buffer, use @code{save-current-buffer} or @code{with-current-buffer} | |
806 | instead (@pxref{Current Buffer}). If you need to save or restore | |
807 | window configurations, see the forms described in @ref{Window | |
808 | Configurations} and in @ref{Frame Configurations}. | |
b8d4c8d0 GM |
809 | |
810 | @defspec save-excursion body@dots{} | |
811 | @cindex mark excursion | |
812 | @cindex point excursion | |
c1bcd0d5 CY |
813 | This special form saves the identity of the current buffer and the |
814 | values of point and the mark in it, evaluates @var{body}, and finally | |
815 | restores the buffer and its saved values of point and the mark. All | |
816 | three saved values are restored even in case of an abnormal exit via | |
817 | @code{throw} or error (@pxref{Nonlocal Exits}). | |
b8d4c8d0 | 818 | |
c1bcd0d5 CY |
819 | The value returned by @code{save-excursion} is the result of the last |
820 | form in @var{body}, or @code{nil} if no body forms were given. | |
821 | @end defspec | |
b8d4c8d0 | 822 | |
c1bcd0d5 CY |
823 | Because @code{save-excursion} only saves point and mark for the |
824 | buffer that was current at the start of the excursion, any changes | |
825 | made to point and/or mark in other buffers, during the excursion, will | |
826 | remain in effect afterward. This frequently leads to unintended | |
827 | consequences, so the byte compiler warns if you call @code{set-buffer} | |
828 | during an excursion: | |
b8d4c8d0 | 829 | |
c1bcd0d5 | 830 | @example |
84f4a531 CY |
831 | Warning: Use `with-current-buffer' rather than |
832 | save-excursion+set-buffer | |
c1bcd0d5 | 833 | @end example |
b8d4c8d0 | 834 | |
c1bcd0d5 CY |
835 | @noindent |
836 | To avoid such problems, you should call @code{save-excursion} only | |
837 | after setting the desired current buffer, as in the following example: | |
b8d4c8d0 GM |
838 | |
839 | @example | |
840 | @group | |
c1bcd0d5 CY |
841 | (defun append-string-to-buffer (string buffer) |
842 | "Append STRING to the end of BUFFER." | |
843 | (with-current-buffer buffer | |
844 | (save-excursion | |
845 | (goto-char (point-max)) | |
846 | (insert string)))) | |
b8d4c8d0 GM |
847 | @end group |
848 | @end example | |
c1bcd0d5 CY |
849 | |
850 | @cindex window excursions | |
851 | Likewise, @code{save-excursion} does not restore window-buffer | |
852 | correspondences altered by functions such as @code{switch-to-buffer}. | |
b8d4c8d0 GM |
853 | |
854 | @strong{Warning:} Ordinary insertion of text adjacent to the saved | |
c1bcd0d5 CY |
855 | point value relocates the saved value, just as it relocates all |
856 | markers. More precisely, the saved value is a marker with insertion | |
857 | type @code{nil}. @xref{Marker Insertion Types}. Therefore, when the | |
858 | saved point value is restored, it normally comes before the inserted | |
859 | text. | |
b8d4c8d0 GM |
860 | |
861 | Although @code{save-excursion} saves the location of the mark, it does | |
862 | not prevent functions which modify the buffer from setting | |
863 | @code{deactivate-mark}, and thus causing the deactivation of the mark | |
864 | after the command finishes. @xref{The Mark}. | |
865 | ||
866 | @node Narrowing | |
867 | @section Narrowing | |
868 | @cindex narrowing | |
869 | @cindex restriction (in a buffer) | |
870 | @cindex accessible portion (of a buffer) | |
871 | ||
872 | @dfn{Narrowing} means limiting the text addressable by Emacs editing | |
873 | commands to a limited range of characters in a buffer. The text that | |
874 | remains addressable is called the @dfn{accessible portion} of the | |
875 | buffer. | |
876 | ||
e5c2edf7 CY |
877 | Narrowing is specified with two buffer positions, which become the |
878 | beginning and end of the accessible portion. For most editing | |
879 | commands and primitives, these positions replace the values of the | |
880 | beginning and end of the buffer. While narrowing is in effect, no | |
881 | text outside the accessible portion is displayed, and point cannot | |
882 | move outside the accessible portion. Note that narrowing does not | |
883 | alter actual buffer positions (@pxref{Point}); it only determines | |
884 | which positions are considered the accessible portion of the buffer. | |
885 | Most functions refuse to operate on text that is outside the | |
886 | accessible portion. | |
887 | ||
888 | Commands for saving buffers are unaffected by narrowing; they save | |
b8d4c8d0 GM |
889 | the entire buffer regardless of any narrowing. |
890 | ||
7f5d317d EZ |
891 | If you need to display in a single buffer several very different |
892 | types of text, consider using an alternative facility described in | |
893 | @ref{Swapping Text}. | |
894 | ||
b8d4c8d0 GM |
895 | @deffn Command narrow-to-region start end |
896 | This function sets the accessible portion of the current buffer to start | |
897 | at @var{start} and end at @var{end}. Both arguments should be character | |
898 | positions. | |
899 | ||
900 | In an interactive call, @var{start} and @var{end} are set to the bounds | |
901 | of the current region (point and the mark, with the smallest first). | |
902 | @end deffn | |
903 | ||
904 | @deffn Command narrow-to-page &optional move-count | |
905 | This function sets the accessible portion of the current buffer to | |
906 | include just the current page. An optional first argument | |
907 | @var{move-count} non-@code{nil} means to move forward or backward by | |
908 | @var{move-count} pages and then narrow to one page. The variable | |
909 | @code{page-delimiter} specifies where pages start and end | |
910 | (@pxref{Standard Regexps}). | |
911 | ||
912 | In an interactive call, @var{move-count} is set to the numeric prefix | |
913 | argument. | |
914 | @end deffn | |
915 | ||
916 | @deffn Command widen | |
917 | @cindex widening | |
918 | This function cancels any narrowing in the current buffer, so that the | |
919 | entire contents are accessible. This is called @dfn{widening}. | |
920 | It is equivalent to the following expression: | |
921 | ||
922 | @example | |
923 | (narrow-to-region 1 (1+ (buffer-size))) | |
924 | @end example | |
925 | @end deffn | |
926 | ||
e5c2edf7 CY |
927 | @defun buffer-narrowed-p |
928 | This function returns non-@code{nil} if the buffer is narrowed, and | |
929 | @code{nil} otherwise. | |
930 | @end defun | |
931 | ||
b8d4c8d0 GM |
932 | @defspec save-restriction body@dots{} |
933 | This special form saves the current bounds of the accessible portion, | |
934 | evaluates the @var{body} forms, and finally restores the saved bounds, | |
935 | thus restoring the same state of narrowing (or absence thereof) formerly | |
936 | in effect. The state of narrowing is restored even in the event of an | |
937 | abnormal exit via @code{throw} or error (@pxref{Nonlocal Exits}). | |
938 | Therefore, this construct is a clean way to narrow a buffer temporarily. | |
939 | ||
940 | The value returned by @code{save-restriction} is that returned by the | |
941 | last form in @var{body}, or @code{nil} if no body forms were given. | |
942 | ||
943 | @c Wordy to avoid overfull hbox. --rjc 16mar92 | |
944 | @strong{Caution:} it is easy to make a mistake when using the | |
945 | @code{save-restriction} construct. Read the entire description here | |
946 | before you try it. | |
947 | ||
948 | If @var{body} changes the current buffer, @code{save-restriction} still | |
949 | restores the restrictions on the original buffer (the buffer whose | |
950 | restrictions it saved from), but it does not restore the identity of the | |
951 | current buffer. | |
952 | ||
953 | @code{save-restriction} does @emph{not} restore point and the mark; use | |
954 | @code{save-excursion} for that. If you use both @code{save-restriction} | |
955 | and @code{save-excursion} together, @code{save-excursion} should come | |
956 | first (on the outside). Otherwise, the old point value would be | |
957 | restored with temporary narrowing still in effect. If the old point | |
958 | value were outside the limits of the temporary narrowing, this would | |
959 | fail to restore it accurately. | |
960 | ||
961 | Here is a simple example of correct use of @code{save-restriction}: | |
962 | ||
963 | @example | |
964 | @group | |
965 | ---------- Buffer: foo ---------- | |
966 | This is the contents of foo | |
967 | This is the contents of foo | |
968 | This is the contents of foo@point{} | |
969 | ---------- Buffer: foo ---------- | |
970 | @end group | |
971 | ||
972 | @group | |
973 | (save-excursion | |
974 | (save-restriction | |
975 | (goto-char 1) | |
976 | (forward-line 2) | |
977 | (narrow-to-region 1 (point)) | |
978 | (goto-char (point-min)) | |
979 | (replace-string "foo" "bar"))) | |
980 | ||
981 | ---------- Buffer: foo ---------- | |
982 | This is the contents of bar | |
983 | This is the contents of bar | |
984 | This is the contents of foo@point{} | |
985 | ---------- Buffer: foo ---------- | |
986 | @end group | |
987 | @end example | |
988 | @end defspec |