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