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
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.
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.
37 @comment node-name, next, previous, up
38 @section Buffer Basics
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.
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
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}.
77 This function returns @code{t} if @var{object} is a 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
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{Warning:} 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
123 (defun append-to-buffer (buffer start end)
124 "Append to specified buffer the text of the region.
126 (interactive "BAppend to buffer: \nr")
127 (let ((oldbuf (current-buffer)))
129 (set-buffer (get-buffer-create buffer))
130 (insert-buffer-substring oldbuf start end))))
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:
163 (let (buffer-read-only
164 (obuf (current-buffer)))
172 Using @code{save-current-buffer}, as shown here, handles quitting,
173 errors, and @code{throw}, as well as ordinary evaluation.
177 (let (buffer-read-only)
184 @defun current-buffer
185 This function returns the current buffer.
190 @result{} #<buffer buffers.texi>
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
205 @defspec save-current-buffer body...
206 The @code{save-current-buffer} special form saves the identity of the
207 current buffer, evaluates the @var{body} forms, and finally restores
208 that buffer as current. The return value is the value of the last
209 form in @var{body}. The current buffer is restored even in case of an
210 abnormal 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 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}).
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}).
241 See also @code{with-temp-file} in @ref{Writing to Files}.
244 @section 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
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 (but if such a buffer
257 visits a file, it @strong{is} mentioned). A name starting with
258 space also initially disables recording undo information; see
261 @defun buffer-name &optional buffer
262 This function returns the name of @var{buffer} as a string. If
263 @var{buffer} is not supplied, it defaults to the current buffer.
265 If @code{buffer-name} returns @code{nil}, it means that @var{buffer}
266 has been killed. @xref{Killing Buffers}.
271 @result{} "buffers.texi"
275 (setq foo (get-buffer "temp"))
276 @result{} #<buffer temp>
288 @result{} #<killed buffer>
293 @deffn Command rename-buffer newname &optional unique
294 This function renames the current buffer to @var{newname}. An error
295 is signaled if @var{newname} is not a string, or if there is already a
296 buffer with that name. The function returns @var{newname}.
299 Ordinarily, @code{rename-buffer} signals an error if @var{newname} is
300 already in use. However, if @var{unique} is non-@code{nil}, it modifies
301 @var{newname} to make a name that is not in use. Interactively, you can
302 make @var{unique} non-@code{nil} with a numeric prefix argument.
303 (This is how the command @code{rename-uniquely} is implemented.)
306 @defun get-buffer buffer-or-name
307 This function returns the buffer specified by @var{buffer-or-name}.
308 If @var{buffer-or-name} is a string and there is no buffer with that
309 name, the value is @code{nil}. If @var{buffer-or-name} is a buffer, it
310 is returned as given; that is not very useful, so the argument is usually
315 (setq b (get-buffer "lewis"))
316 @result{} #<buffer lewis>
320 @result{} #<buffer lewis>
323 (get-buffer "Frazzle-nots")
328 See also the function @code{get-buffer-create} in @ref{Creating Buffers}.
332 @defun generate-new-buffer-name starting-name &rest ignore
333 This function returns a name that would be unique for a new buffer---but
334 does not create the buffer. It starts with @var{starting-name}, and
335 produces a name not currently in use for any buffer by appending a
336 number inside of @samp{<@dots{}>}.
338 If the optional second argument @var{ignore} is non-@code{nil}, it
339 should be a string; it makes a difference if it is a name in the
340 sequence of names to be tried. That name will be considered acceptable,
341 if it is tried, even if a buffer with that name exists. Thus, if
342 buffers named @samp{foo}, @samp{foo<2>}, @samp{foo<3>} and @samp{foo<4>}
346 (generate-new-buffer-name "foo")
348 (generate-new-buffer-name "foo" "foo<3>")
350 (generate-new-buffer-name "foo" "foo<6>")
354 See the related function @code{generate-new-buffer} in @ref{Creating
358 @node Buffer File Name
359 @section Buffer File Name
361 @cindex buffer file name
362 @cindex file name of buffer
364 The @dfn{buffer file name} is the name of the file that is visited in
365 that buffer. When a buffer is not visiting a file, its buffer file name
366 is @code{nil}. Most of the time, the buffer name is the same as the
367 nondirectory part of the buffer file name, but the buffer file name and
368 the buffer name are distinct and can be set independently.
369 @xref{Visiting Files}.
371 @defun buffer-file-name &optional buffer
372 This function returns the absolute file name of the file that
373 @var{buffer} is visiting. If @var{buffer} is not visiting any file,
374 @code{buffer-file-name} returns @code{nil}. If @var{buffer} is not
375 supplied, it defaults to the current buffer.
379 (buffer-file-name (other-buffer))
380 @result{} "/usr/user/lewis/manual/files.texi"
385 @defvar buffer-file-name
386 This buffer-local variable contains the name of the file being visited
387 in the current buffer, or @code{nil} if it is not visiting a file. It
388 is a permanent local variable, unaffected by
389 @code{kill-all-local-variables}.
394 @result{} "/usr/user/lewis/manual/buffers.texi"
398 It is risky to change this variable's value without doing various other
399 things. Normally it is better to use @code{set-visited-file-name} (see
400 below); some of the things done there, such as changing the buffer name,
401 are not strictly necessary, but others are essential to avoid confusing
405 @defvar buffer-file-truename
406 This buffer-local variable holds the truename of the file visited in the
407 current buffer, or @code{nil} if no file is visited. It is a permanent
408 local, unaffected by @code{kill-all-local-variables}. @xref{Truenames}.
411 @defvar buffer-file-number
412 This buffer-local variable holds the file number and directory device
413 number of the file visited in the current buffer, or @code{nil} if no
414 file or a nonexistent file is visited. It is a permanent local,
415 unaffected by @code{kill-all-local-variables}.
417 The value is normally a list of the form @code{(@var{filenum}
418 @var{devnum})}. This pair of numbers uniquely identifies the file among
419 all files accessible on the system. See the function
420 @code{file-attributes}, in @ref{File Attributes}, for more information
424 @defun get-file-buffer filename
425 This function returns the buffer visiting file @var{filename}. If
426 there is no such buffer, it returns @code{nil}. The argument
427 @var{filename}, which must be a string, is expanded (@pxref{File Name
428 Expansion}), then compared against the visited file names of all live
433 (get-file-buffer "buffers.texi")
434 @result{} #<buffer buffers.texi>
438 In unusual circumstances, there can be more than one buffer visiting
439 the same file name. In such cases, this function returns the first
440 such buffer in the buffer list.
443 @deffn Command set-visited-file-name filename &optional no-query along-with-file
444 If @var{filename} is a non-empty string, this function changes the
445 name of the file visited in the current buffer to @var{filename}. (If the
446 buffer had no visited file, this gives it one.) The @emph{next time}
447 the buffer is saved it will go in the newly-specified file.
449 This command marks the buffer as modified, since it does not (as far
450 as Emacs knows) match the contents of @var{filename}, even if it
451 matched the former visited file. It also renames the buffer to
452 correspond to the new file name, unless the new name is already in
455 If @var{filename} is @code{nil} or the empty string, that stands for
456 ``no visited file''. In this case, @code{set-visited-file-name} marks
457 the buffer as having no visited file.
459 Normally, this function asks the user for confirmation if the specified
460 file already exists. If @var{no-query} is non-@code{nil}, that prevents
461 asking this question.
463 If @var{along-with-file} is non-@code{nil}, that means to assume that the
464 former visited file has been renamed to @var{filename}.
466 @c Wordy to avoid overfull hbox. --rjc 16mar92
467 When the function @code{set-visited-file-name} is called interactively, it
468 prompts for @var{filename} in the minibuffer.
471 @defvar list-buffers-directory
472 This buffer-local variable specifies a string to display in a buffer
473 listing where the visited file name would go, for buffers that don't
474 have a visited file name. Dired buffers use this variable.
477 @node Buffer Modification
478 @section Buffer Modification
479 @cindex buffer modification
480 @cindex modification flag (of buffer)
482 Emacs keeps a flag called the @dfn{modified flag} for each buffer, to
483 record whether you have changed the text of the buffer. This flag is
484 set to @code{t} whenever you alter the contents of the buffer, and
485 cleared to @code{nil} when you save it. Thus, the flag shows whether
486 there are unsaved changes. The flag value is normally shown in the mode
487 line (@pxref{Mode Line Variables}), and controls saving (@pxref{Saving
488 Buffers}) and auto-saving (@pxref{Auto-Saving}).
490 Some Lisp programs set the flag explicitly. For example, the function
491 @code{set-visited-file-name} sets the flag to @code{t}, because the text
492 does not match the newly-visited file, even if it is unchanged from the
493 file formerly visited.
495 The functions that modify the contents of buffers are described in
498 @defun buffer-modified-p &optional buffer
499 This function returns @code{t} if the buffer @var{buffer} has been modified
500 since it was last read in from a file or saved, or @code{nil}
501 otherwise. If @var{buffer} is not supplied, the current buffer
505 @defun set-buffer-modified-p flag
506 This function marks the current buffer as modified if @var{flag} is
507 non-@code{nil}, or as unmodified if the flag is @code{nil}.
509 Another effect of calling this function is to cause unconditional
510 redisplay of the mode line for the current buffer. In fact, the
511 function @code{force-mode-line-update} works by doing this:
515 (set-buffer-modified-p (buffer-modified-p))
520 @defun restore-buffer-modified-p flag
521 Like @code{set-buffer-modified-p}, but does not force redisplay
525 @deffn Command not-modified
526 This command marks the current buffer as unmodified, and not needing to
527 be saved. With prefix arg, it marks the buffer as modified, so that it
528 will be saved at the next suitable occasion.
530 Don't use this function in programs, since it prints a message in the
531 echo area; use @code{set-buffer-modified-p} (above) instead.
535 @defun buffer-modified-tick &optional buffer
536 This function returns @var{buffer}'s modification-count. This is a
537 counter that increments every time the buffer is modified. If
538 @var{buffer} is @code{nil} (or omitted), the current buffer is used.
541 @node Modification Time
542 @comment node-name, next, previous, up
543 @section Comparison of Modification Time
544 @cindex comparison of modification time
545 @cindex modification time, comparison of
547 Suppose that you visit a file and make changes in its buffer, and
548 meanwhile the file itself is changed on disk. At this point, saving the
549 buffer would overwrite the changes in the file. Occasionally this may
550 be what you want, but usually it would lose valuable information. Emacs
551 therefore checks the file's modification time using the functions
552 described below before saving the file.
554 @defun verify-visited-file-modtime buffer
555 This function compares what @var{buffer} has recorded for the
556 modification time of its visited file against the actual modification
557 time of the file as recorded by the operating system. The two should be
558 the same unless some other process has written the file since Emacs
561 The function returns @code{t} if the last actual modification time and
562 Emacs's recorded modification time are the same, @code{nil} otherwise.
565 @defun clear-visited-file-modtime
566 This function clears out the record of the last modification time of
567 the file being visited by the current buffer. As a result, the next
568 attempt to save this buffer will not complain of a discrepancy in
569 file modification times.
571 This function is called in @code{set-visited-file-name} and other
572 exceptional places where the usual test to avoid overwriting a changed
573 file should not be done.
577 @defun visited-file-modtime
578 This function returns the buffer's recorded last file modification time,
579 as a list of the form @code{(@var{high} . @var{low})}. (This is the
580 same format that @code{file-attributes} uses to return time values; see
581 @ref{File Attributes}.)
585 @defun set-visited-file-modtime &optional time
586 This function updates the buffer's record of the last modification time
587 of the visited file, to the value specified by @var{time} if @var{time}
588 is not @code{nil}, and otherwise to the last modification time of the
591 If @var{time} is not @code{nil}, it should have the form
592 @code{(@var{high} . @var{low})} or @code{(@var{high} @var{low})}, in
593 either case containing two integers, each of which holds 16 bits of the
596 This function is useful if the buffer was not read from the file
597 normally, or if the file itself has been changed for some known benign
601 @defun ask-user-about-supersession-threat filename
602 @cindex obsolete buffer
603 This function is used to ask a user how to proceed after an attempt to
604 modify an obsolete buffer visiting file @var{filename}. An
605 @dfn{obsolete buffer} is an unmodified buffer for which the associated
606 file on disk is newer than the last save-time of the buffer. This means
607 some other program has probably altered the file.
609 @kindex file-supersession
610 Depending on the user's answer, the function may return normally, in
611 which case the modification of the buffer proceeds, or it may signal a
612 @code{file-supersession} error with data @code{(@var{filename})}, in which
613 case the proposed buffer modification is not allowed.
615 This function is called automatically by Emacs on the proper
616 occasions. It exists so you can customize Emacs by redefining it.
617 See the file @file{userlock.el} for the standard definition.
619 See also the file locking mechanism in @ref{File Locks}.
622 @node Read Only Buffers
623 @section Read-Only Buffers
624 @cindex read-only buffer
625 @cindex buffer, read-only
627 If a buffer is @dfn{read-only}, then you cannot change its contents,
628 although you may change your view of the contents by scrolling and
631 Read-only buffers are used in two kinds of situations:
635 A buffer visiting a write-protected file is normally read-only.
637 Here, the purpose is to inform the user that editing the buffer with the
638 aim of saving it in the file may be futile or undesirable. The user who
639 wants to change the buffer text despite this can do so after clearing
640 the read-only flag with @kbd{C-x C-q}.
643 Modes such as Dired and Rmail make buffers read-only when altering the
644 contents with the usual editing commands would probably be a mistake.
646 The special commands of these modes bind @code{buffer-read-only} to
647 @code{nil} (with @code{let}) or bind @code{inhibit-read-only} to
648 @code{t} around the places where they themselves change the text.
651 @defvar buffer-read-only
652 This buffer-local variable specifies whether the buffer is read-only.
653 The buffer is read-only if this variable is non-@code{nil}.
656 @defvar inhibit-read-only
657 If this variable is non-@code{nil}, then read-only buffers and read-only
658 characters may be modified. Read-only characters in a buffer are those
659 that have non-@code{nil} @code{read-only} properties (either text
660 properties or overlay properties). @xref{Special Properties}, for more
661 information about text properties. @xref{Overlays}, for more
662 information about overlays and their properties.
664 If @code{inhibit-read-only} is @code{t}, all @code{read-only} character
665 properties have no effect. If @code{inhibit-read-only} is a list, then
666 @code{read-only} character properties have no effect if they are members
667 of the list (comparison is done with @code{eq}).
670 @deffn Command toggle-read-only
671 This command changes whether the current buffer is read-only. It is
672 intended for interactive use; do not use it in programs. At any given
673 point in a program, you should know whether you want the read-only flag
674 on or off; so you can set @code{buffer-read-only} explicitly to the
675 proper value, @code{t} or @code{nil}.
678 @defun barf-if-buffer-read-only
679 This function signals a @code{buffer-read-only} error if the current
680 buffer is read-only. @xref{Interactive Call}, for another way to
681 signal an error if the current buffer is read-only.
684 @node The Buffer List
685 @section The Buffer List
688 The @dfn{buffer list} is a list of all live buffers. Creating a
689 buffer adds it to this list, and killing a buffer removes it. The
690 order of the buffers in the list is based primarily on how recently
691 each buffer has been displayed in the selected window. Buffers move
692 to the front of the list when they are selected (selecting a window
693 that already displays the buffer counts as selecting the buffer), and
694 to the end when they are buried (see @code{bury-buffer}, below).
695 Several functions, notably @code{other-buffer}, use this ordering. A
696 buffer list displayed for the user also follows this order.
698 In addition to the fundamental Emacs buffer list, each frame has its
699 own version of the buffer list, in which the buffers that have been
700 selected in that frame come first, starting with the buffers most
701 recently selected @emph{in that frame}. (This order is recorded in
702 @var{frame}'s @code{buffer-list} frame parameter; see @ref{Window Frame
703 Parameters}.) The buffers that were never selected in @var{frame} come
704 afterward, ordered according to the fundamental Emacs buffer list.
706 @defun buffer-list &optional frame
707 This function returns the buffer list, including all buffers, even those
708 whose names begin with a space. The elements are actual buffers, not
711 If @var{frame} is a frame, this returns @var{frame}'s buffer list. If
712 @var{frame} is @code{nil}, the fundamental Emacs buffer list is used:
713 all the buffers appear in order of most recent selection, regardless of
714 which frames they were selected in.
719 @result{} (#<buffer buffers.texi>
720 #<buffer *Minibuf-1*> #<buffer buffer.c>
721 #<buffer *Help*> #<buffer TAGS>)
725 ;; @r{Note that the name of the minibuffer}
726 ;; @r{begins with a space!}
727 (mapcar (function buffer-name) (buffer-list))
728 @result{} ("buffers.texi" " *Minibuf-1*"
729 "buffer.c" "*Help*" "TAGS")
734 The list that @code{buffer-list} returns is constructed specifically
735 by @code{buffer-list}; it is not an internal Emacs data structure, and
736 modifying it has no effect on the order of buffers. If you want to
737 change the order of buffers in the frame-independent buffer list, here
741 (defun reorder-buffer-list (new-list)
743 (bury-buffer (car new-list))
744 (setq new-list (cdr new-list))))
747 With this method, you can specify any order for the list, but there is
748 no danger of losing a buffer or adding something that is not a valid
751 To change the order or value of a frame's buffer list, set the frame's
752 @code{buffer-list} frame parameter with @code{modify-frame-parameters}
753 (@pxref{Parameter Access}).
755 @defun other-buffer &optional buffer visible-ok frame
756 This function returns the first buffer in the buffer list other than
757 @var{buffer}. Usually this is the buffer selected most recently (in
758 frame @var{frame} or else the currently selected frame, @pxref{Input
759 Focus}), aside from @var{buffer}. Buffers whose names start with a
760 space are not considered at all.
762 If @var{buffer} is not supplied (or if it is not a buffer), then
763 @code{other-buffer} returns the first buffer in the selected frame's
764 buffer list that is not now visible in any window in a visible frame.
766 If @var{frame} has a non-@code{nil} @code{buffer-predicate} parameter,
767 then @code{other-buffer} uses that predicate to decide which buffers to
768 consider. It calls the predicate once for each buffer, and if the value
769 is @code{nil}, that buffer is ignored. @xref{Window Frame Parameters}.
772 If @var{visible-ok} is @code{nil}, @code{other-buffer} avoids returning
773 a buffer visible in any window on any visible frame, except as a last
774 resort. If @var{visible-ok} is non-@code{nil}, then it does not matter
775 whether a buffer is displayed somewhere or not.
777 If no suitable buffer exists, the buffer @samp{*scratch*} is returned
778 (and created, if necessary).
781 @deffn Command bury-buffer &optional buffer-or-name
782 This function puts @var{buffer-or-name} at the end of the buffer list,
783 without changing the order of any of the other buffers on the list.
784 This buffer therefore becomes the least desirable candidate for
785 @code{other-buffer} to return.
787 @code{bury-buffer} operates on each frame's @code{buffer-list} parameter
788 as well as the frame-independent Emacs buffer list; therefore, the
789 buffer that you bury will come last in the value of @code{(buffer-list
790 @var{frame})} and in the value of @code{(buffer-list nil)}.
792 If @var{buffer-or-name} is @code{nil} or omitted, this means to bury the
793 current buffer. In addition, if the buffer is displayed in the selected
794 window, this switches to some other buffer (obtained using
795 @code{other-buffer}) in the selected window. But if the buffer is
796 displayed in some other window, it remains displayed there.
798 To replace a buffer in all the windows that display it, use
799 @code{replace-buffer-in-windows}. @xref{Buffers and Windows}.
802 @node Creating Buffers
803 @section Creating Buffers
804 @cindex creating buffers
805 @cindex buffers, creating
807 This section describes the two primitives for creating buffers.
808 @code{get-buffer-create} creates a buffer if it finds no existing buffer
809 with the specified name; @code{generate-new-buffer} always creates a new
810 buffer and gives it a unique name.
812 Other functions you can use to create buffers include
813 @code{with-output-to-temp-buffer} (@pxref{Temporary Displays}) and
814 @code{create-file-buffer} (@pxref{Visiting Files}). Starting a
815 subprocess can also create a buffer (@pxref{Processes}).
817 @defun get-buffer-create name
818 This function returns a buffer named @var{name}. It returns an existing
819 buffer with that name, if one exists; otherwise, it creates a new
820 buffer. The buffer does not become the current buffer---this function
821 does not change which buffer is current.
823 An error is signaled if @var{name} is not a string.
827 (get-buffer-create "foo")
828 @result{} #<buffer foo>
832 The major mode for the new buffer is set to Fundamental mode. The
833 variable @code{default-major-mode} is handled at a higher level.
834 @xref{Auto Major Mode}.
837 @defun generate-new-buffer name
838 This function returns a newly created, empty buffer, but does not make
839 it current. If there is no buffer named @var{name}, then that is the
840 name of the new buffer. If that name is in use, this function adds
841 suffixes of the form @samp{<@var{n}>} to @var{name}, where @var{n} is an
842 integer. It tries successive integers starting with 2 until it finds an
845 An error is signaled if @var{name} is not a string.
849 (generate-new-buffer "bar")
850 @result{} #<buffer bar>
853 (generate-new-buffer "bar")
854 @result{} #<buffer bar<2>>
857 (generate-new-buffer "bar")
858 @result{} #<buffer bar<3>>
862 The major mode for the new buffer is set to Fundamental mode. The
863 variable @code{default-major-mode} is handled at a higher level.
864 @xref{Auto Major Mode}.
866 See the related function @code{generate-new-buffer-name} in @ref{Buffer
870 @node Killing Buffers
871 @section Killing Buffers
872 @cindex killing buffers
873 @cindex buffers, killing
875 @dfn{Killing a buffer} makes its name unknown to Emacs and makes its
876 text space available for other use.
878 The buffer object for the buffer that has been killed remains in
879 existence as long as anything refers to it, but it is specially marked
880 so that you cannot make it current or display it. Killed buffers retain
881 their identity, however; if you kill two distinct buffers, they remain
882 distinct according to @code{eq} although both are dead.
884 If you kill a buffer that is current or displayed in a window, Emacs
885 automatically selects or displays some other buffer instead. This means
886 that killing a buffer can in general change the current buffer.
887 Therefore, when you kill a buffer, you should also take the precautions
888 associated with changing the current buffer (unless you happen to know
889 that the buffer being killed isn't current). @xref{Current Buffer}.
891 If you kill a buffer that is the base buffer of one or more indirect
892 buffers, the indirect buffers are automatically killed as well.
894 The @code{buffer-name} of a killed buffer is @code{nil}. You can use
895 this feature to test whether a buffer has been killed:
899 (defun buffer-killed-p (buffer)
900 "Return t if BUFFER is killed."
901 (not (buffer-name buffer)))
905 @deffn Command kill-buffer buffer-or-name
906 This function kills the buffer @var{buffer-or-name}, freeing all its
907 memory for other uses or to be returned to the operating system. It
910 Any processes that have this buffer as the @code{process-buffer} are
911 sent the @code{SIGHUP} signal, which normally causes them to terminate.
912 (The basic meaning of @code{SIGHUP} is that a dialup line has been
913 disconnected.) @xref{Signals to Processes}.
915 If the buffer is visiting a file and contains unsaved changes,
916 @code{kill-buffer} asks the user to confirm before the buffer is killed.
917 It does this even if not called interactively. To prevent the request
918 for confirmation, clear the modified flag before calling
919 @code{kill-buffer}. @xref{Buffer Modification}.
921 Killing a buffer that is already dead has no effect.
924 (kill-buffer "foo.unchanged")
926 (kill-buffer "foo.changed")
928 ---------- Buffer: Minibuffer ----------
929 Buffer foo.changed modified; kill anyway? (yes or no) @kbd{yes}
930 ---------- Buffer: Minibuffer ----------
936 @defvar kill-buffer-query-functions
937 After confirming unsaved changes, @code{kill-buffer} calls the functions
938 in the list @code{kill-buffer-query-functions}, in order of appearance,
939 with no arguments. The buffer being killed is the current buffer when
940 they are called. The idea of this feature is that these functions will
941 ask for confirmation from the user. If any of them returns @code{nil},
942 @code{kill-buffer} spares the buffer's life.
945 @defvar kill-buffer-hook
946 This is a normal hook run by @code{kill-buffer} after asking all the
947 questions it is going to ask, just before actually killing the buffer.
948 The buffer to be killed is current when the hook functions run.
949 @xref{Hooks}. This variable is a permanent local, so its local binding
950 is not cleared by changing major modes.
953 @defvar buffer-offer-save
954 This variable, if non-@code{nil} in a particular buffer, tells
955 @code{save-buffers-kill-emacs} and @code{save-some-buffers} to offer to
956 save that buffer, just as they offer to save file-visiting buffers. The
957 variable @code{buffer-offer-save} automatically becomes buffer-local
958 when set for any reason. @xref{Buffer-Local Variables}.
961 @defun buffer-live-p buffer
962 This function returns @code{t} if @var{object} is a buffer which has
963 not been killed, @code{nil} otherwise.
966 @node Indirect Buffers
967 @section Indirect Buffers
968 @cindex indirect buffers
971 An @dfn{indirect buffer} shares the text of some other buffer, which
972 is called the @dfn{base buffer} of the indirect buffer. In some ways it
973 is the analogue, for buffers, of a symbolic link among files. The base
974 buffer may not itself be an indirect buffer.
976 The text of the indirect buffer is always identical to the text of its
977 base buffer; changes made by editing either one are visible immediately
978 in the other. This includes the text properties as well as the characters
981 In all other respects, the indirect buffer and its base buffer are
982 completely separate. They have different names, different values of
983 point, different narrowing, different markers and overlays (though
984 inserting or deleting text in either buffer relocates the markers and
985 overlays for both), different major modes, and different buffer-local
988 An indirect buffer cannot visit a file, but its base buffer can. If
989 you try to save the indirect buffer, that actually saves the base
992 Killing an indirect buffer has no effect on its base buffer. Killing
993 the base buffer effectively kills the indirect buffer in that it cannot
994 ever again be the current buffer.
996 @deffn Command make-indirect-buffer base-buffer name
997 This creates an indirect buffer named @var{name} whose base buffer
998 is @var{base-buffer}. The argument @var{base-buffer} may be a buffer
1001 If @var{base-buffer} is an indirect buffer, its base buffer is used as
1002 the base for the new buffer.
1005 @defun buffer-base-buffer buffer
1006 This function returns the base buffer of @var{buffer}. If @var{buffer}
1007 is not indirect, the value is @code{nil}. Otherwise, the value is
1008 another buffer, which is never an indirect buffer.
1012 @section The Buffer Gap
1014 Emacs buffers are implemented using an invisible @dfn{gap} to make
1015 insertion and deletion faster. Insertion works by filling in part of
1016 the gap, and deletion adds to the gap. Of course, this means that the
1017 gap must first be moved to the locus of the insertion or deletion.
1018 Emacs moves the gap only when you try to insert or delete. This is why
1019 your first editing command in one part of a large buffer, after
1020 previously editing in another far-away part, sometimes involves a
1023 This mechanism works invisibly, and Lisp code should never be affected
1024 by the gap's current location, but these functions are available for
1025 getting information about the gap status.
1028 This function returns the current gap position in the current buffer.
1032 This function returns the current gap size of the current buffer.
1036 arch-tag: 2e53cfab-5691-41f6-b5a8-9c6a3462399c