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