*** empty log message ***
[emacs.git] / lispref / buffers.texi
blobb82c0df12964d28a866658fb6e214131abd385d5
1 @c -*-texinfo-*-
2 @c This is part of the GNU Emacs Lisp Reference Manual.
3 @c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999
4 @c   Free Software Foundation, Inc. 
5 @c See the file elisp.texi for copying conditions.
6 @setfilename ../info/buffers
7 @node Buffers, Windows, Backups and Auto-Saving, Top
8 @chapter Buffers
9 @cindex buffer
11   A @dfn{buffer} is a Lisp object containing text to be edited.  Buffers
12 are used to hold the contents of files that are being visited; there may
13 also be buffers that are not visiting files.  While several buffers may
14 exist at one time, only one buffer is designated the @dfn{current
15 buffer} at any time.  Most editing commands act on the contents of the
16 current buffer.  Each buffer, including the current buffer, may or may
17 not be displayed in any windows.
19 @menu
20 * Buffer Basics::       What is a buffer?
21 * Current Buffer::      Designating a buffer as current
22                           so that primitives will access its contents.
23 * Buffer Names::        Accessing and changing buffer names.
24 * Buffer File Name::    The buffer file name indicates which file is visited.
25 * Buffer Modification:: A buffer is @dfn{modified} if it needs to be saved.
26 * Modification Time::   Determining whether the visited file was changed
27                          ``behind Emacs's back''.
28 * Read Only Buffers::   Modifying text is not allowed in a read-only buffer.
29 * The Buffer List::     How to look at all the existing buffers.
30 * Creating Buffers::    Functions that create buffers.
31 * Killing Buffers::     Buffers exist until explicitly killed.
32 * Indirect Buffers::    An indirect buffer shares text with some other buffer.
33 * Buffer Gap::          The gap in the buffer.
34 @end menu
36 @node Buffer Basics
37 @comment  node-name,  next,  previous,  up
38 @section Buffer Basics
40 @ifnottex
41   A @dfn{buffer} is a Lisp object containing text to be edited.  Buffers
42 are used to hold the contents of files that are being visited; there may
43 also be buffers that are not visiting files.  Although several buffers
44 normally exist, only one buffer is designated the @dfn{current
45 buffer} at any time.  Most editing commands act on the contents of the
46 current buffer.  Each buffer, including the current buffer, may or may
47 not be displayed in any windows.
48 @end ifnottex
50   Buffers in Emacs editing are objects that have distinct names and hold
51 text that can be edited.  Buffers appear to Lisp programs as a special
52 data type.  You can think of the contents of a buffer as a string that
53 you can extend; insertions and deletions may occur in any part of the
54 buffer.  @xref{Text}.
56   A Lisp buffer object contains numerous pieces of information.  Some of
57 this information is directly accessible to the programmer through
58 variables, while other information is accessible only through
59 special-purpose functions.  For example, the visited file name is
60 directly accessible through a variable, while the value of point is
61 accessible only through a primitive function.
63   Buffer-specific information that is directly accessible is stored in
64 @dfn{buffer-local} variable bindings, which are variable values that are
65 effective only in a particular buffer.  This feature allows each buffer
66 to override the values of certain variables.  Most major modes override
67 variables such as @code{fill-column} or @code{comment-column} in this
68 way.  For more information about buffer-local variables and functions
69 related to them, see @ref{Buffer-Local Variables}.
71   For functions and variables related to visiting files in buffers, see
72 @ref{Visiting Files} and @ref{Saving Buffers}.  For functions and
73 variables related to the display of buffers in windows, see
74 @ref{Buffers and Windows}.
76 @defun bufferp object
77 This function returns @code{t} if @var{object} is a buffer,
78 @code{nil} otherwise.
79 @end defun
81 @node Current Buffer
82 @section The Current Buffer
83 @cindex selecting a buffer
84 @cindex changing to another buffer
85 @cindex current buffer
87   There are, in general, many buffers in an Emacs session.  At any time,
88 one of them is designated as the @dfn{current buffer}.  This is the
89 buffer in which most editing takes place, because most of the primitives
90 for examining or changing text in a buffer operate implicitly on the
91 current buffer (@pxref{Text}).  Normally the buffer that is displayed on
92 the screen in the selected window is the current buffer, but this is not
93 always so: a Lisp program can temporarily designate any buffer as
94 current in order to operate on its contents, without changing what is
95 displayed on the screen.
97   The way to designate a current buffer in a Lisp program is by calling
98 @code{set-buffer}.  The specified buffer remains current until a new one
99 is designated.
101   When an editing command returns to the editor command loop, the
102 command loop designates the buffer displayed in the selected window as
103 current, to prevent confusion: the buffer that the cursor is in when
104 Emacs reads a command is the buffer that the command will apply to.
105 (@xref{Command Loop}.)  Therefore, @code{set-buffer} is not the way to
106 switch visibly to a different buffer so that the user can edit it.  For
107 that, you must use the functions described in @ref{Displaying Buffers}.
109   @strong{Note:} Lisp functions that change to a different current buffer
110 should not depend on the command loop to set it back afterwards.
111 Editing commands written in Emacs Lisp can be called from other programs
112 as well as from the command loop; it is convenient for the caller if
113 the subroutine does not change which buffer is current (unless, of
114 course, that is the subroutine's purpose).  Therefore, you should
115 normally use @code{set-buffer} within a @code{save-current-buffer} or
116 @code{save-excursion} (@pxref{Excursions}) form that will restore the
117 current buffer when your function is done.  Here is an example, the
118 code for the command @code{append-to-buffer} (with the documentation
119 string abridged):
121 @example
122 @group
123 (defun append-to-buffer (buffer start end)
124   "Append to specified buffer the text of the region.
125 @dots{}"
126   (interactive "BAppend to buffer: \nr")
127   (let ((oldbuf (current-buffer)))
128     (save-current-buffer
129       (set-buffer (get-buffer-create buffer))
130       (insert-buffer-substring oldbuf start end))))
131 @end group
132 @end example
134 @noindent
135 This function binds a local variable to record the current buffer, and
136 then @code{save-current-buffer} arranges to make it current again.
137 Next, @code{set-buffer} makes the specified buffer current.  Finally,
138 @code{insert-buffer-substring} copies the string from the original
139 current buffer to the specified (and now current) buffer.
141   If the buffer appended to happens to be displayed in some window, 
142 the next redisplay will show how its text has changed.  Otherwise, you
143 will not see the change immediately on the screen.  The buffer becomes
144 current temporarily during the execution of the command, but this does
145 not cause it to be displayed.
147   If you make local bindings (with @code{let} or function arguments) for
148 a variable that may also have buffer-local bindings, make sure that the
149 same buffer is current at the beginning and at the end of the local
150 binding's scope.  Otherwise you might bind it in one buffer and unbind
151 it in another!  There are two ways to do this.  In simple cases, you may
152 see that nothing ever changes the current buffer within the scope of the
153 binding.  Otherwise, use @code{save-current-buffer} or
154 @code{save-excursion} to make sure that the buffer current at the
155 beginning is current again whenever the variable is unbound.
157   Do not rely on using @code{set-buffer} to change the current buffer
158 back, because that won't do the job if a quit happens while the wrong
159 buffer is current.  Here is what @emph{not} to do:
161 @example
162 @group
163 (let (buffer-read-only
164       (obuf (current-buffer)))
165   (set-buffer @dots{})
166   @dots{}
167   (set-buffer obuf))
168 @end group
169 @end example
171 @noindent
172 Using @code{save-current-buffer}, as shown here, handles quitting,
173 errors, and @code{throw}, as well as ordinary evaluation.
175 @example
176 @group
177 (let (buffer-read-only)
178   (save-current-buffer
179     (set-buffer @dots{})
180     @dots{}))
181 @end group
182 @end example
184 @defun current-buffer
185 This function returns the current buffer.
187 @example
188 @group
189 (current-buffer)
190      @result{} #<buffer buffers.texi>
191 @end group
192 @end example
193 @end defun
195 @defun set-buffer buffer-or-name
196 This function makes @var{buffer-or-name} the current buffer.  This does
197 not display the buffer in any window, so the user cannot necessarily see
198 the buffer.  But Lisp programs will now operate on it.
200 This function returns the buffer identified by @var{buffer-or-name}.
201 An error is signaled if @var{buffer-or-name} does not identify an
202 existing buffer.
203 @end defun
205 @defspec save-current-buffer body...
206 The @code{save-current-buffer} macro saves the identity of the current
207 buffer, evaluates the @var{body} forms, and finally restores that buffer
208 as current.  The return value is the value of the last form in
209 @var{body}.  The current buffer is restored even in case of an abnormal
210 exit via @code{throw} or error (@pxref{Nonlocal Exits}).
212 If the buffer that used to be current has been killed by the time of
213 exit from @code{save-current-buffer}, then it is not made current again,
214 of course.  Instead, whichever buffer was current just before exit
215 remains current.
216 @end defspec
218 @defmac with-current-buffer buffer body...
219 The @code{with-current-buffer} macro saves the identity of the current
220 buffer, makes @var{buffer} current, evaluates the @var{body} forms, and
221 finally restores the buffer.  The return value is the value of the last
222 form in @var{body}.  The current buffer is restored even in case of an
223 abnormal exit via @code{throw} or error (@pxref{Nonlocal Exits}).
224 @end defmac
226 @defmac with-temp-buffer body...
227 The @code{with-temp-buffer} macro evaluates the @var{body} forms
228 with a temporary buffer as the current buffer.  It saves the identity of
229 the current buffer, creates a temporary buffer and makes it current,
230 evaluates the @var{body} forms, and finally restores the previous
231 current buffer while killing the temporary buffer.
233 The return value is the value of the last form in @var{body}.  You can
234 return the contents of the temporary buffer by using
235 @code{(buffer-string)} as the last form.
237 The current buffer is restored even in case of an abnormal exit via
238 @code{throw} or error (@pxref{Nonlocal Exits}).
239 @end defmac
241 See also @code{with-temp-file} in @ref{Writing to Files}.
243 @node Buffer Names
244 @section Buffer Names
245 @cindex buffer names
247   Each buffer has a unique name, which is a string.  Many of the
248 functions that work on buffers accept either a buffer or a buffer name
249 as an argument.  Any argument called @var{buffer-or-name} is of this
250 sort, and an error is signaled if it is neither a string nor a buffer.
251 Any argument called @var{buffer} must be an actual buffer
252 object, not a name.
254   Buffers that are ephemeral and generally uninteresting to the user
255 have names starting with a space, so that the @code{list-buffers} and
256 @code{buffer-menu} commands don't mention them.  A name starting with
257 space also initially disables recording undo information; see
258 @ref{Undo}.
260 @defun buffer-name &optional buffer
261 This function returns the name of @var{buffer} as a string.  If
262 @var{buffer} is not supplied, it defaults to the current buffer.
264 If @code{buffer-name} returns @code{nil}, it means that @var{buffer}
265 has been killed.  @xref{Killing Buffers}.
267 @example
268 @group
269 (buffer-name)
270      @result{} "buffers.texi"
271 @end group
273 @group
274 (setq foo (get-buffer "temp"))
275      @result{} #<buffer temp>
276 @end group
277 @group
278 (kill-buffer foo)
279      @result{} nil
280 @end group
281 @group
282 (buffer-name foo)
283      @result{} nil
284 @end group
285 @group
287      @result{} #<killed buffer>
288 @end group
289 @end example
290 @end defun
292 @deffn Command rename-buffer newname &optional unique
293 This function renames the current buffer to @var{newname}.  An error
294 is signaled if @var{newname} is not a string, or if there is already a
295 buffer with that name.  The function returns @var{newname}.
297 @c Emacs 19 feature
298 Ordinarily, @code{rename-buffer} signals an error if @var{newname} is
299 already in use.  However, if @var{unique} is non-@code{nil}, it modifies
300 @var{newname} to make a name that is not in use.  Interactively, you can
301 make @var{unique} non-@code{nil} with a numeric prefix argument.
302 (This is how the command @code{rename-uniquely} is implemented.)
303 @end deffn
305 @defun get-buffer buffer-or-name
306 This function returns the buffer specified by @var{buffer-or-name}.
307 If @var{buffer-or-name} is a string and there is no buffer with that
308 name, the value is @code{nil}.  If @var{buffer-or-name} is a buffer, it
309 is returned as given; that is not very useful, so the argument is usually 
310 a name.  For example:
312 @example
313 @group
314 (setq b (get-buffer "lewis"))
315      @result{} #<buffer lewis>
316 @end group
317 @group
318 (get-buffer b)
319      @result{} #<buffer lewis>
320 @end group
321 @group
322 (get-buffer "Frazzle-nots")
323      @result{} nil
324 @end group
325 @end example
327 See also the function @code{get-buffer-create} in @ref{Creating Buffers}.
328 @end defun
330 @c Emacs 19 feature
331 @defun generate-new-buffer-name starting-name &rest ignore
332 This function returns a name that would be unique for a new buffer---but
333 does not create the buffer.  It starts with @var{starting-name}, and
334 produces a name not currently in use for any buffer by appending a
335 number inside of @samp{<@dots{}>}.
337 If the optional second argument @var{ignore} is non-@code{nil}, it
338 should be a string; it makes a difference if it is a name in the
339 sequence of names to be tried.  That name will be considered acceptable,
340 if it is tried, even if a buffer with that name exists.  Thus, if
341 buffers named @samp{foo}, @samp{foo<2>}, @samp{foo<3>} and @samp{foo<4>}
342 exist,
344 @example
345 (generate-new-buffer-name "foo")
346      @result{} "foo<5>"
347 (generate-new-buffer-name "foo" "foo<3>")
348      @result{} "foo<3>"
349 (generate-new-buffer-name "foo" "foo<6>")
350      @result{} "foo<5>"
351 @end example
353 See the related function @code{generate-new-buffer} in @ref{Creating
354 Buffers}.
355 @end defun
357 @node Buffer File Name
358 @section Buffer File Name
359 @cindex visited file
360 @cindex buffer file name
361 @cindex file name of buffer
363   The @dfn{buffer file name} is the name of the file that is visited in
364 that buffer.  When a buffer is not visiting a file, its buffer file name
365 is @code{nil}.  Most of the time, the buffer name is the same as the
366 nondirectory part of the buffer file name, but the buffer file name and
367 the buffer name are distinct and can be set independently.
368 @xref{Visiting Files}.
370 @defun buffer-file-name &optional buffer
371 This function returns the absolute file name of the file that
372 @var{buffer} is visiting.  If @var{buffer} is not visiting any file,
373 @code{buffer-file-name} returns @code{nil}.  If @var{buffer} is not
374 supplied, it defaults to the current buffer.
376 @example
377 @group
378 (buffer-file-name (other-buffer))
379      @result{} "/usr/user/lewis/manual/files.texi"
380 @end group
381 @end example
382 @end defun
384 @defvar buffer-file-name
385 This buffer-local variable contains the name of the file being visited
386 in the current buffer, or @code{nil} if it is not visiting a file.  It
387 is a permanent local variable, unaffected by
388 @code{kill-all-local-variables}.
390 @example
391 @group
392 buffer-file-name
393      @result{} "/usr/user/lewis/manual/buffers.texi"
394 @end group
395 @end example
397 It is risky to change this variable's value without doing various other
398 things.  Normally it is better to use @code{set-visited-file-name} (see
399 below); some of the things done there, such as changing the buffer name,
400 are not strictly necessary, but others are essential to avoid confusing
401 Emacs.
402 @end defvar
404 @defvar buffer-file-truename
405 This buffer-local variable holds the truename of the file visited in the
406 current buffer, or @code{nil} if no file is visited.  It is a permanent
407 local, unaffected by @code{kill-all-local-variables}.  @xref{Truenames}.
408 @end defvar
410 @defvar buffer-file-number
411 This buffer-local variable holds the file number and directory device
412 number of the file visited in the current buffer, or @code{nil} if no
413 file or a nonexistent file is visited.  It is a permanent local,
414 unaffected by @code{kill-all-local-variables}.
416 The value is normally a list of the form @code{(@var{filenum}
417 @var{devnum})}.  This pair of numbers uniquely identifies the file among
418 all files accessible on the system.  See the function
419 @code{file-attributes}, in @ref{File Attributes}, for more information
420 about them.
421 @end defvar
423 @defun get-file-buffer filename
424 This function returns the buffer visiting file @var{filename}.  If
425 there is no such buffer, it returns @code{nil}.  The argument
426 @var{filename}, which must be a string, is expanded (@pxref{File Name
427 Expansion}), then compared against the visited file names of all live
428 buffers.
430 @example
431 @group
432 (get-file-buffer "buffers.texi")
433     @result{} #<buffer buffers.texi>
434 @end group
435 @end example
437 In unusual circumstances, there can be more than one buffer visiting
438 the same file name.  In such cases, this function returns the first
439 such buffer in the buffer list.
440 @end defun
442 @deffn Command set-visited-file-name filename &optional no-query along-with-file
443 If @var{filename} is a non-empty string, this function changes the
444 name of the file visited in the current buffer to @var{filename}.  (If the
445 buffer had no visited file, this gives it one.)  The @emph{next time}
446 the buffer is saved it will go in the newly-specified file.  This
447 command marks the buffer as modified, since it does not (as far as Emacs
448 knows) match the contents of @var{filename}, even if it matched the
449 former visited file.
451 If @var{filename} is @code{nil} or the empty string, that stands for
452 ``no visited file''.  In this case, @code{set-visited-file-name} marks
453 the buffer as having no visited file.
455 Normally, this function asks the user for confirmation if the specified
456 file already exists.  If @var{no-query} is non-@code{nil}, that prevents
457 asking this question.
459 If @var{along-with-file} is non-@code{nil}, that means to assume that the
460 former visited file has been renamed to @var{filename}.
462 @c Wordy to avoid overfull hbox.  --rjc 16mar92
463 When the function @code{set-visited-file-name} is called interactively, it
464 prompts for @var{filename} in the minibuffer.
465 @end deffn
467 @defvar list-buffers-directory
468 This buffer-local variable specifies a string to display in a buffer
469 listing where the visited file name would go, for buffers that don't
470 have a visited file name.  Dired buffers use this variable.
471 @end defvar
473 @node Buffer Modification
474 @section Buffer Modification
475 @cindex buffer modification
476 @cindex modification flag (of buffer)
478   Emacs keeps a flag called the @dfn{modified flag} for each buffer, to
479 record whether you have changed the text of the buffer.  This flag is
480 set to @code{t} whenever you alter the contents of the buffer, and
481 cleared to @code{nil} when you save it.  Thus, the flag shows whether
482 there are unsaved changes.  The flag value is normally shown in the mode
483 line (@pxref{Mode Line Variables}), and controls saving (@pxref{Saving
484 Buffers}) and auto-saving (@pxref{Auto-Saving}).
486   Some Lisp programs set the flag explicitly.  For example, the function
487 @code{set-visited-file-name} sets the flag to @code{t}, because the text
488 does not match the newly-visited file, even if it is unchanged from the
489 file formerly visited.
491   The functions that modify the contents of buffers are described in
492 @ref{Text}.
494 @defun buffer-modified-p &optional buffer
495 This function returns @code{t} if the buffer @var{buffer} has been modified
496 since it was last read in from a file or saved, or @code{nil}
497 otherwise.  If @var{buffer} is not supplied, the current buffer
498 is tested.
499 @end defun
501 @defun set-buffer-modified-p flag
502 This function marks the current buffer as modified if @var{flag} is
503 non-@code{nil}, or as unmodified if the flag is @code{nil}.
505 Another effect of calling this function is to cause unconditional
506 redisplay of the mode line for the current buffer.  In fact, the
507 function @code{force-mode-line-update} works by doing this:
509 @example
510 @group
511 (set-buffer-modified-p (buffer-modified-p))
512 @end group
513 @end example
514 @end defun
516 @deffn Command not-modified
517 This command marks the current buffer as unmodified, and not needing to
518 be saved.  With prefix arg, it marks the buffer as modified, so that it
519 will be saved at the next suitable occasion.
521 Don't use this function in programs, since it prints a message in the
522 echo area; use @code{set-buffer-modified-p} (above) instead.
523 @end deffn
525 @c Emacs 19 feature
526 @defun buffer-modified-tick &optional buffer
527 This function returns @var{buffer}'s modification-count.  This is a
528 counter that increments every time the buffer is modified.  If
529 @var{buffer} is @code{nil} (or omitted), the current buffer is used.
530 @end defun
532 @node Modification Time
533 @comment  node-name,  next,  previous,  up
534 @section Comparison of Modification Time
535 @cindex comparison of modification time
536 @cindex modification time, comparison of 
538   Suppose that you visit a file and make changes in its buffer, and
539 meanwhile the file itself is changed on disk.  At this point, saving the
540 buffer would overwrite the changes in the file.  Occasionally this may
541 be what you want, but usually it would lose valuable information.  Emacs
542 therefore checks the file's modification time using the functions
543 described below before saving the file.
545 @defun verify-visited-file-modtime buffer
546 This function compares what @var{buffer} has recorded for the
547 modification time of its visited file against the actual modification
548 time of the file as recorded by the operating system.  The two should be
549 the same unless some other process has written the file since Emacs
550 visited or saved it.
552 The function returns @code{t} if the last actual modification time and
553 Emacs's recorded modification time are the same, @code{nil} otherwise.
554 @end defun
556 @defun clear-visited-file-modtime
557 This function clears out the record of the last modification time of
558 the file being visited by the current buffer.  As a result, the next
559 attempt to save this buffer will not complain of a discrepancy in
560 file modification times.
562 This function is called in @code{set-visited-file-name} and other
563 exceptional places where the usual test to avoid overwriting a changed
564 file should not be done.
565 @end defun
567 @c Emacs 19 feature
568 @defun visited-file-modtime
569 This function returns the buffer's recorded last file modification time,
570 as a list of the form @code{(@var{high} . @var{low})}.  (This is the
571 same format that @code{file-attributes} uses to return time values; see
572 @ref{File Attributes}.)
573 @end defun
575 @c Emacs 19 feature
576 @defun set-visited-file-modtime &optional time
577 This function updates the buffer's record of the last modification time
578 of the visited file, to the value specified by @var{time} if @var{time}
579 is not @code{nil}, and otherwise to the last modification time of the
580 visited file.
582 If @var{time} is not @code{nil}, it should have the form
583 @code{(@var{high} . @var{low})} or @code{(@var{high} @var{low})}, in
584 either case containing two integers, each of which holds 16 bits of the
585 time.
587 This function is useful if the buffer was not read from the file
588 normally, or if the file itself has been changed for some known benign
589 reason.
590 @end defun
592 @defun ask-user-about-supersession-threat filename
593 @cindex obsolete buffer
594 This function is used to ask a user how to proceed after an attempt to
595 modify an obsolete buffer visiting file @var{filename}.  An
596 @dfn{obsolete buffer} is an unmodified buffer for which the associated
597 file on disk is newer than the last save-time of the buffer.  This means
598 some other program has probably altered the file.
600 @kindex file-supersession
601 Depending on the user's answer, the function may return normally, in
602 which case the modification of the buffer proceeds, or it may signal a
603 @code{file-supersession} error with data @code{(@var{filename})}, in which
604 case the proposed buffer modification is not allowed.  
606 This function is called automatically by Emacs on the proper
607 occasions.  It exists so you can customize Emacs by redefining it.
608 See the file @file{userlock.el} for the standard definition.
610 See also the file locking mechanism in @ref{File Locks}.
611 @end defun
613 @node Read Only Buffers
614 @section Read-Only Buffers
615 @cindex read-only buffer
616 @cindex buffer, read-only
618   If a buffer is @dfn{read-only}, then you cannot change its contents,
619 although you may change your view of the contents by scrolling and 
620 narrowing.
622   Read-only buffers are used in two kinds of situations:
624 @itemize @bullet
625 @item
626 A buffer visiting a write-protected file is normally read-only.
628 Here, the purpose is to inform the user that editing the buffer with the
629 aim of saving it in the file may be futile or undesirable.  The user who
630 wants to change the buffer text despite this can do so after clearing
631 the read-only flag with @kbd{C-x C-q}.
633 @item
634 Modes such as Dired and Rmail make buffers read-only when altering the
635 contents with the usual editing commands would probably be a mistake.
637 The special commands of these modes bind @code{buffer-read-only} to
638 @code{nil} (with @code{let}) or bind @code{inhibit-read-only} to
639 @code{t} around the places where they themselves change the text.
640 @end itemize
642 @defvar buffer-read-only
643 This buffer-local variable specifies whether the buffer is read-only.
644 The buffer is read-only if this variable is non-@code{nil}.
645 @end defvar
647 @defvar inhibit-read-only
648 If this variable is non-@code{nil}, then read-only buffers and read-only
649 characters may be modified.  Read-only characters in a buffer are those
650 that have non-@code{nil} @code{read-only} properties (either text
651 properties or overlay properties).  @xref{Special Properties}, for more
652 information about text properties.  @xref{Overlays}, for more
653 information about overlays and their properties.
655 If @code{inhibit-read-only} is @code{t}, all @code{read-only} character
656 properties have no effect.  If @code{inhibit-read-only} is a list, then
657 @code{read-only} character properties have no effect if they are members
658 of the list (comparison is done with @code{eq}).
659 @end defvar
661 @deffn Command toggle-read-only
662 This command changes whether the current buffer is read-only.  It is
663 intended for interactive use; do not use it in programs.  At any given
664 point in a program, you should know whether you want the read-only flag
665 on or off; so you can set @code{buffer-read-only} explicitly to the
666 proper value, @code{t} or @code{nil}.
667 @end deffn
669 @defun barf-if-buffer-read-only
670 This function signals a @code{buffer-read-only} error if the current
671 buffer is read-only.  @xref{Interactive Call}, for another way to
672 signal an error if the current buffer is read-only.
673 @end defun
675 @node The Buffer List
676 @section The Buffer List
677 @cindex buffer list
679   The @dfn{buffer list} is a list of all live buffers.  Creating a
680 buffer adds it to this list, and killing a buffer excises it.  The order
681 of the buffers in the list is based primarily on how recently each
682 buffer has been displayed in the selected window.  Buffers move to the
683 front of the list when they are selected and to the end when they are
684 buried (see @code{bury-buffer}, below).  Several functions, notably
685 @code{other-buffer}, use this ordering.  A buffer list displayed for the
686 user also follows this order.
688   In addition to the fundamental Emacs buffer list, each frame has its
689 own version of the buffer list, in which the buffers that have been
690 selected in that frame come first, starting with the buffers most
691 recently selected @emph{in that frame}.  (This order is recorded in
692 @var{frame}'s @code{buffer-list} frame parameter; see @ref{Window Frame
693 Parameters}.)  The buffers that were never selected in @var{frame} come
694 afterward, ordered according to the fundamental Emacs buffer list.
696 @defun buffer-list &optional frame
697 This function returns the buffer list, including all buffers, even those
698 whose names begin with a space.  The elements are actual buffers, not
699 their names.
701 If @var{frame} is a frame, this returns @var{frame}'s buffer list.  If
702 @var{frame} is @code{nil}, the fundamental Emacs buffer list is used:
703 all the buffers appear in order of most recent selection, regardless of
704 which frames they were selected in.
706 @example
707 @group
708 (buffer-list)
709      @result{} (#<buffer buffers.texi>
710          #<buffer  *Minibuf-1*> #<buffer buffer.c>
711          #<buffer *Help*> #<buffer TAGS>)
712 @end group
714 @group
715 ;; @r{Note that the name of the minibuffer}
716 ;;   @r{begins with a space!}
717 (mapcar (function buffer-name) (buffer-list))
718     @result{} ("buffers.texi" " *Minibuf-1*" 
719         "buffer.c" "*Help*" "TAGS")
720 @end group
721 @end example
722 @end defun
724   The list that @code{buffer-list} returns is constructed specifically
725 by @code{buffer-list}; it is not an internal Emacs data structure, and
726 modifying it has no effect on the order of buffers.  If you want to
727 change the order of buffers in the frame-independent buffer list, here
728 is an easy way:
730 @example
731 (defun reorder-buffer-list (new-list)
732   (while new-list
733     (bury-buffer (car new-list))
734     (setq new-list (cdr new-list))))
735 @end example
737   With this method, you can specify any order for the list, but there is
738 no danger of losing a buffer or adding something that is not a valid
739 live buffer.
741   To change the order or value of a frame's buffer list, set the frame's
742 @code{buffer-list} frame parameter with @code{modify-frame-parameters}
743 (@pxref{Parameter Access}).
745 @defun other-buffer &optional buffer visible-ok frame
746 This function returns the first buffer in the buffer list other than
747 @var{buffer}.  Usually this is the buffer selected most recently (in
748 frame @var{frame} or else the currently selected frame), aside from
749 @var{buffer}.  Buffers whose names start with a space are not considered
750 at all.
752 If @var{buffer} is not supplied (or if it is not a buffer), then
753 @code{other-buffer} returns the first buffer in the selected frame's
754 buffer list that is not now visible in any window in a visible frame.
756 If @var{frame} has a non-@code{nil} @code{buffer-predicate} parameter,
757 then @code{other-buffer} uses that predicate to decide which buffers to
758 consider.  It calls the predicate once for each buffer, and if the value
759 is @code{nil}, that buffer is ignored.  @xref{Window Frame Parameters}.
761 @c Emacs 19 feature
762 If @var{visible-ok} is @code{nil}, @code{other-buffer} avoids returning
763 a buffer visible in any window on any visible frame, except as a last
764 resort.   If @var{visible-ok} is non-@code{nil}, then it does not matter
765 whether a buffer is displayed somewhere or not.
767 If no suitable buffer exists, the buffer @samp{*scratch*} is returned
768 (and created, if necessary).
769 @end defun
771 @deffn Command bury-buffer &optional buffer-or-name
772 This function puts @var{buffer-or-name} at the end of the buffer list,
773 without changing the order of any of the other buffers on the list.
774 This buffer therefore becomes the least desirable candidate for
775 @code{other-buffer} to return.
777 @code{bury-buffer} operates on each frame's @code{buffer-list} parameter
778 as well as the frame-independent Emacs buffer list; therefore, the
779 buffer that you bury will come last in the value of @code{(buffer-list
780 @var{frame})} and in the value of @code{(buffer-list nil)}.
782 If @var{buffer-or-name} is @code{nil} or omitted, this means to bury the
783 current buffer.  In addition, if the buffer is displayed in the selected
784 window, this switches to some other buffer (obtained using
785 @code{other-buffer}) in the selected window.  But if the buffer is
786 displayed in some other window, it remains displayed there.
788 To replace a buffer in all the windows that display it, use
789 @code{replace-buffer-in-windows}.  @xref{Buffers and Windows}.
790 @end deffn
792 @node Creating Buffers
793 @section Creating Buffers
794 @cindex creating buffers
795 @cindex buffers, creating
797   This section describes the two primitives for creating buffers.
798 @code{get-buffer-create} creates a buffer if it finds no existing buffer
799 with the specified name; @code{generate-new-buffer} always creates a new
800 buffer and gives it a unique name.
802   Other functions you can use to create buffers include
803 @code{with-output-to-temp-buffer} (@pxref{Temporary Displays}) and
804 @code{create-file-buffer} (@pxref{Visiting Files}).  Starting a
805 subprocess can also create a buffer (@pxref{Processes}).
807 @defun get-buffer-create name
808 This function returns a buffer named @var{name}.  It returns an existing
809 buffer with that name, if one exists; otherwise, it creates a new
810 buffer.  The buffer does not become the current buffer---this function
811 does not change which buffer is current.
813 An error is signaled if @var{name} is not a string.
815 @example
816 @group
817 (get-buffer-create "foo")
818      @result{} #<buffer foo>
819 @end group
820 @end example
822 The major mode for the new buffer is set to Fundamental mode.  The
823 variable @code{default-major-mode} is handled at a higher level.
824 @xref{Auto Major Mode}.
825 @end defun
827 @defun generate-new-buffer name
828 This function returns a newly created, empty buffer, but does not make
829 it current.  If there is no buffer named @var{name}, then that is the
830 name of the new buffer.  If that name is in use, this function adds
831 suffixes of the form @samp{<@var{n}>} to @var{name}, where @var{n} is an
832 integer.  It tries successive integers starting with 2 until it finds an
833 available name.
835 An error is signaled if @var{name} is not a string.
837 @example
838 @group
839 (generate-new-buffer "bar")
840      @result{} #<buffer bar>
841 @end group
842 @group
843 (generate-new-buffer "bar")
844      @result{} #<buffer bar<2>>
845 @end group
846 @group
847 (generate-new-buffer "bar")
848      @result{} #<buffer bar<3>>
849 @end group
850 @end example
852 The major mode for the new buffer is set to Fundamental mode.  The
853 variable @code{default-major-mode} is handled at a higher level.
854 @xref{Auto Major Mode}.
856 See the related function @code{generate-new-buffer-name} in @ref{Buffer
857 Names}.
858 @end defun
860 @node Killing Buffers
861 @section Killing Buffers
862 @cindex killing buffers
863 @cindex buffers, killing
865   @dfn{Killing a buffer} makes its name unknown to Emacs and makes its
866 text space available for other use.
868   The buffer object for the buffer that has been killed remains in
869 existence as long as anything refers to it, but it is specially marked
870 so that you cannot make it current or display it.  Killed buffers retain
871 their identity, however; if you kill two distinct buffers, they remain
872 distinct according to @code{eq} although both are dead.
874   If you kill a buffer that is current or displayed in a window, Emacs
875 automatically selects or displays some other buffer instead.  This means
876 that killing a buffer can in general change the current buffer.
877 Therefore, when you kill a buffer, you should also take the precautions
878 associated with changing the current buffer (unless you happen to know
879 that the buffer being killed isn't current).  @xref{Current Buffer}.
881   If you kill a buffer that is the base buffer of one or more indirect
882 buffers, the indirect buffers are automatically killed as well.
884   The @code{buffer-name} of a killed buffer is @code{nil}.  You can use
885 this feature to test whether a buffer has been killed:
887 @example
888 @group
889 (defun buffer-killed-p (buffer)
890   "Return t if BUFFER is killed."
891   (not (buffer-name buffer)))
892 @end group
893 @end example
895 @deffn Command kill-buffer buffer-or-name
896 This function kills the buffer @var{buffer-or-name}, freeing all its
897 memory for other uses or to be returned to the operating system.  It
898 returns @code{nil}.
900 Any processes that have this buffer as the @code{process-buffer} are
901 sent the @code{SIGHUP} signal, which normally causes them to terminate.
902 (The basic meaning of @code{SIGHUP} is that a dialup line has been
903 disconnected.)  @xref{Deleting Processes}.
905 If the buffer is visiting a file and contains unsaved changes,
906 @code{kill-buffer} asks the user to confirm before the buffer is killed.
907 It does this even if not called interactively.  To prevent the request
908 for confirmation, clear the modified flag before calling
909 @code{kill-buffer}.  @xref{Buffer Modification}.
911 Killing a buffer that is already dead has no effect.
913 @smallexample
914 (kill-buffer "foo.unchanged")
915      @result{} nil
916 (kill-buffer "foo.changed")
918 ---------- Buffer: Minibuffer ----------
919 Buffer foo.changed modified; kill anyway? (yes or no) @kbd{yes}
920 ---------- Buffer: Minibuffer ----------
922      @result{} nil
923 @end smallexample
924 @end deffn
926 @defvar kill-buffer-query-functions
927 After confirming unsaved changes, @code{kill-buffer} calls the functions
928 in the list @code{kill-buffer-query-functions}, in order of appearance,
929 with no arguments.  The buffer being killed is the current buffer when
930 they are called.  The idea of this feature is that these functions will
931 ask for confirmation from the user.  If any of them returns @code{nil},
932 @code{kill-buffer} spares the buffer's life.
933 @end defvar
935 @defvar kill-buffer-hook
936 This is a normal hook run by @code{kill-buffer} after asking all the
937 questions it is going to ask, just before actually killing the buffer.
938 The buffer to be killed is current when the hook functions run.
939 @xref{Hooks}.
940 @end defvar
942 @defvar buffer-offer-save
943 This variable, if non-@code{nil} in a particular buffer, tells
944 @code{save-buffers-kill-emacs} and @code{save-some-buffers} to offer to
945 save that buffer, just as they offer to save file-visiting buffers.  The
946 variable @code{buffer-offer-save} automatically becomes buffer-local
947 when set for any reason.  @xref{Buffer-Local Variables}.
948 @end defvar
950 @node Indirect Buffers
951 @section Indirect Buffers
952 @cindex indirect buffers
953 @cindex base buffer
955   An @dfn{indirect buffer} shares the text of some other buffer, which
956 is called the @dfn{base buffer} of the indirect buffer.  In some ways it
957 is the analogue, for buffers, of a symbolic link among files.  The base
958 buffer may not itself be an indirect buffer.
960   The text of the indirect buffer is always identical to the text of its
961 base buffer; changes made by editing either one are visible immediately
962 in the other.  This includes the text properties as well as the characters
963 themselves.
965   In all other respects, the indirect buffer and its base buffer are
966 completely separate.  They have different names, different values of
967 point, different narrowing, different markers and overlays (though
968 inserting or deleting text in either buffer relocates the markers and
969 overlays for both), different major modes, and different buffer-local
970 variables.
972   An indirect buffer cannot visit a file, but its base buffer can.  If
973 you try to save the indirect buffer, that actually saves the base
974 buffer.
976   Killing an indirect buffer has no effect on its base buffer.  Killing
977 the base buffer effectively kills the indirect buffer in that it cannot
978 ever again be the current buffer.
980 @deffn Command make-indirect-buffer base-buffer name
981 This creates an indirect buffer named @var{name} whose base buffer
982 is @var{base-buffer}.  The argument @var{base-buffer} may be a buffer
983 or a string.
985 If @var{base-buffer} is an indirect buffer, its base buffer is used as
986 the base for the new buffer.
987 @end deffn
989 @defun buffer-base-buffer buffer
990 This function returns the base buffer of @var{buffer}.  If @var{buffer}
991 is not indirect, the value is @code{nil}.  Otherwise, the value is
992 another buffer, which is never an indirect buffer.
993 @end defun
995 @node Buffer Gap
996 @section The Buffer Gap
998   Emacs buffers are implemented using an invisible @dfn{gap} to make
999 insertion and deletion faster.  Insertion works by filling in part of
1000 the gap, and deletion adds to the gap.  Of course, this means that the
1001 gap must first be moved to the locus of the insertion or deletion.
1002 Emacs moves the gap only when you try to insert or delete.  This is why
1003 your first editing command in one part of a large buffer, after
1004 previously editing in another far-away part, sometimes involves a
1005 noticeable delay.
1007   This mechanism works invisibly, and Lisp code should never be affected
1008 by the gap's current location, but these functions are available for
1009 getting information about the gap status.
1011 @defun gap-position
1012 This function returns the current gap position in the current buffer.
1013 @end defun
1015 @defun gap-size
1016 This function returns the current gap size of the current buffer.
1017 @end defun