2 @c This is part of the GNU Emacs Lisp Reference Manual.
3 @c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998 Free Software Foundation, Inc.
4 @c See the file elisp.texi for copying conditions.
5 @setfilename ../info/buffers
6 @node Buffers, Windows, Backups and Auto-Saving, Top
10 A @dfn{buffer} is a Lisp object containing text to be edited. Buffers
11 are used to hold the contents of files that are being visited; there may
12 also be buffers that are not visiting files. While several buffers may
13 exist at one time, only one buffer is designated the @dfn{current
14 buffer} at any time. Most editing commands act on the contents of the
15 current buffer. Each buffer, including the current buffer, may or may
16 not be displayed in any windows.
19 * Buffer Basics:: What is a buffer?
20 * Current Buffer:: Designating a buffer as current
21 so that primitives will access its contents.
22 * Buffer Names:: Accessing and changing buffer names.
23 * Buffer File Name:: The buffer file name indicates which file is visited.
24 * Buffer Modification:: A buffer is @dfn{modified} if it needs to be saved.
25 * Modification Time:: Determining whether the visited file was changed
26 ``behind Emacs's back''.
27 * Read Only Buffers:: Modifying text is not allowed in a read-only buffer.
28 * The Buffer List:: How to look at all the existing buffers.
29 * Creating Buffers:: Functions that create buffers.
30 * Killing Buffers:: Buffers exist until explicitly killed.
31 * Indirect Buffers:: An indirect buffer shares text with some other buffer.
32 * Buffer Gap:: The gap in the buffer.
36 @comment node-name, next, previous, up
37 @section Buffer Basics
40 A @dfn{buffer} is a Lisp object containing text to be edited. Buffers
41 are used to hold the contents of files that are being visited; there may
42 also be buffers that are not visiting files. Although several buffers
43 normally exist, only one buffer is designated the @dfn{current
44 buffer} at any time. Most editing commands act on the contents of the
45 current buffer. Each buffer, including the current buffer, may or may
46 not be displayed in any windows.
49 Buffers in Emacs editing are objects that have distinct names and hold
50 text that can be edited. Buffers appear to Lisp programs as a special
51 data type. You can think of the contents of a buffer as a string that
52 you can extend; insertions and deletions may occur in any part of the
55 A Lisp buffer object contains numerous pieces of information. Some of
56 this information is directly accessible to the programmer through
57 variables, while other information is accessible only through
58 special-purpose functions. For example, the visited file name is
59 directly accessible through a variable, while the value of point is
60 accessible only through a primitive function.
62 Buffer-specific information that is directly accessible is stored in
63 @dfn{buffer-local} variable bindings, which are variable values that are
64 effective only in a particular buffer. This feature allows each buffer
65 to override the values of certain variables. Most major modes override
66 variables such as @code{fill-column} or @code{comment-column} in this
67 way. For more information about buffer-local variables and functions
68 related to them, see @ref{Buffer-Local Variables}.
70 For functions and variables related to visiting files in buffers, see
71 @ref{Visiting Files} and @ref{Saving Buffers}. For functions and
72 variables related to the display of buffers in windows, see
73 @ref{Buffers and Windows}.
76 This function returns @code{t} if @var{object} is a buffer,
81 @section The Current Buffer
82 @cindex selecting a buffer
83 @cindex changing to another buffer
84 @cindex current buffer
86 There are, in general, many buffers in an Emacs session. At any time,
87 one of them is designated as the @dfn{current buffer}. This is the
88 buffer in which most editing takes place, because most of the primitives
89 for examining or changing text in a buffer operate implicitly on the
90 current buffer (@pxref{Text}). Normally the buffer that is displayed on
91 the screen in the selected window is the current buffer, but this is not
92 always so: a Lisp program can temporarily designate any buffer as
93 current in order to operate on its contents, without changing what is
94 displayed on the screen.
96 The way to designate a current buffer in a Lisp program is by calling
97 @code{set-buffer}. The specified buffer remains current until a new one
100 When an editing command returns to the editor command loop, the
101 command loop designates the buffer displayed in the selected window as
102 current, to prevent confusion: the buffer that the cursor is in when
103 Emacs reads a command is the buffer that the command will apply to.
104 (@xref{Command Loop}.) Therefore, @code{set-buffer} is not the way to
105 switch visibly to a different buffer so that the user can edit it. For
106 that, you must use the functions described in @ref{Displaying Buffers}.
108 @strong{Note:} Lisp functions that change to a different current buffer
109 should not depend on the command loop to set it back afterwards.
110 Editing commands written in Emacs Lisp can be called from other programs
111 as well as from the command loop; it is convenient for the caller if
112 the subroutine does not change which buffer is current (unless, of
113 course, that is the subroutine's purpose). Therefore, you should
114 normally use @code{set-buffer} within a @code{save-current-buffer} or
115 @code{save-excursion} (@pxref{Excursions}) form that will restore the
116 current buffer when your function is done. Here is an example, the
117 code for the command @code{append-to-buffer} (with the documentation
122 (defun append-to-buffer (buffer start end)
123 "Append to specified buffer the text of the region.
125 (interactive "BAppend to buffer: \nr")
126 (let ((oldbuf (current-buffer)))
128 (set-buffer (get-buffer-create buffer))
129 (insert-buffer-substring oldbuf start end))))
134 This function binds a local variable to record the current buffer, and
135 then @code{save-current-buffer} arranges to make it current again.
136 Next, @code{set-buffer} makes the specified buffer current. Finally,
137 @code{insert-buffer-substring} copies the string from the original
138 current buffer to the specified (and now current) buffer.
140 If the buffer appended to happens to be displayed in some window,
141 the next redisplay will show how its text has changed. Otherwise, you
142 will not see the change immediately on the screen. The buffer becomes
143 current temporarily during the execution of the command, but this does
144 not cause it to be displayed.
146 If you make local bindings (with @code{let} or function arguments) for
147 a variable that may also have buffer-local bindings, make sure that the
148 same buffer is current at the beginning and at the end of the local
149 binding's scope. Otherwise you might bind it in one buffer and unbind
150 it in another! There are two ways to do this. In simple cases, you may
151 see that nothing ever changes the current buffer within the scope of the
152 binding. Otherwise, use @code{save-current-buffer} or
153 @code{save-excursion} to make sure that the buffer current at the
154 beginning is current again whenever the variable is unbound.
156 Do not rely on using @code{set-buffer} to change the current buffer
157 back, because that won't do the job if a quit happens while the wrong
158 buffer is current. Here is what @emph{not} to do:
162 (let (buffer-read-only
163 (obuf (current-buffer)))
171 Using @code{save-current-buffer}, as shown here, handles quitting,
172 errors, and @code{throw}, as well as ordinary evaluation.
176 (let (buffer-read-only)
183 @defun current-buffer
184 This function returns the current buffer.
189 @result{} #<buffer buffers.texi>
194 @defun set-buffer buffer-or-name
195 This function makes @var{buffer-or-name} the current buffer. This does
196 not display the buffer in any window, so the user cannot necessarily see
197 the buffer. But Lisp programs will now operate on it.
199 This function returns the buffer identified by @var{buffer-or-name}.
200 An error is signaled if @var{buffer-or-name} does not identify an
204 @defspec save-current-buffer body...
205 @tindex save-current-buffer
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
218 @defmac with-current-buffer buffer body...
219 @tindex with-current-buffer
220 The @code{with-current-buffer} macro saves the identity of the current
221 buffer, makes @var{buffer} current, evaluates the @var{body} forms, and
222 finally restores the buffer. The return value is the value of the last
223 form in @var{body}. The current buffer is restored even in case of an
224 abnormal exit via @code{throw} or error (@pxref{Nonlocal Exits}).
227 @defmac with-temp-buffer body...
228 @tindex with-temp-buffer
229 The @code{with-temp-buffer} macro evaluates the @var{body} forms
230 with a temporary buffer as the current buffer. It saves the identity of
231 the current buffer, creates a temporary buffer and makes it current,
232 evaluates the @var{body} forms, and finally restores the previous
233 current buffer while killing the temporary buffer.
235 The return value is the value of the last form in @var{body}. You can
236 return the contents of the temporary buffer by using
237 @code{(buffer-string)} as the last form.
239 The current buffer is restored even in case of an abnormal exit via
240 @code{throw} or error (@pxref{Nonlocal Exits}).
243 See also @code{with-temp-file} in @ref{Writing to Files}.
246 @section Buffer Names
249 Each buffer has a unique name, which is a string. Many of the
250 functions that work on buffers accept either a buffer or a buffer name
251 as an argument. Any argument called @var{buffer-or-name} is of this
252 sort, and an error is signaled if it is neither a string nor a buffer.
253 Any argument called @var{buffer} must be an actual buffer
256 Buffers that are ephemeral and generally uninteresting to the user
257 have names starting with a space, so that the @code{list-buffers} and
258 @code{buffer-menu} commands don't mention them. A name starting with
259 space also initially disables recording undo information; see
262 @defun buffer-name &optional buffer
263 This function returns the name of @var{buffer} as a string. If
264 @var{buffer} is not supplied, it defaults to the current buffer.
266 If @code{buffer-name} returns @code{nil}, it means that @var{buffer}
267 has been killed. @xref{Killing Buffers}.
272 @result{} "buffers.texi"
276 (setq foo (get-buffer "temp"))
277 @result{} #<buffer temp>
289 @result{} #<killed buffer>
294 @deffn Command rename-buffer newname &optional unique
295 This function renames the current buffer to @var{newname}. An error
296 is signaled if @var{newname} is not a string, or if there is already a
297 buffer with that name. The function returns @var{newname}.
300 Ordinarily, @code{rename-buffer} signals an error if @var{newname} is
301 already in use. However, if @var{unique} is non-@code{nil}, it modifies
302 @var{newname} to make a name that is not in use. Interactively, you can
303 make @var{unique} non-@code{nil} with a numeric prefix argument.
304 (This is how the command @code{rename-uniquely} is implemented.)
307 @defun get-buffer buffer-or-name
308 This function returns the buffer specified by @var{buffer-or-name}.
309 If @var{buffer-or-name} is a string and there is no buffer with that
310 name, the value is @code{nil}. If @var{buffer-or-name} is a buffer, it
311 is returned as given; that is not very useful, so the argument is usually
316 (setq b (get-buffer "lewis"))
317 @result{} #<buffer lewis>
321 @result{} #<buffer lewis>
324 (get-buffer "Frazzle-nots")
329 See also the function @code{get-buffer-create} in @ref{Creating Buffers}.
333 @defun generate-new-buffer-name starting-name &rest ignore
334 This function returns a name that would be unique for a new buffer---but
335 does not create the buffer. It starts with @var{starting-name}, and
336 produces a name not currently in use for any buffer by appending a
337 number inside of @samp{<@dots{}>}.
339 If the optional second argument @var{ignore} is non-@code{nil}, it
340 should be buffer name in the sequence to be tried. That name will be
341 considered acceptable, if it is tried, even if a buffer with that name
344 See the related function @code{generate-new-buffer} in @ref{Creating
348 @node Buffer File Name
349 @section Buffer File Name
351 @cindex buffer file name
352 @cindex file name of buffer
354 The @dfn{buffer file name} is the name of the file that is visited in
355 that buffer. When a buffer is not visiting a file, its buffer file name
356 is @code{nil}. Most of the time, the buffer name is the same as the
357 nondirectory part of the buffer file name, but the buffer file name and
358 the buffer name are distinct and can be set independently.
359 @xref{Visiting Files}.
361 @defun buffer-file-name &optional buffer
362 This function returns the absolute file name of the file that
363 @var{buffer} is visiting. If @var{buffer} is not visiting any file,
364 @code{buffer-file-name} returns @code{nil}. If @var{buffer} is not
365 supplied, it defaults to the current buffer.
369 (buffer-file-name (other-buffer))
370 @result{} "/usr/user/lewis/manual/files.texi"
375 @defvar buffer-file-name
376 This buffer-local variable contains the name of the file being visited
377 in the current buffer, or @code{nil} if it is not visiting a file. It
378 is a permanent local variable, unaffected by
379 @code{kill-all-local-variables}.
384 @result{} "/usr/user/lewis/manual/buffers.texi"
388 It is risky to change this variable's value without doing various other
389 things. Normally it is better to use @code{set-visited-file-name} (see
390 below); some of the things done there, such as changing the buffer name,
391 are not strictly necessary, but others are essential to avoid confusing
395 @defvar buffer-file-truename
396 This buffer-local variable holds the truename of the file visited in the
397 current buffer, or @code{nil} if no file is visited. It is a permanent
398 local, unaffected by @code{kill-all-local-variables}. @xref{Truenames}.
401 @defvar buffer-file-number
402 This buffer-local variable holds the file number and directory device
403 number of the file visited in the current buffer, or @code{nil} if no
404 file or a nonexistent file is visited. It is a permanent local,
405 unaffected by @code{kill-all-local-variables}.
407 The value is normally a list of the form @code{(@var{filenum}
408 @var{devnum})}. This pair of numbers uniquely identifies the file among
409 all files accessible on the system. See the function
410 @code{file-attributes}, in @ref{File Attributes}, for more information
414 @defun get-file-buffer filename
415 This function returns the buffer visiting file @var{filename}. If
416 there is no such buffer, it returns @code{nil}. The argument
417 @var{filename}, which must be a string, is expanded (@pxref{File Name
418 Expansion}), then compared against the visited file names of all live
423 (get-file-buffer "buffers.texi")
424 @result{} #<buffer buffers.texi>
428 In unusual circumstances, there can be more than one buffer visiting
429 the same file name. In such cases, this function returns the first
430 such buffer in the buffer list.
433 @deffn Command set-visited-file-name filename &optional no-query along-with-file
434 If @var{filename} is a non-empty string, this function changes the
435 name of the file visited in the current buffer to @var{filename}. (If the
436 buffer had no visited file, this gives it one.) The @emph{next time}
437 the buffer is saved it will go in the newly-specified file. This
438 command marks the buffer as modified, since it does not (as far as Emacs
439 knows) match the contents of @var{filename}, even if it matched the
442 If @var{filename} is @code{nil} or the empty string, that stands for
443 ``no visited file''. In this case, @code{set-visited-file-name} marks
444 the buffer as having no visited file.
446 Normally, this function asks the user for confirmation if the specified
447 file already exists. If @var{no-query} is non-@code{nil}, that prevents
448 asking this question.
450 If @var{along-with-file} is non-@code{nil}, that means to assume that the
451 former visited file has been renamed to @var{filename}.
453 @c Wordy to avoid overfull hbox. --rjc 16mar92
454 When the function @code{set-visited-file-name} is called interactively, it
455 prompts for @var{filename} in the minibuffer.
458 @defvar list-buffers-directory
459 This buffer-local variable specifies a string to display in a buffer
460 listing where the visited file name would go, for buffers that don't
461 have a visited file name. Dired buffers use this variable.
464 @node Buffer Modification
465 @section Buffer Modification
466 @cindex buffer modification
467 @cindex modification flag (of buffer)
469 Emacs keeps a flag called the @dfn{modified flag} for each buffer, to
470 record whether you have changed the text of the buffer. This flag is
471 set to @code{t} whenever you alter the contents of the buffer, and
472 cleared to @code{nil} when you save it. Thus, the flag shows whether
473 there are unsaved changes. The flag value is normally shown in the mode
474 line (@pxref{Mode Line Variables}), and controls saving (@pxref{Saving
475 Buffers}) and auto-saving (@pxref{Auto-Saving}).
477 Some Lisp programs set the flag explicitly. For example, the function
478 @code{set-visited-file-name} sets the flag to @code{t}, because the text
479 does not match the newly-visited file, even if it is unchanged from the
480 file formerly visited.
482 The functions that modify the contents of buffers are described in
485 @defun buffer-modified-p &optional buffer
486 This function returns @code{t} if the buffer @var{buffer} has been modified
487 since it was last read in from a file or saved, or @code{nil}
488 otherwise. If @var{buffer} is not supplied, the current buffer
492 @defun set-buffer-modified-p flag
493 This function marks the current buffer as modified if @var{flag} is
494 non-@code{nil}, or as unmodified if the flag is @code{nil}.
496 Another effect of calling this function is to cause unconditional
497 redisplay of the mode line for the current buffer. In fact, the
498 function @code{force-mode-line-update} works by doing this:
502 (set-buffer-modified-p (buffer-modified-p))
507 @deffn Command not-modified
508 This command marks the current buffer as unmodified, and not needing to
509 be saved. With prefix arg, it marks the buffer as modified, so that it
510 will be saved at the next suitable occasion.
512 Don't use this function in programs, since it prints a message in the
513 echo area; use @code{set-buffer-modified-p} (above) instead.
517 @defun buffer-modified-tick &optional buffer
518 This function returns @var{buffer}'s modification-count. This is a
519 counter that increments every time the buffer is modified. If
520 @var{buffer} is @code{nil} (or omitted), the current buffer is used.
523 @node Modification Time
524 @comment node-name, next, previous, up
525 @section Comparison of Modification Time
526 @cindex comparison of modification time
527 @cindex modification time, comparison of
529 Suppose that you visit a file and make changes in its buffer, and
530 meanwhile the file itself is changed on disk. At this point, saving the
531 buffer would overwrite the changes in the file. Occasionally this may
532 be what you want, but usually it would lose valuable information. Emacs
533 therefore checks the file's modification time using the functions
534 described below before saving the file.
536 @defun verify-visited-file-modtime buffer
537 This function compares what @var{buffer} has recorded for the
538 modification time of its visited file against the actual modification
539 time of the file as recorded by the operating system. The two should be
540 the same unless some other process has written the file since Emacs
543 The function returns @code{t} if the last actual modification time and
544 Emacs's recorded modification time are the same, @code{nil} otherwise.
547 @defun clear-visited-file-modtime
548 This function clears out the record of the last modification time of
549 the file being visited by the current buffer. As a result, the next
550 attempt to save this buffer will not complain of a discrepancy in
551 file modification times.
553 This function is called in @code{set-visited-file-name} and other
554 exceptional places where the usual test to avoid overwriting a changed
555 file should not be done.
559 @defun visited-file-modtime
560 This function returns the buffer's recorded last file modification time,
561 as a list of the form @code{(@var{high} . @var{low})}. (This is the
562 same format that @code{file-attributes} uses to return time values; see
563 @ref{File Attributes}.)
567 @defun set-visited-file-modtime &optional time
568 This function updates the buffer's record of the last modification time
569 of the visited file, to the value specified by @var{time} if @var{time}
570 is not @code{nil}, and otherwise to the last modification time of the
573 If @var{time} is not @code{nil}, it should have the form
574 @code{(@var{high} . @var{low})} or @code{(@var{high} @var{low})}, in
575 either case containing two integers, each of which holds 16 bits of the
578 This function is useful if the buffer was not read from the file
579 normally, or if the file itself has been changed for some known benign
583 @defun ask-user-about-supersession-threat filename
584 @cindex obsolete buffer
585 This function is used to ask a user how to proceed after an attempt to
586 modify an obsolete buffer visiting file @var{filename}. An
587 @dfn{obsolete buffer} is an unmodified buffer for which the associated
588 file on disk is newer than the last save-time of the buffer. This means
589 some other program has probably altered the file.
591 @kindex file-supersession
592 Depending on the user's answer, the function may return normally, in
593 which case the modification of the buffer proceeds, or it may signal a
594 @code{file-supersession} error with data @code{(@var{filename})}, in which
595 case the proposed buffer modification is not allowed.
597 This function is called automatically by Emacs on the proper
598 occasions. It exists so you can customize Emacs by redefining it.
599 See the file @file{userlock.el} for the standard definition.
601 See also the file locking mechanism in @ref{File Locks}.
604 @node Read Only Buffers
605 @section Read-Only Buffers
606 @cindex read-only buffer
607 @cindex buffer, read-only
609 If a buffer is @dfn{read-only}, then you cannot change its contents,
610 although you may change your view of the contents by scrolling and
613 Read-only buffers are used in two kinds of situations:
617 A buffer visiting a write-protected file is normally read-only.
619 Here, the purpose is to inform the user that editing the buffer with the
620 aim of saving it in the file may be futile or undesirable. The user who
621 wants to change the buffer text despite this can do so after clearing
622 the read-only flag with @kbd{C-x C-q}.
625 Modes such as Dired and Rmail make buffers read-only when altering the
626 contents with the usual editing commands would probably be a mistake.
628 The special commands of these modes bind @code{buffer-read-only} to
629 @code{nil} (with @code{let}) or bind @code{inhibit-read-only} to
630 @code{t} around the places where they themselves change the text.
633 @defvar buffer-read-only
634 This buffer-local variable specifies whether the buffer is read-only.
635 The buffer is read-only if this variable is non-@code{nil}.
638 @defvar inhibit-read-only
639 If this variable is non-@code{nil}, then read-only buffers and read-only
640 characters may be modified. Read-only characters in a buffer are those
641 that have non-@code{nil} @code{read-only} properties (either text
642 properties or overlay properties). @xref{Special Properties}, for more
643 information about text properties. @xref{Overlays}, for more
644 information about overlays and their properties.
646 If @code{inhibit-read-only} is @code{t}, all @code{read-only} character
647 properties have no effect. If @code{inhibit-read-only} is a list, then
648 @code{read-only} character properties have no effect if they are members
649 of the list (comparison is done with @code{eq}).
652 @deffn Command toggle-read-only
653 This command changes whether the current buffer is read-only. It is
654 intended for interactive use; do not use it in programs. At any given
655 point in a program, you should know whether you want the read-only flag
656 on or off; so you can set @code{buffer-read-only} explicitly to the
657 proper value, @code{t} or @code{nil}.
660 @defun barf-if-buffer-read-only
661 This function signals a @code{buffer-read-only} error if the current
662 buffer is read-only. @xref{Interactive Call}, for another way to
663 signal an error if the current buffer is read-only.
666 @node The Buffer List
667 @section The Buffer List
670 The @dfn{buffer list} is a list of all live buffers. Creating a
671 buffer adds it to this list, and killing a buffer excises it. The order
672 of the buffers in the list is based primarily on how recently each
673 buffer has been displayed in the selected window. Buffers move to the
674 front of the list when they are selected and to the end when they are
675 buried (see @code{bury-buffer}, below). Several functions, notably
676 @code{other-buffer}, use this ordering. A buffer list displayed for the
677 user also follows this order.
679 In addition to the fundamental Emacs buffer list, each frame has its
680 own version of the buffer list, in which the buffers that have been
681 selected in that frame come first, starting with the buffers most
682 recently selected @emph{in that frame}. (This order is recorded in
683 @var{frame}'s @code{buffer-list} frame parameter; see @ref{Window Frame
684 Parameters}.) The buffers that were never selected in @var{frame} come
685 afterward, ordered according to the fundamental Emacs buffer list.
687 @defun buffer-list &optional frame
688 This function returns the buffer list, including all buffers, even those
689 whose names begin with a space. The elements are actual buffers, not
692 If @var{frame} is a frame, this returns @var{frame}'s buffer list. If
693 @var{frame} is @code{nil}, the fundamental Emacs buffer list is used:
694 all the buffers appear in order of most recent selection, regardless of
695 which frames they were selected in.
700 @result{} (#<buffer buffers.texi>
701 #<buffer *Minibuf-1*> #<buffer buffer.c>
702 #<buffer *Help*> #<buffer TAGS>)
706 ;; @r{Note that the name of the minibuffer}
707 ;; @r{begins with a space!}
708 (mapcar (function buffer-name) (buffer-list))
709 @result{} ("buffers.texi" " *Minibuf-1*"
710 "buffer.c" "*Help*" "TAGS")
715 The list that @code{buffer-list} returns is constructed specifically
716 by @code{buffer-list}; it is not an internal Emacs data structure, and
717 modifying it has no effect on the order of buffers. If you want to
718 change the order of buffers in the frame-independent buffer list, here
722 (defun reorder-buffer-list (new-list)
724 (bury-buffer (car new-list))
725 (setq new-list (cdr new-list))))
728 With this method, you can specify any order for the list, but there is
729 no danger of losing a buffer or adding something that is not a valid
732 To change the order or value of a frame's buffer list, set the frame's
733 @code{buffer-list} frame parameter with @code{modify-frame-parameters}
734 (@pxref{Parameter Access}).
736 @defun other-buffer &optional buffer visible-ok frame
737 This function returns the first buffer in the buffer list other than
738 @var{buffer}. Usually this is the buffer selected most recently (in
739 frame @var{frame} or else the currently selected frame), aside from
740 @var{buffer}. Buffers whose names start with a space are not considered
743 If @var{buffer} is not supplied (or if it is not a buffer), then
744 @code{other-buffer} returns the first buffer in the selected frame's
745 buffer list that is not now visible in any window in a visible frame.
747 If @var{frame} has a non-@code{nil} @code{buffer-predicate} parameter,
748 then @code{other-buffer} uses that predicate to decide which buffers to
749 consider. It calls the predicate once for each buffer, and if the value
750 is @code{nil}, that buffer is ignored. @xref{Window Frame Parameters}.
753 If @var{visible-ok} is @code{nil}, @code{other-buffer} avoids returning
754 a buffer visible in any window on any visible frame, except as a last
755 resort. If @var{visible-ok} is non-@code{nil}, then it does not matter
756 whether a buffer is displayed somewhere or not.
758 If no suitable buffer exists, the buffer @samp{*scratch*} is returned
759 (and created, if necessary).
762 @deffn Command bury-buffer &optional buffer-or-name
763 This function puts @var{buffer-or-name} at the end of the buffer list,
764 without changing the order of any of the other buffers on the list.
765 This buffer therefore becomes the least desirable candidate for
766 @code{other-buffer} to return.
768 @code{bury-buffer} operates on each frame's @code{buffer-list} parameter
769 as well as the frame-independent Emacs buffer list; therefore, the
770 buffer that you bury will come last in the value of @code{(buffer-list
771 @var{frame})} and in the value of @code{(buffer-list nil)}.
773 If @var{buffer-or-name} is @code{nil} or omitted, this means to bury the
774 current buffer. In addition, if the buffer is displayed in the selected
775 window, this switches to some other buffer (obtained using
776 @code{other-buffer}) in the selected window. But if the buffer is
777 displayed in some other window, it remains displayed there.
779 To replace a buffer in all the windows that display it, use
780 @code{replace-buffer-in-windows}. @xref{Buffers and Windows}.
783 @node Creating Buffers
784 @section Creating Buffers
785 @cindex creating buffers
786 @cindex buffers, creating
788 This section describes the two primitives for creating buffers.
789 @code{get-buffer-create} creates a buffer if it finds no existing buffer
790 with the specified name; @code{generate-new-buffer} always creates a new
791 buffer and gives it a unique name.
793 Other functions you can use to create buffers include
794 @code{with-output-to-temp-buffer} (@pxref{Temporary Displays}) and
795 @code{create-file-buffer} (@pxref{Visiting Files}). Starting a
796 subprocess can also create a buffer (@pxref{Processes}).
798 @defun get-buffer-create name
799 This function returns a buffer named @var{name}. It returns an existing
800 buffer with that name, if one exists; otherwise, it creates a new
801 buffer. The buffer does not become the current buffer---this function
802 does not change which buffer is current.
804 An error is signaled if @var{name} is not a string.
808 (get-buffer-create "foo")
809 @result{} #<buffer foo>
813 The major mode for the new buffer is set to Fundamental mode. The
814 variable @code{default-major-mode} is handled at a higher level.
815 @xref{Auto Major Mode}.
818 @defun generate-new-buffer name
819 This function returns a newly created, empty buffer, but does not make
820 it current. If there is no buffer named @var{name}, then that is the
821 name of the new buffer. If that name is in use, this function adds
822 suffixes of the form @samp{<@var{n}>} to @var{name}, where @var{n} is an
823 integer. It tries successive integers starting with 2 until it finds an
826 An error is signaled if @var{name} is not a string.
830 (generate-new-buffer "bar")
831 @result{} #<buffer bar>
834 (generate-new-buffer "bar")
835 @result{} #<buffer bar<2>>
838 (generate-new-buffer "bar")
839 @result{} #<buffer bar<3>>
843 The major mode for the new buffer is set to Fundamental mode. The
844 variable @code{default-major-mode} is handled at a higher level.
845 @xref{Auto Major Mode}.
847 See the related function @code{generate-new-buffer-name} in @ref{Buffer
851 @node Killing Buffers
852 @section Killing Buffers
853 @cindex killing buffers
854 @cindex buffers, killing
856 @dfn{Killing a buffer} makes its name unknown to Emacs and makes its
857 text space available for other use.
859 The buffer object for the buffer that has been killed remains in
860 existence as long as anything refers to it, but it is specially marked
861 so that you cannot make it current or display it. Killed buffers retain
862 their identity, however; if you kill two distinct buffers, they remain
863 distinct according to @code{eq} although both are dead.
865 If you kill a buffer that is current or displayed in a window, Emacs
866 automatically selects or displays some other buffer instead. This means
867 that killing a buffer can in general change the current buffer.
868 Therefore, when you kill a buffer, you should also take the precautions
869 associated with changing the current buffer (unless you happen to know
870 that the buffer being killed isn't current). @xref{Current Buffer}.
872 If you kill a buffer that is the base buffer of one or more indirect
873 buffers, the indirect buffers are automatically killed as well.
875 The @code{buffer-name} of a killed buffer is @code{nil}. You can use
876 this feature to test whether a buffer has been killed:
880 (defun buffer-killed-p (buffer)
881 "Return t if BUFFER is killed."
882 (not (buffer-name buffer)))
886 @deffn Command kill-buffer buffer-or-name
887 This function kills the buffer @var{buffer-or-name}, freeing all its
888 memory for other uses or to be returned to the operating system. It
891 Any processes that have this buffer as the @code{process-buffer} are
892 sent the @code{SIGHUP} signal, which normally causes them to terminate.
893 (The basic meaning of @code{SIGHUP} is that a dialup line has been
894 disconnected.) @xref{Deleting Processes}.
896 If the buffer is visiting a file and contains unsaved changes,
897 @code{kill-buffer} asks the user to confirm before the buffer is killed.
898 It does this even if not called interactively. To prevent the request
899 for confirmation, clear the modified flag before calling
900 @code{kill-buffer}. @xref{Buffer Modification}.
902 Killing a buffer that is already dead has no effect.
905 (kill-buffer "foo.unchanged")
907 (kill-buffer "foo.changed")
909 ---------- Buffer: Minibuffer ----------
910 Buffer foo.changed modified; kill anyway? (yes or no) @kbd{yes}
911 ---------- Buffer: Minibuffer ----------
917 @defvar kill-buffer-query-functions
918 After confirming unsaved changes, @code{kill-buffer} calls the functions
919 in the list @code{kill-buffer-query-functions}, in order of appearance,
920 with no arguments. The buffer being killed is the current buffer when
921 they are called. The idea of this feature is that these functions will
922 ask for confirmation from the user. If any of them returns @code{nil},
923 @code{kill-buffer} spares the buffer's life.
926 @defvar kill-buffer-hook
927 This is a normal hook run by @code{kill-buffer} after asking all the
928 questions it is going to ask, just before actually killing the buffer.
929 The buffer to be killed is current when the hook functions run.
933 @defvar buffer-offer-save
934 This variable, if non-@code{nil} in a particular buffer, tells
935 @code{save-buffers-kill-emacs} and @code{save-some-buffers} to offer to
936 save that buffer, just as they offer to save file-visiting buffers. The
937 variable @code{buffer-offer-save} automatically becomes buffer-local
938 when set for any reason. @xref{Buffer-Local Variables}.
941 @node Indirect Buffers
942 @section Indirect Buffers
943 @cindex indirect buffers
946 An @dfn{indirect buffer} shares the text of some other buffer, which
947 is called the @dfn{base buffer} of the indirect buffer. In some ways it
948 is the analogue, for buffers, of a symbolic link among files. The base
949 buffer may not itself be an indirect buffer.
951 The text of the indirect buffer is always identical to the text of its
952 base buffer; changes made by editing either one are visible immediately
953 in the other. This includes the text properties as well as the characters
956 In all other respects, the indirect buffer and its base buffer are
957 completely separate. They have different names, different values of
958 point, different narrowing, different markers and overlays (though
959 inserting or deleting text in either buffer relocates the markers and
960 overlays for both), different major modes, and different buffer-local
963 An indirect buffer cannot visit a file, but its base buffer can. If
964 you try to save the indirect buffer, that actually saves the base
967 Killing an indirect buffer has no effect on its base buffer. Killing
968 the base buffer effectively kills the indirect buffer in that it cannot
969 ever again be the current buffer.
971 @deffn Command make-indirect-buffer base-buffer name
972 This creates an indirect buffer named @var{name} whose base buffer
973 is @var{base-buffer}. The argument @var{base-buffer} may be a buffer
976 If @var{base-buffer} is an indirect buffer, its base buffer is used as
977 the base for the new buffer.
980 @defun buffer-base-buffer buffer
981 This function returns the base buffer of @var{buffer}. If @var{buffer}
982 is not indirect, the value is @code{nil}. Otherwise, the value is
983 another buffer, which is never an indirect buffer.
987 @section The Buffer Gap
989 Emacs buffers are implemented using an invisible @dfn{gap} to make
990 insertion and deletion faster. Insertion works by filling in part of
991 the gap, and deletion adds to the gap. Of course, this means that the
992 gap must first be moved to the locus of the insertion or deletion.
993 Emacs moves the gap only when you try to insert or delete. This is why
994 your first editing command in one part of a large buffer, after
995 previously editing in another far-away part, sometimes involves a
998 This mechanism works invisibly, and Lisp code should never be affected
999 by the gap's current location, but these functions are available for
1000 getting information about the gap status.
1003 This function returns the current gap position in the current buffer.
1007 This function returns the current gap size of the current buffer.