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