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