1 /* Buffer manipulation primitives for GNU Emacs.
2 Copyright (C) 1985, 1986, 1987, 1988, 1989, 1992, 1993
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
22 #include <sys/types.h>
24 #include <sys/param.h>
27 /* in 4.1, param.h fails to define this. */
28 #define MAXPATHLEN 1024
29 #endif /* not MAXPATHLEN */
33 #include "intervals.h"
39 #include "blockinput.h"
41 struct buffer
*current_buffer
; /* the current buffer */
43 /* First buffer in chain of all buffers (in reverse order of creation).
44 Threaded through ->next. */
46 struct buffer
*all_buffers
;
48 /* This structure holds the default values of the buffer-local variables
49 defined with DEFVAR_PER_BUFFER, that have special slots in each buffer.
50 The default value occupies the same slot in this structure
51 as an individual buffer's value occupies in that buffer.
52 Setting the default value also goes through the alist of buffers
53 and stores into each buffer that does not say it has a local value. */
55 struct buffer buffer_defaults
;
57 /* A Lisp_Object pointer to the above, used for staticpro */
59 static Lisp_Object Vbuffer_defaults
;
61 /* This structure marks which slots in a buffer have corresponding
62 default values in buffer_defaults.
63 Each such slot has a nonzero value in this structure.
64 The value has only one nonzero bit.
66 When a buffer has its own local value for a slot,
67 the bit for that slot (found in the same slot in this structure)
68 is turned on in the buffer's local_var_flags slot.
70 If a slot in this structure is -1, then even though there may
71 be a DEFVAR_PER_BUFFER for the slot, there is no default value for it;
72 and the corresponding slot in buffer_defaults is not used.
74 If a slot is -2, then there is no DEFVAR_PER_BUFFER for it,
75 but there is a default value which is copied into each buffer.
77 If a slot in this structure is negative, then even though there may
78 be a DEFVAR_PER_BUFFER for the slot, there is no default value for it;
79 and the corresponding slot in buffer_defaults is not used.
81 If a slot in this structure corresponding to a DEFVAR_PER_BUFFER is
82 zero, that is a bug */
84 struct buffer buffer_local_flags
;
86 /* This structure holds the names of symbols whose values may be
87 buffer-local. It is indexed and accessed in the same way as the above. */
89 struct buffer buffer_local_symbols
;
90 /* A Lisp_Object pointer to the above, used for staticpro */
91 static Lisp_Object Vbuffer_local_symbols
;
93 /* This structure holds the required types for the values in the
94 buffer-local slots. If a slot contains Qnil, then the
95 corresponding buffer slot may contain a value of any type. If a
96 slot contains an integer, then prospective values' tags must be
97 equal to that integer. When a tag does not match, the function
98 buffer_slot_type_mismatch will signal an error. */
99 struct buffer buffer_local_types
;
101 Lisp_Object
Fset_buffer ();
102 void set_buffer_internal ();
104 /* Alist of all buffer names vs the buffers. */
105 /* This used to be a variable, but is no longer,
106 to prevent lossage due to user rplac'ing this alist or its elements. */
107 Lisp_Object Vbuffer_alist
;
109 /* Functions to call before and after each text change. */
110 Lisp_Object Vbefore_change_function
;
111 Lisp_Object Vafter_change_function
;
113 Lisp_Object Vtransient_mark_mode
;
115 /* List of functions to call before changing an unmodified buffer. */
116 Lisp_Object Vfirst_change_hook
;
117 Lisp_Object Qfirst_change_hook
;
119 Lisp_Object Qfundamental_mode
, Qmode_class
, Qpermanent_local
;
121 Lisp_Object Qprotected_field
;
123 Lisp_Object QSFundamental
; /* A string "Fundamental" */
125 Lisp_Object Qkill_buffer_hook
;
127 /* For debugging; temporary. See set_buffer_internal. */
128 /* Lisp_Object Qlisp_mode, Vcheck_symbol; */
133 if (XTYPE (spec
) == Lisp_String
)
134 error ("No buffer named %s", XSTRING (spec
)->data
);
135 error ("Invalid buffer argument");
138 DEFUN ("buffer-list", Fbuffer_list
, Sbuffer_list
, 0, 0, 0,
139 "Return a list of all existing live buffers.")
142 return Fmapcar (Qcdr
, Vbuffer_alist
);
145 DEFUN ("get-buffer", Fget_buffer
, Sget_buffer
, 1, 1, 0,
146 "Return the buffer named NAME (a string).\n\
147 If there is no live buffer named NAME, return nil.\n\
148 NAME may also be a buffer; if so, the value is that buffer.")
150 register Lisp_Object name
;
152 if (XTYPE (name
) == Lisp_Buffer
)
154 CHECK_STRING (name
, 0);
156 return Fcdr (Fassoc (name
, Vbuffer_alist
));
159 DEFUN ("get-file-buffer", Fget_file_buffer
, Sget_file_buffer
, 1, 1, 0,
160 "Return the buffer visiting file FILENAME (a string).\n\
161 If there is no such live buffer, return nil.")
163 register Lisp_Object filename
;
165 register Lisp_Object tail
, buf
, tem
;
166 CHECK_STRING (filename
, 0);
167 filename
= Fexpand_file_name (filename
, Qnil
);
169 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
171 buf
= Fcdr (XCONS (tail
)->car
);
172 if (XTYPE (buf
) != Lisp_Buffer
) continue;
173 if (XTYPE (XBUFFER (buf
)->filename
) != Lisp_String
) continue;
174 tem
= Fstring_equal (XBUFFER (buf
)->filename
, filename
);
181 /* Incremented for each buffer created, to assign the buffer number. */
184 DEFUN ("get-buffer-create", Fget_buffer_create
, Sget_buffer_create
, 1, 1, 0,
185 "Return the buffer named NAME, or create such a buffer and return it.\n\
186 A new buffer is created if there is no live buffer named NAME.\n\
187 If NAME starts with a space, the new buffer does not keep undo information.\n\
188 If NAME is a buffer instead of a string, then it is the value returned.\n\
189 The value is never nil.")
191 register Lisp_Object name
;
193 register Lisp_Object buf
, function
, tem
;
194 int count
= specpdl_ptr
- specpdl
;
195 register struct buffer
*b
;
197 buf
= Fget_buffer (name
);
201 b
= (struct buffer
*) xmalloc (sizeof (struct buffer
));
203 BUF_GAP_SIZE (b
) = 20;
205 BUFFER_ALLOC (BUF_BEG_ADDR (b
), BUF_GAP_SIZE (b
));
207 if (! BUF_BEG_ADDR (b
))
217 /* Put this on the chain of all buffers including killed ones. */
218 b
->next
= all_buffers
;
221 b
->mark
= Fmake_marker ();
222 /*b->number = make_number (++buffer_count);*/
224 if (XSTRING (name
)->data
[0] != ' ')
231 /* Put this in the alist of all live buffers. */
232 XSET (buf
, Lisp_Buffer
, b
);
233 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buf
), Qnil
));
235 b
->mark
= Fmake_marker ();
239 function
= buffer_defaults
.major_mode
;
242 tem
= Fget (current_buffer
->major_mode
, Qmode_class
);
244 function
= current_buffer
->major_mode
;
247 if (NILP (function
) || EQ (function
, Qfundamental_mode
))
250 /* To select a nonfundamental mode,
251 select the buffer temporarily and then call the mode function. */
253 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
258 return unbind_to (count
, buf
);
261 /* Reinitialize everything about a buffer except its name and contents. */
265 register struct buffer
*b
;
268 b
->directory
= (current_buffer
) ? current_buffer
->directory
: Qnil
;
270 b
->save_modified
= 1;
271 XFASTINT (b
->save_length
) = 0;
272 b
->last_window_start
= 1;
274 b
->auto_save_modified
= 0;
275 b
->auto_save_file_name
= Qnil
;
277 b
->overlays_before
= Qnil
;
278 b
->overlays_after
= Qnil
;
279 XFASTINT (b
->overlay_center
) = 1;
281 /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
282 INITIALIZE_INTERVAL (b
, NULL_INTERVAL
);
284 reset_buffer_local_variables(b
);
287 reset_buffer_local_variables (b
)
288 register struct buffer
*b
;
292 /* Reset the major mode to Fundamental, together with all the
293 things that depend on the major mode.
294 default-major-mode is handled at a higher level.
295 We ignore it here. */
296 b
->major_mode
= Qfundamental_mode
;
298 b
->abbrev_table
= Vfundamental_mode_abbrev_table
;
299 b
->mode_name
= QSFundamental
;
300 b
->minor_modes
= Qnil
;
301 b
->downcase_table
= Vascii_downcase_table
;
302 b
->upcase_table
= Vascii_upcase_table
;
303 b
->case_canon_table
= Vascii_downcase_table
;
304 b
->case_eqv_table
= Vascii_upcase_table
;
305 b
->mark_active
= Qnil
;
307 b
->sort_table
= XSTRING (Vascii_sort_table
);
308 b
->folding_sort_table
= XSTRING (Vascii_folding_sort_table
);
311 /* Reset all per-buffer variables to their defaults. */
312 b
->local_var_alist
= Qnil
;
313 b
->local_var_flags
= 0;
315 /* For each slot that has a default value,
316 copy that into the slot. */
318 for (offset
= (char *)&buffer_local_flags
.name
- (char *)&buffer_local_flags
;
319 offset
< sizeof (struct buffer
);
320 offset
+= sizeof (Lisp_Object
)) /* sizeof int == sizeof Lisp_Object */
321 if (*(int *)(offset
+ (char *) &buffer_local_flags
) > 0
322 || *(int *)(offset
+ (char *) &buffer_local_flags
) == -2)
323 *(Lisp_Object
*)(offset
+ (char *)b
) =
324 *(Lisp_Object
*)(offset
+ (char *)&buffer_defaults
);
327 /* We split this away from generate-new-buffer, because rename-buffer
328 and set-visited-file-name ought to be able to use this to really
329 rename the buffer properly. */
331 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name
, Sgenerate_new_buffer_name
,
333 "Return a string that is the name of no existing buffer based on NAME.\n\
334 If there is no live buffer named NAME, then return NAME.\n\
335 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER\n\
336 until an unused name is found, and then return that name.")
338 register Lisp_Object name
;
340 register Lisp_Object gentemp
, tem
;
344 CHECK_STRING (name
, 0);
346 tem
= Fget_buffer (name
);
353 sprintf (number
, "<%d>", ++count
);
354 gentemp
= concat2 (name
, build_string (number
));
355 tem
= Fget_buffer (gentemp
);
362 DEFUN ("buffer-name", Fbuffer_name
, Sbuffer_name
, 0, 1, 0,
363 "Return the name of BUFFER, as a string.\n\
364 With no argument or nil as argument, return the name of the current buffer.")
366 register Lisp_Object buffer
;
369 return current_buffer
->name
;
370 CHECK_BUFFER (buffer
, 0);
371 return XBUFFER (buffer
)->name
;
374 DEFUN ("buffer-file-name", Fbuffer_file_name
, Sbuffer_file_name
, 0, 1, 0,
375 "Return name of file BUFFER is visiting, or nil if none.\n\
376 No argument or nil as argument means use the current buffer.")
378 register Lisp_Object buffer
;
381 return current_buffer
->filename
;
382 CHECK_BUFFER (buffer
, 0);
383 return XBUFFER (buffer
)->filename
;
386 DEFUN ("buffer-local-variables", Fbuffer_local_variables
,
387 Sbuffer_local_variables
, 0, 1, 0,
388 "Return an alist of variables that are buffer-local in BUFFER.\n\
389 Each element looks like (SYMBOL . VALUE) and describes one variable.\n\
390 Note that storing new VALUEs in these elements doesn't change the variables.\n\
391 No argument or nil as argument means use current buffer as BUFFER.")
393 register Lisp_Object buffer
;
395 register struct buffer
*buf
;
396 register Lisp_Object val
;
399 buf
= current_buffer
;
402 CHECK_BUFFER (buffer
, 0);
403 buf
= XBUFFER (buffer
);
407 /* Reference each variable in the alist in our current buffer.
408 If inquiring about the current buffer, this gets the current values,
409 so store them into the alist so the alist is up to date.
410 If inquiring about some other buffer, this swaps out any values
411 for that buffer, making the alist up to date automatically. */
412 register Lisp_Object tem
;
413 for (tem
= buf
->local_var_alist
; CONSP (tem
); tem
= XCONS (tem
)->cdr
)
415 Lisp_Object v1
= Fsymbol_value (XCONS (XCONS (tem
)->car
)->car
);
416 if (buf
== current_buffer
)
417 XCONS (XCONS (tem
)->car
)->cdr
= v1
;
421 /* Make a copy of the alist, to return it. */
422 val
= Fcopy_alist (buf
->local_var_alist
);
424 /* Add on all the variables stored in special slots. */
426 register int offset
, mask
;
428 for (offset
= (char *)&buffer_local_symbols
.name
- (char *)&buffer_local_symbols
;
429 offset
< sizeof (struct buffer
);
430 offset
+= (sizeof (int))) /* sizeof int == sizeof Lisp_Object */
432 mask
= *(int *)(offset
+ (char *) &buffer_local_flags
);
433 if (mask
== -1 || (buf
->local_var_flags
& mask
))
434 if (XTYPE (*(Lisp_Object
*)(offset
+ (char *)&buffer_local_symbols
))
436 val
= Fcons (Fcons (*(Lisp_Object
*)(offset
+ (char *)&buffer_local_symbols
),
437 *(Lisp_Object
*)(offset
+ (char *)buf
)),
445 DEFUN ("buffer-modified-p", Fbuffer_modified_p
, Sbuffer_modified_p
,
447 "Return t if BUFFER was modified since its file was last read or saved.\n\
448 No argument or nil as argument means use current buffer as BUFFER.")
450 register Lisp_Object buffer
;
452 register struct buffer
*buf
;
454 buf
= current_buffer
;
457 CHECK_BUFFER (buffer
, 0);
458 buf
= XBUFFER (buffer
);
461 return buf
->save_modified
< BUF_MODIFF (buf
) ? Qt
: Qnil
;
464 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p
, Sset_buffer_modified_p
,
466 "Mark current buffer as modified or unmodified according to FLAG.\n\
467 A non-nil FLAG means mark the buffer modified.")
469 register Lisp_Object flag
;
471 register int already
;
472 register Lisp_Object fn
;
474 #ifdef CLASH_DETECTION
475 /* If buffer becoming modified, lock the file.
476 If buffer becoming unmodified, unlock the file. */
478 fn
= current_buffer
->filename
;
481 already
= current_buffer
->save_modified
< MODIFF
;
482 if (!already
&& !NILP (flag
))
484 else if (already
&& NILP (flag
))
487 #endif /* CLASH_DETECTION */
489 current_buffer
->save_modified
= NILP (flag
) ? MODIFF
: 0;
494 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick
, Sbuffer_modified_tick
,
496 "Return BUFFER's tick counter, incremented for each change in text.\n\
497 Each buffer has a tick counter which is incremented each time the text in\n\
498 that buffer is changed. It wraps around occasionally.\n\
499 No argument or nil as argument means use current buffer as BUFFER.")
501 register Lisp_Object buffer
;
503 register struct buffer
*buf
;
505 buf
= current_buffer
;
508 CHECK_BUFFER (buffer
, 0);
509 buf
= XBUFFER (buffer
);
512 return make_number (BUF_MODIFF (buf
));
515 DEFUN ("rename-buffer", Frename_buffer
, Srename_buffer
, 1, 2,
516 "sRename buffer (to new name): \nP",
517 "Change current buffer's name to NEWNAME (a string).\n\
518 If second arg UNIQUE is nil or omitted, it is an error if a\n\
519 buffer named NEWNAME already exists.\n\
520 If UNIQUE is non-nil, come up with a new name using\n\
521 `generate-new-buffer-name'.\n\
522 Interactively, you can set UNIQUE with a prefix argument.\n\
523 We return the name we actually gave the buffer.\n\
524 This does not change the name of the visited file (if any).")
526 register Lisp_Object name
, unique
;
528 register Lisp_Object tem
, buf
;
530 CHECK_STRING (name
, 0);
531 tem
= Fget_buffer (name
);
532 if (XBUFFER (tem
) == current_buffer
)
533 return current_buffer
->name
;
537 name
= Fgenerate_new_buffer_name (name
);
539 error ("Buffer name \"%s\" is in use", XSTRING (name
)->data
);
542 current_buffer
->name
= name
;
544 /* Catch redisplay's attention. Unless we do this, the mode lines for
545 any windows displaying current_buffer will stay unchanged. */
548 XSET (buf
, Lisp_Buffer
, current_buffer
);
549 Fsetcar (Frassq (buf
, Vbuffer_alist
), name
);
550 if (NILP (current_buffer
->filename
) && !NILP (current_buffer
->auto_save_file_name
))
551 call0 (intern ("rename-auto-save-file"));
555 DEFUN ("other-buffer", Fother_buffer
, Sother_buffer
, 0, 2, 0,
556 "Return most recently selected buffer other than BUFFER.\n\
557 Buffers not visible in windows are preferred to visible buffers,\n\
558 unless optional second argument VISIBLE-OK is non-nil.\n\
559 If no other buffer exists, the buffer `*scratch*' is returned.\n\
560 If BUFFER is omitted or nil, some interesting buffer is returned.")
562 register Lisp_Object buffer
, visible_ok
;
564 register Lisp_Object tail
, buf
, notsogood
, tem
;
567 for (tail
= Vbuffer_alist
; !NILP (tail
); tail
= Fcdr (tail
))
569 buf
= Fcdr (Fcar (tail
));
570 if (EQ (buf
, buffer
))
572 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
574 if (NILP (visible_ok
))
575 tem
= Fget_buffer_window (buf
, Qnil
);
580 if (NILP (notsogood
))
583 if (!NILP (notsogood
))
585 return Fget_buffer_create (build_string ("*scratch*"));
588 DEFUN ("buffer-disable-undo", Fbuffer_disable_undo
, Sbuffer_disable_undo
, 1,1,
590 "Make BUFFER stop keeping undo information.")
592 register Lisp_Object buffer
;
594 Lisp_Object real_buffer
;
597 XSET (real_buffer
, Lisp_Buffer
, current_buffer
);
600 real_buffer
= Fget_buffer (buffer
);
601 if (NILP (real_buffer
))
605 XBUFFER (real_buffer
)->undo_list
= Qt
;
610 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo
, Sbuffer_enable_undo
,
612 "Start keeping undo information for buffer BUFFER.\n\
613 No argument or nil as argument means do this for the current buffer.")
615 register Lisp_Object buffer
;
617 Lisp_Object real_buffer
;
620 XSET (real_buffer
, Lisp_Buffer
, current_buffer
);
623 real_buffer
= Fget_buffer (buffer
);
624 if (NILP (real_buffer
))
628 if (EQ (XBUFFER (real_buffer
)->undo_list
, Qt
))
629 XBUFFER (real_buffer
)->undo_list
= Qnil
;
635 DEFVAR_LISP ("kill-buffer-hook", no_cell, "\
636 Hook to be run (by `run-hooks', which see) when a buffer is killed.\n\
637 The buffer being killed will be current while the hook is running.\n\
640 DEFUN ("kill-buffer", Fkill_buffer
, Skill_buffer
, 1, 1, "bKill buffer: ",
641 "Kill the buffer BUFFER.\n\
642 The argument may be a buffer or may be the name of a buffer.\n\
643 An argument of nil means kill the current buffer.\n\n\
644 Value is t if the buffer is actually killed, nil if user says no.\n\n\
645 The value of `kill-buffer-hook' (which may be local to that buffer),\n\
646 if not void, is a list of functions to be called, with no arguments,\n\
647 before the buffer is actually killed. The buffer to be killed is current\n\
648 when the hook functions are called.\n\n\
649 Any processes that have this buffer as the `process-buffer' are killed\n\
650 with `delete-process'.")
655 register struct buffer
*b
;
656 register Lisp_Object tem
;
657 register struct Lisp_Marker
*m
;
658 struct gcpro gcpro1
, gcpro2
;
661 buf
= Fcurrent_buffer ();
663 buf
= Fget_buffer (bufname
);
669 /* Query if the buffer is still modified. */
670 if (INTERACTIVE
&& !NILP (b
->filename
)
671 && BUF_MODIFF (b
) > b
->save_modified
)
673 GCPRO2 (buf
, bufname
);
674 tem
= do_yes_or_no_p (format1 ("Buffer %s modified; kill anyway? ",
675 XSTRING (b
->name
)->data
));
681 /* Run kill-buffer hook with the buffer to be killed the current buffer. */
683 register Lisp_Object val
;
684 int count
= specpdl_ptr
- specpdl
;
686 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
687 set_buffer_internal (b
);
688 call1 (Vrun_hooks
, Qkill_buffer_hook
);
689 unbind_to (count
, Qnil
);
692 /* We have no more questions to ask. Verify that it is valid
693 to kill the buffer. This must be done after the questions
694 since anything can happen within do_yes_or_no_p. */
696 /* Don't kill the minibuffer now current. */
697 if (EQ (buf
, XWINDOW (minibuf_window
)->buffer
))
703 /* Make this buffer not be current.
704 In the process, notice if this is the sole visible buffer
705 and give up if so. */
706 if (b
== current_buffer
)
708 tem
= Fother_buffer (buf
, Qnil
);
710 if (b
== current_buffer
)
714 /* Now there is no question: we can kill the buffer. */
716 #ifdef CLASH_DETECTION
717 /* Unlock this buffer's file, if it is locked. */
719 #endif /* CLASH_DETECTION */
721 kill_buffer_processes (buf
);
725 Vbuffer_alist
= Fdelq (Frassq (buf
, Vbuffer_alist
), Vbuffer_alist
);
726 Freplace_buffer_in_windows (buf
);
729 /* Delete any auto-save file. */
730 if (XTYPE (b
->auto_save_file_name
) == Lisp_String
)
733 tem
= Fsymbol_value (intern ("delete-auto-save-files"));
735 unlink (XSTRING (b
->auto_save_file_name
)->data
);
738 /* Unchain all markers of this buffer
739 and leave them pointing nowhere. */
740 for (tem
= b
->markers
; !EQ (tem
, Qnil
); )
749 /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
750 INITIALIZE_INTERVAL (b
, NULL_INTERVAL
);
751 /* Perhaps we should explicitly free the interval tree here... */
755 BUFFER_FREE (BUF_BEG_ADDR (b
));
762 /* Move the assoc for buffer BUF to the front of buffer-alist. Since
763 we do this each time BUF is selected visibly, the more recently
764 selected buffers are always closer to the front of the list. This
765 means that other_buffer is more likely to choose a relevant buffer. */
770 register Lisp_Object link
, prev
;
773 for (link
= Vbuffer_alist
; CONSP (link
); link
= XCONS (link
)->cdr
)
775 if (EQ (XCONS (XCONS (link
)->car
)->cdr
, buf
))
780 /* Effectively do Vbuffer_alist = Fdelq (link, Vbuffer_alist);
781 we cannot use Fdelq itself here because it allows quitting. */
784 Vbuffer_alist
= XCONS (Vbuffer_alist
)->cdr
;
786 XCONS (prev
)->cdr
= XCONS (XCONS (prev
)->cdr
)->cdr
;
788 XCONS(link
)->cdr
= Vbuffer_alist
;
789 Vbuffer_alist
= link
;
792 DEFUN ("switch-to-buffer", Fswitch_to_buffer
, Sswitch_to_buffer
, 1, 2, "BSwitch to buffer: ",
793 "Select buffer BUFFER in the current window.\n\
794 BUFFER may be a buffer or a buffer name.\n\
795 Optional second arg NORECORD non-nil means\n\
796 do not put this buffer at the front of the list of recently selected ones.\n\
798 WARNING: This is NOT the way to work on another buffer temporarily\n\
799 within a Lisp program! Use `set-buffer' instead. That avoids messing with\n\
800 the window-buffer correspondences.")
802 Lisp_Object bufname
, norecord
;
804 register Lisp_Object buf
;
807 if (EQ (minibuf_window
, selected_window
))
808 error ("Cannot switch buffers in minibuffer window");
809 tem
= Fwindow_dedicated_p (selected_window
);
811 error ("Cannot switch buffers in a dedicated window");
814 buf
= Fother_buffer (Fcurrent_buffer (), Qnil
);
816 buf
= Fget_buffer_create (bufname
);
821 Fset_window_buffer (EQ (selected_window
, minibuf_window
)
822 ? Fnext_window (minibuf_window
, Qnil
, Qnil
)
829 DEFUN ("pop-to-buffer", Fpop_to_buffer
, Spop_to_buffer
, 1, 2, 0,
830 "Select buffer BUFFER in some window, preferably a different one.\n\
831 If BUFFER is nil, then some other buffer is chosen.\n\
832 If `pop-up-windows' is non-nil, windows can be split to do this.\n\
833 If optional second arg OTHER-WINDOW is non-nil, insist on finding another\n\
834 window even if BUFFER is already visible in the selected window.")
836 Lisp_Object bufname
, other
;
838 register Lisp_Object buf
;
840 buf
= Fother_buffer (Fcurrent_buffer (), Qnil
);
842 buf
= Fget_buffer_create (bufname
);
845 Fselect_window (Fdisplay_buffer (buf
, other
));
849 DEFUN ("current-buffer", Fcurrent_buffer
, Scurrent_buffer
, 0, 0, 0,
850 "Return the current buffer as a Lisp object.")
853 register Lisp_Object buf
;
854 XSET (buf
, Lisp_Buffer
, current_buffer
);
858 /* Set the current buffer to b */
861 set_buffer_internal (b
)
862 register struct buffer
*b
;
864 register struct buffer
*old_buf
;
865 register Lisp_Object tail
, valcontents
;
868 if (current_buffer
== b
)
871 windows_or_buffers_changed
= 1;
872 old_buf
= current_buffer
;
874 last_known_column_point
= -1; /* invalidate indentation cache */
876 /* Look down buffer's list of local Lisp variables
877 to find and update any that forward into C variables. */
879 for (tail
= b
->local_var_alist
; !NILP (tail
); tail
= XCONS (tail
)->cdr
)
881 valcontents
= XSYMBOL (XCONS (XCONS (tail
)->car
)->car
)->value
;
882 if ((XTYPE (valcontents
) == Lisp_Buffer_Local_Value
883 || XTYPE (valcontents
) == Lisp_Some_Buffer_Local_Value
)
884 && (tem
= XTYPE (XCONS (valcontents
)->car
),
885 (tem
== Lisp_Boolfwd
|| tem
== Lisp_Intfwd
886 || tem
== Lisp_Objfwd
)))
887 /* Just reference the variable
888 to cause it to become set for this buffer. */
889 Fsymbol_value (XCONS (XCONS (tail
)->car
)->car
);
892 /* Do the same with any others that were local to the previous buffer */
895 for (tail
= old_buf
->local_var_alist
; !NILP (tail
); tail
= XCONS (tail
)->cdr
)
897 valcontents
= XSYMBOL (XCONS (XCONS (tail
)->car
)->car
)->value
;
898 if ((XTYPE (valcontents
) == Lisp_Buffer_Local_Value
899 || XTYPE (valcontents
) == Lisp_Some_Buffer_Local_Value
)
900 && (tem
= XTYPE (XCONS (valcontents
)->car
),
901 (tem
== Lisp_Boolfwd
|| tem
== Lisp_Intfwd
902 || tem
== Lisp_Objfwd
)))
903 /* Just reference the variable
904 to cause it to become set for this buffer. */
905 Fsymbol_value (XCONS (XCONS (tail
)->car
)->car
);
909 DEFUN ("set-buffer", Fset_buffer
, Sset_buffer
, 1, 1, 0,
910 "Make the buffer BUFFER current for editing operations.\n\
911 BUFFER may be a buffer or the name of an existing buffer.\n\
912 See also `save-excursion' when you want to make a buffer current temporarily.\n\
913 This function does not display the buffer, so its effect ends\n\
914 when the current command terminates.\n\
915 Use `switch-to-buffer' or `pop-to-buffer' to switch buffers permanently.")
917 register Lisp_Object bufname
;
919 register Lisp_Object buffer
;
920 buffer
= Fget_buffer (bufname
);
923 if (NILP (XBUFFER (buffer
)->name
))
924 error ("Selecting deleted buffer");
925 set_buffer_internal (XBUFFER (buffer
));
929 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only
,
930 Sbarf_if_buffer_read_only
, 0, 0, 0,
931 "Signal a `buffer-read-only' error if the current buffer is read-only.")
934 while (!NILP (current_buffer
->read_only
))
935 Fsignal (Qbuffer_read_only
, (Fcons (Fcurrent_buffer (), Qnil
)));
939 DEFUN ("bury-buffer", Fbury_buffer
, Sbury_buffer
, 0, 1, "",
940 "Put BUFFER at the end of the list of all buffers.\n\
941 There it is the least likely candidate for `other-buffer' to return;\n\
942 thus, the least likely buffer for \\[switch-to-buffer] to select by default.\n\
943 If BUFFER is nil or omitted, bury the current buffer.\n\
944 Also, if BUFFER is nil or omitted, remove the current buffer from the\n\
945 selected window if it is displayed there.")
947 register Lisp_Object buf
;
949 /* Figure out what buffer we're going to bury. */
952 XSET (buf
, Lisp_Buffer
, current_buffer
);
954 /* If we're burying the current buffer, unshow it. */
955 Fswitch_to_buffer (Fother_buffer (buf
, Qnil
), Qnil
);
961 buf1
= Fget_buffer (buf
);
967 /* Move buf to the end of the buffer list. */
969 register Lisp_Object aelt
, link
;
971 aelt
= Frassq (buf
, Vbuffer_alist
);
972 link
= Fmemq (aelt
, Vbuffer_alist
);
973 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
974 XCONS (link
)->cdr
= Qnil
;
975 Vbuffer_alist
= nconc2 (Vbuffer_alist
, link
);
981 DEFUN ("erase-buffer", Ferase_buffer
, Serase_buffer
, 0, 0, "*",
982 "Delete the entire contents of the current buffer.\n\
983 Any clipping restriction in effect (see `narrow-to-region') is removed,\n\
984 so the buffer is truly empty after this.")
989 current_buffer
->last_window_start
= 1;
990 /* Prevent warnings, or suspension of auto saving, that would happen
991 if future size is less than past size. Use of erase-buffer
992 implies that the future text is not really related to the past text. */
993 XFASTINT (current_buffer
->save_length
) = 0;
997 validate_region (b
, e
)
998 register Lisp_Object
*b
, *e
;
1002 CHECK_NUMBER_COERCE_MARKER (*b
, 0);
1003 CHECK_NUMBER_COERCE_MARKER (*e
, 1);
1005 if (XINT (*b
) > XINT (*e
))
1007 i
= XFASTINT (*b
); /* This is legit even if *b is < 0 */
1009 XFASTINT (*e
) = i
; /* because this is all we do with i. */
1012 if (!(BEGV
<= XINT (*b
) && XINT (*b
) <= XINT (*e
)
1013 && XINT (*e
) <= ZV
))
1014 args_out_of_range (*b
, *e
);
1018 list_buffers_1 (files
)
1021 register Lisp_Object tail
, tem
, buf
;
1022 Lisp_Object col1
, col2
, col3
, minspace
;
1023 register struct buffer
*old
= current_buffer
, *b
;
1024 int desired_point
= 0;
1025 Lisp_Object other_file_symbol
;
1027 other_file_symbol
= intern ("list-buffers-directory");
1029 XFASTINT (col1
) = 19;
1030 XFASTINT (col2
) = 25;
1031 XFASTINT (col3
) = 40;
1032 XFASTINT (minspace
) = 1;
1034 Fset_buffer (Vstandard_output
);
1036 tail
= intern ("Buffer-menu-mode");
1037 if (!EQ (tail
, current_buffer
->major_mode
)
1038 && (tem
= Ffboundp (tail
), !NILP (tem
)))
1040 Fbuffer_disable_undo (Vstandard_output
);
1041 current_buffer
->read_only
= Qnil
;
1044 MR Buffer Size Mode File\n\
1045 -- ------ ---- ---- ----\n", -1);
1047 for (tail
= Vbuffer_alist
; !NILP (tail
); tail
= Fcdr (tail
))
1049 buf
= Fcdr (Fcar (tail
));
1051 /* Don't mention the minibuffers. */
1052 if (XSTRING (b
->name
)->data
[0] == ' ')
1054 /* Optionally don't mention buffers that lack files. */
1055 if (!NILP (files
) && NILP (b
->filename
))
1057 /* Identify the current buffer. */
1059 desired_point
= point
;
1060 write_string (b
== old
? "." : " ", -1);
1061 /* Identify modified buffers */
1062 write_string (BUF_MODIFF (b
) > b
->save_modified
? "*" : " ", -1);
1063 write_string (NILP (b
->read_only
) ? " " : "% ", -1);
1064 Fprinc (b
->name
, Qnil
);
1065 Findent_to (col1
, make_number (2));
1066 XFASTINT (tem
) = BUF_Z (b
) - BUF_BEG (b
);
1068 Findent_to (col2
, minspace
);
1069 Fprinc (b
->mode_name
, Qnil
);
1070 Findent_to (col3
, minspace
);
1072 if (!NILP (b
->filename
))
1073 Fprinc (b
->filename
, Qnil
);
1076 /* No visited file; check local value of list-buffers-directory. */
1078 set_buffer_internal (b
);
1079 tem
= Fboundp (other_file_symbol
);
1082 tem
= Fsymbol_value (other_file_symbol
);
1083 Fset_buffer (Vstandard_output
);
1084 if (XTYPE (tem
) == Lisp_String
)
1088 Fset_buffer (Vstandard_output
);
1090 write_string ("\n", -1);
1093 current_buffer
->read_only
= Qt
;
1094 set_buffer_internal (old
);
1095 /* Foo. This doesn't work since temp_output_buffer_show sets point to 1
1097 XBUFFER (Vstandard_output)->text.pointloc = desired_point;
1102 DEFUN ("list-buffers", Flist_buffers
, Slist_buffers
, 0, 1, "P",
1103 "Display a list of names of existing buffers.\n\
1104 The list is displayed in a buffer named `*Buffer List*'.\n\
1105 Note that buffers with names starting with spaces are omitted.\n\
1106 Non-null optional arg FILES-ONLY means mention only file buffers.\n\
1108 The M column contains a * for buffers that are modified.\n\
1109 The R column contains a % for buffers that are read-only.")
1113 internal_with_output_to_temp_buffer ("*Buffer List*",
1114 list_buffers_1
, files
);
1118 DEFUN ("kill-all-local-variables", Fkill_all_local_variables
, Skill_all_local_variables
,
1120 "Switch to Fundamental mode by killing current buffer's local variables.\n\
1121 Most local variable bindings are eliminated so that the default values\n\
1122 become effective once more. Also, the syntax table is set from\n\
1123 `standard-syntax-table', the local keymap is set to nil,\n\
1124 and the abbrev table from `fundamental-mode-abbrev-table'.\n\
1125 This function also forces redisplay of the mode line.\n\
1127 Every function to select a new major mode starts by\n\
1128 calling this function.\n\n\
1129 As a special exception, local variables whose names have\n\
1130 a non-nil `permanent-local' property are not eliminated by this function.")
1133 register Lisp_Object alist
, sym
, tem
;
1135 oalist
= current_buffer
->local_var_alist
;
1137 /* Make sure no local variables remain set up with this buffer
1138 for their current values. */
1140 for (alist
= oalist
; !NILP (alist
); alist
= XCONS (alist
)->cdr
)
1142 sym
= XCONS (XCONS (alist
)->car
)->car
;
1144 /* Need not do anything if some other buffer's binding is now encached. */
1145 tem
= XCONS (XCONS (XSYMBOL (sym
)->value
)->cdr
)->car
;
1146 if (XBUFFER (tem
) == current_buffer
)
1148 /* Symbol is set up for this buffer's old local value.
1149 Set it up for the current buffer with the default value. */
1151 tem
= XCONS (XCONS (XSYMBOL (sym
)->value
)->cdr
)->cdr
;
1152 /* Store the symbol's current value into the alist entry
1153 it is currently set up for. This is so that, if the
1154 local is marked permanent, and we make it local again below,
1155 we don't lose the value. */
1156 XCONS (XCONS (tem
)->car
)->cdr
= XCONS (XSYMBOL (sym
)->value
)->car
;
1157 /* Switch to the symbol's default-value alist entry. */
1158 XCONS (tem
)->car
= tem
;
1159 /* Mark it as current for the current buffer. */
1160 XCONS (XCONS (XSYMBOL (sym
)->value
)->cdr
)->car
= Fcurrent_buffer ();
1161 /* Store the current value into any forwarding in the symbol. */
1162 store_symval_forwarding (sym
, XCONS (XSYMBOL (sym
)->value
)->car
,
1167 /* Actually eliminate all local bindings of this buffer. */
1169 reset_buffer_local_variables (current_buffer
);
1171 /* Redisplay mode lines; we are changing major mode. */
1173 update_mode_lines
++;
1175 /* Any which are supposed to be permanent,
1176 make local again, with the same values they had. */
1178 for (alist
= oalist
; !NILP (alist
); alist
= XCONS (alist
)->cdr
)
1180 sym
= XCONS (XCONS (alist
)->car
)->car
;
1181 tem
= Fget (sym
, Qpermanent_local
);
1184 Fmake_local_variable (sym
);
1185 Fset (sym
, XCONS (XCONS (alist
)->car
)->cdr
);
1189 /* Force mode-line redisplay. Useful here because all major mode
1190 commands call this function. */
1191 update_mode_lines
++;
1196 /* Find all the overlays in the current buffer that contain position POS.
1197 Return the number found, and store them in a vector in *VEC_PTR.
1198 Store in *LEN_PTR the size allocated for the vector.
1199 Store in *NEXT_PTR the next position after POS where an overlay starts.
1201 *VEC_PTR and *LEN_PTR should contain a valid vector and size
1202 when this function is called. */
1205 overlays_at (pos
, vec_ptr
, len_ptr
, next_ptr
)
1207 Lisp_Object
**vec_ptr
;
1211 Lisp_Object tail
, overlay
, start
, end
, result
;
1214 Lisp_Object
*vec
= *vec_ptr
;
1218 for (tail
= current_buffer
->overlays_before
;
1220 tail
= XCONS (tail
)->cdr
)
1222 overlay
= XCONS (tail
)->car
;
1223 if (! OVERLAY_VALID (overlay
))
1226 start
= OVERLAY_START (overlay
);
1227 end
= OVERLAY_END (overlay
);
1228 if (OVERLAY_POSITION (end
) <= pos
)
1230 startpos
= OVERLAY_POSITION (start
);
1231 if (startpos
<= pos
)
1235 *len_ptr
= len
*= 2;
1236 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
1239 vec
[idx
++] = overlay
;
1241 else if (startpos
< next
)
1245 for (tail
= current_buffer
->overlays_after
;
1247 tail
= XCONS (tail
)->cdr
)
1249 overlay
= XCONS (tail
)->car
;
1250 if (! OVERLAY_VALID (overlay
))
1253 start
= OVERLAY_START (overlay
);
1254 end
= OVERLAY_END (overlay
);
1255 startpos
= OVERLAY_POSITION (start
);
1258 if (startpos
< next
)
1262 if (OVERLAY_POSITION (end
) > pos
)
1266 *len_ptr
= len
*= 2;
1267 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
1270 vec
[idx
++] = overlay
;
1278 /* Shift overlays in the current buffer's overlay lists,
1279 to center the lists at POS. */
1282 recenter_overlay_lists (pos
)
1285 Lisp_Object overlay
, tail
, next
, prev
, beg
, end
;
1287 /* See if anything in overlays_before should move to overlays_after. */
1289 /* We don't strictly need prev in this loop; it should always be nil.
1290 But we use it for symmetry and in case that should cease to be true
1291 with some future change. */
1293 for (tail
= current_buffer
->overlays_before
;
1295 prev
= tail
, tail
= next
)
1297 next
= XCONS (tail
)->cdr
;
1298 overlay
= XCONS (tail
)->car
;
1300 /* If the overlay is not valid, get rid of it. */
1301 if (!OVERLAY_VALID (overlay
))
1303 /* Splice the cons cell TAIL out of overlays_before. */
1305 XCONS (prev
)->cdr
= next
;
1307 current_buffer
->overlays_before
= next
;
1312 beg
= OVERLAY_START (overlay
);
1313 end
= OVERLAY_END (overlay
);
1315 if (OVERLAY_POSITION (end
) > pos
)
1317 /* OVERLAY needs to be moved. */
1318 int where
= OVERLAY_POSITION (beg
);
1319 Lisp_Object other
, other_prev
;
1321 /* Splice the cons cell TAIL out of overlays_before. */
1323 XCONS (prev
)->cdr
= next
;
1325 current_buffer
->overlays_before
= next
;
1327 /* Search thru overlays_after for where to put it. */
1329 for (other
= current_buffer
->overlays_after
;
1331 other_prev
= other
, other
= XCONS (other
)->cdr
)
1333 Lisp_Object otherbeg
, otheroverlay
, follower
;
1336 otheroverlay
= XCONS (other
)->car
;
1337 if (! OVERLAY_VALID (otheroverlay
))
1340 otherbeg
= OVERLAY_START (otheroverlay
);
1341 if (OVERLAY_POSITION (otherbeg
) >= where
)
1345 /* Add TAIL to overlays_after before OTHER. */
1346 XCONS (tail
)->cdr
= other
;
1347 if (!NILP (other_prev
))
1348 XCONS (other_prev
)->cdr
= tail
;
1350 current_buffer
->overlays_after
= tail
;
1354 /* We've reached the things that should stay in overlays_before.
1355 All the rest of overlays_before must end even earlier,
1360 /* See if anything in overlays_after should be in overlays_before. */
1362 for (tail
= current_buffer
->overlays_after
;
1364 prev
= tail
, tail
= next
)
1366 next
= XCONS (tail
)->cdr
;
1367 overlay
= XCONS (tail
)->car
;
1369 /* If the overlay is not valid, get rid of it. */
1370 if (!OVERLAY_VALID (overlay
))
1372 /* Splice the cons cell TAIL out of overlays_after. */
1374 XCONS (prev
)->cdr
= next
;
1376 current_buffer
->overlays_after
= next
;
1381 beg
= OVERLAY_START (overlay
);
1382 end
= OVERLAY_END (overlay
);
1384 /* Stop looking, when we know that nothing further
1385 can possibly end before POS. */
1386 if (OVERLAY_POSITION (beg
) > pos
)
1389 if (OVERLAY_POSITION (end
) <= pos
)
1391 /* OVERLAY needs to be moved. */
1392 int where
= OVERLAY_POSITION (end
);
1393 Lisp_Object other
, other_prev
;
1395 /* Splice the cons cell TAIL out of overlays_after. */
1397 XCONS (prev
)->cdr
= next
;
1399 current_buffer
->overlays_after
= next
;
1401 /* Search thru overlays_before for where to put it. */
1403 for (other
= current_buffer
->overlays_before
;
1405 other_prev
= other
, other
= XCONS (other
)->cdr
)
1407 Lisp_Object otherend
, otheroverlay
;
1410 otheroverlay
= XCONS (other
)->car
;
1411 if (! OVERLAY_VALID (otheroverlay
))
1414 otherend
= OVERLAY_END (otheroverlay
);
1415 if (OVERLAY_POSITION (otherend
) <= where
)
1419 /* Add TAIL to overlays_before before OTHER. */
1420 XCONS (tail
)->cdr
= other
;
1421 if (!NILP (other_prev
))
1422 XCONS (other_prev
)->cdr
= tail
;
1424 current_buffer
->overlays_before
= tail
;
1429 XFASTINT (current_buffer
->overlay_center
) = pos
;
1432 DEFUN ("make-overlay", Fmake_overlay
, Smake_overlay
, 2, 2, 0,
1433 "Create a new overlay in the current buffer, with range BEG to END.\n\
1434 BEG and END may be integers or markers.")
1436 Lisp_Object beg
, end
;
1438 Lisp_Object overlay
;
1440 if (MARKERP (beg
) && XBUFFER (Fmarker_buffer (beg
)) != current_buffer
)
1441 error ("Marker points into wrong buffer");
1442 if (MARKERP (end
) && XBUFFER (Fmarker_buffer (end
)) != current_buffer
)
1443 error ("Marker points into wrong buffer");
1445 overlay
= Fcons (Fcons (Fcopy_marker (beg
), Fcopy_marker (end
)), Qnil
);
1447 /* Put the new overlay on the wrong list. */
1448 end
= OVERLAY_END (overlay
);
1449 if (OVERLAY_POSITION (end
) < XINT (current_buffer
->overlay_center
))
1450 current_buffer
->overlays_after
1451 = Fcons (overlay
, current_buffer
->overlays_after
);
1453 current_buffer
->overlays_before
1454 = Fcons (overlay
, current_buffer
->overlays_before
);
1456 /* This puts it in the right list, and in the right order. */
1457 recenter_overlay_lists (XINT (current_buffer
->overlay_center
));
1462 DEFUN ("move-overlay", Fmove_overlay
, Smove_overlay
, 3, 3, 0,
1463 "Set the endpoints of OVERLAY to BEG and END.")
1465 Lisp_Object overlay
, beg
, end
;
1467 if (!OVERLAY_VALID (overlay
))
1468 error ("Invalid overlay object");
1470 current_buffer
->overlays_before
1471 = Fdelq (overlay
, current_buffer
->overlays_before
);
1472 current_buffer
->overlays_after
1473 = Fdelq (overlay
, current_buffer
->overlays_after
);
1475 Fset_marker (OVERLAY_START (overlay
), beg
, Qnil
);
1476 Fset_marker (OVERLAY_END (overlay
), end
, Qnil
);
1478 /* Put the overlay on the wrong list. */
1479 end
= OVERLAY_END (overlay
);
1480 if (OVERLAY_POSITION (end
) < XINT (current_buffer
->overlay_center
))
1481 current_buffer
->overlays_after
1482 = Fcons (overlay
, current_buffer
->overlays_after
);
1484 current_buffer
->overlays_before
1485 = Fcons (overlay
, current_buffer
->overlays_before
);
1487 /* This puts it in the right list, and in the right order. */
1488 recenter_overlay_lists (XINT (current_buffer
->overlay_center
));
1493 DEFUN ("delete-overlay", Fdelete_overlay
, Sdelete_overlay
, 1, 1, 0,
1494 "Delete the overlay OVERLAY from the current buffer.")
1497 current_buffer
->overlays_before
1498 = Fdelq (overlay
, current_buffer
->overlays_before
);
1499 current_buffer
->overlays_after
1500 = Fdelq (overlay
, current_buffer
->overlays_after
);
1504 DEFUN ("overlays-at", Foverlays_at
, Soverlays_at
, 1, 1, 0,
1505 "Return a list of the overays that contain position POS.")
1511 Lisp_Object
*overlay_vec
;
1515 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
1518 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
1520 /* Put all the overlays we want in a vector in overlay_vec.
1521 Store the length in len. */
1522 noverlays
= overlays_at (XINT (pos
), &overlay_vec
, &len
, &endpos
);
1524 /* Make a list of them all. */
1525 result
= Flist (noverlays
, overlay_vec
);
1527 xfree (overlay_vec
);
1531 DEFUN ("next-overlay-change", Fnext_overlay_change
, Snext_overlay_change
,
1533 "Return the next position after POS where an overlay starts or ends.")
1539 Lisp_Object
*overlay_vec
;
1544 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
1547 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
1549 /* Put all the overlays we want in a vector in overlay_vec.
1550 Store the length in len.
1551 endpos gets the position where the next overlay starts. */
1552 noverlays
= overlays_at (XINT (pos
), &overlay_vec
, &len
, &endpos
);
1554 /* If any of these overlays ends before endpos,
1555 use its ending point instead. */
1556 for (i
= 0; i
< noverlays
; i
++)
1561 oend
= OVERLAY_END (overlay_vec
[i
]);
1562 oendpos
= OVERLAY_POSITION (oend
);
1563 if (oendpos
< endpos
)
1567 xfree (overlay_vec
);
1568 return make_number (endpos
);
1571 /* These functions are for debugging overlays. */
1573 DEFUN ("overlay-lists", Foverlay_lists
, Soverlay_lists
, 0, 0, 0,
1574 "Return a pair of lists giving all the overlays of the current buffer.\n\
1575 The car has all the overlays before the overlay center;\n\
1576 the cdr has all the overlays before the overlay center.\n\
1577 Recentering overlays moves overlays between these lists.\n\
1578 The lists you get are copies, so that changing them has no effect.\n\
1579 However, the overlays you get are the real objects that the buffer uses.")
1582 Lisp_Object before
, after
;
1583 before
= current_buffer
->overlays_before
;
1585 before
= Fcopy_sequence (before
);
1586 after
= current_buffer
->overlays_after
;
1588 after
= Fcopy_sequence (after
);
1590 return Fcons (before
, after
);
1593 DEFUN ("overlay-recenter", Foverlay_recenter
, Soverlay_recenter
, 1, 1, 0,
1594 "Recenter the overlays of the current buffer around position POS.")
1598 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
1600 recenter_overlay_lists (XINT (pos
));
1604 DEFUN ("overlay-get", Foverlay_get
, Soverlay_get
, 2, 2, 0,
1605 "Get the property of overlay OVERLAY with property name NAME.")
1607 Lisp_Object overlay
, prop
;
1610 for (plist
= Fcdr_safe (Fcdr_safe (overlay
));
1611 CONSP (plist
) && CONSP (XCONS (plist
)->cdr
);
1612 plist
= XCONS (XCONS (plist
)->cdr
)->cdr
)
1614 if (EQ (XCONS (plist
)->car
, prop
))
1615 return XCONS (XCONS (plist
)->cdr
)->car
;
1619 DEFUN ("overlay-put", Foverlay_put
, Soverlay_put
, 3, 3, 0,
1620 "Set one property of overlay OVERLAY: give property PROP value VALUE.")
1621 (overlay
, prop
, value
)
1622 Lisp_Object overlay
, prop
, value
;
1624 Lisp_Object plist
, tail
;
1626 plist
= Fcdr_safe (Fcdr_safe (overlay
));
1629 CONSP (tail
) && CONSP (XCONS (tail
)->cdr
);
1630 tail
= XCONS (XCONS (tail
)->cdr
)->cdr
)
1632 if (EQ (XCONS (tail
)->car
, prop
))
1633 return XCONS (XCONS (tail
)->cdr
)->car
= value
;
1636 if (! CONSP (XCONS (overlay
)->cdr
))
1637 XCONS (overlay
)->cdr
= Fcons (Qnil
, Qnil
);
1639 XCONS (XCONS (overlay
)->cdr
)->cdr
1640 = Fcons (prop
, Fcons (value
, plist
));
1645 /* Somebody has tried to store NEWVAL into the buffer-local slot with
1646 offset XUINT (valcontents), and NEWVAL has an unacceptable type. */
1648 buffer_slot_type_mismatch (valcontents
, newval
)
1649 Lisp_Object valcontents
, newval
;
1651 unsigned int offset
= XUINT (valcontents
);
1652 unsigned char *symbol_name
=
1653 (XSYMBOL (*(Lisp_Object
*)(offset
+ (char *)&buffer_local_symbols
))
1657 switch (XINT (*(Lisp_Object
*)(offset
+ (char *)&buffer_local_types
)))
1659 case Lisp_Int
: type_name
= "integers"; break;
1660 case Lisp_String
: type_name
= "strings"; break;
1661 case Lisp_Marker
: type_name
= "markers"; break;
1662 case Lisp_Symbol
: type_name
= "symbols"; break;
1663 case Lisp_Cons
: type_name
= "lists"; break;
1664 case Lisp_Vector
: type_name
= "vectors"; break;
1669 error ("only %s should be stored in the buffer-local variable %s",
1670 type_name
, symbol_name
);
1675 register Lisp_Object tem
;
1677 /* Make sure all markable slots in buffer_defaults
1678 are initialized reasonably, so mark_buffer won't choke. */
1679 reset_buffer (&buffer_defaults
);
1680 reset_buffer (&buffer_local_symbols
);
1681 XSET (Vbuffer_defaults
, Lisp_Buffer
, &buffer_defaults
);
1682 XSET (Vbuffer_local_symbols
, Lisp_Buffer
, &buffer_local_symbols
);
1684 /* Set up the default values of various buffer slots. */
1685 /* Must do these before making the first buffer! */
1687 /* real setup is done in loaddefs.el */
1688 buffer_defaults
.mode_line_format
= build_string ("%-");
1689 buffer_defaults
.abbrev_mode
= Qnil
;
1690 buffer_defaults
.overwrite_mode
= Qnil
;
1691 buffer_defaults
.case_fold_search
= Qt
;
1692 buffer_defaults
.auto_fill_function
= Qnil
;
1693 buffer_defaults
.selective_display
= Qnil
;
1695 buffer_defaults
.selective_display_ellipses
= Qt
;
1697 buffer_defaults
.abbrev_table
= Qnil
;
1698 buffer_defaults
.display_table
= Qnil
;
1699 buffer_defaults
.undo_list
= Qnil
;
1700 buffer_defaults
.mark_active
= Qnil
;
1701 buffer_defaults
.overlays_before
= Qnil
;
1702 buffer_defaults
.overlays_after
= Qnil
;
1703 XFASTINT (buffer_defaults
.overlay_center
) = 1;
1705 XFASTINT (buffer_defaults
.tab_width
) = 8;
1706 buffer_defaults
.truncate_lines
= Qnil
;
1707 buffer_defaults
.ctl_arrow
= Qt
;
1709 XFASTINT (buffer_defaults
.fill_column
) = 70;
1710 XFASTINT (buffer_defaults
.left_margin
) = 0;
1712 /* Assign the local-flags to the slots that have default values.
1713 The local flag is a bit that is used in the buffer
1714 to say that it has its own local value for the slot.
1715 The local flag bits are in the local_var_flags slot of the buffer. */
1717 /* Nothing can work if this isn't true */
1718 if (sizeof (int) != sizeof (Lisp_Object
)) abort ();
1720 /* 0 means not a lisp var, -1 means always local, else mask */
1721 bzero (&buffer_local_flags
, sizeof buffer_local_flags
);
1722 XFASTINT (buffer_local_flags
.filename
) = -1;
1723 XFASTINT (buffer_local_flags
.directory
) = -1;
1724 XFASTINT (buffer_local_flags
.backed_up
) = -1;
1725 XFASTINT (buffer_local_flags
.save_length
) = -1;
1726 XFASTINT (buffer_local_flags
.auto_save_file_name
) = -1;
1727 XFASTINT (buffer_local_flags
.read_only
) = -1;
1728 XFASTINT (buffer_local_flags
.major_mode
) = -1;
1729 XFASTINT (buffer_local_flags
.mode_name
) = -1;
1730 XFASTINT (buffer_local_flags
.undo_list
) = -1;
1731 XFASTINT (buffer_local_flags
.mark_active
) = -1;
1733 XFASTINT (buffer_local_flags
.mode_line_format
) = 1;
1734 XFASTINT (buffer_local_flags
.abbrev_mode
) = 2;
1735 XFASTINT (buffer_local_flags
.overwrite_mode
) = 4;
1736 XFASTINT (buffer_local_flags
.case_fold_search
) = 8;
1737 XFASTINT (buffer_local_flags
.auto_fill_function
) = 0x10;
1738 XFASTINT (buffer_local_flags
.selective_display
) = 0x20;
1740 XFASTINT (buffer_local_flags
.selective_display_ellipses
) = 0x40;
1742 XFASTINT (buffer_local_flags
.tab_width
) = 0x80;
1743 XFASTINT (buffer_local_flags
.truncate_lines
) = 0x100;
1744 XFASTINT (buffer_local_flags
.ctl_arrow
) = 0x200;
1745 XFASTINT (buffer_local_flags
.fill_column
) = 0x400;
1746 XFASTINT (buffer_local_flags
.left_margin
) = 0x800;
1747 XFASTINT (buffer_local_flags
.abbrev_table
) = 0x1000;
1748 XFASTINT (buffer_local_flags
.display_table
) = 0x2000;
1749 XFASTINT (buffer_local_flags
.syntax_table
) = 0x8000;
1751 Vbuffer_alist
= Qnil
;
1755 QSFundamental
= build_string ("Fundamental");
1757 Qfundamental_mode
= intern ("fundamental-mode");
1758 buffer_defaults
.major_mode
= Qfundamental_mode
;
1760 Qmode_class
= intern ("mode-class");
1762 Qprotected_field
= intern ("protected-field");
1764 Qpermanent_local
= intern ("permanent-local");
1766 Qkill_buffer_hook
= intern ("kill-buffer-hook");
1768 Vprin1_to_string_buffer
= Fget_buffer_create (build_string (" prin1"));
1769 /* super-magic invisible buffer */
1770 Vbuffer_alist
= Qnil
;
1772 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
1777 char buf
[MAXPATHLEN
+1];
1779 struct stat dotstat
, pwdstat
;
1781 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
1783 /* If PWD is accurate, use it instead of calling getwd. This is faster
1784 when PWD is right, and may avoid a fatal error. */
1785 if ((pwd
= getenv ("PWD")) != 0 && *pwd
== '/'
1786 && stat (pwd
, &pwdstat
) == 0
1787 && stat (".", &dotstat
) == 0
1788 && dotstat
.st_ino
== pwdstat
.st_ino
1789 && dotstat
.st_dev
== pwdstat
.st_dev
1790 && strlen (pwd
) < MAXPATHLEN
)
1792 else if (getwd (buf
) == 0)
1793 fatal ("`getwd' failed: %s.\n", buf
);
1796 /* Maybe this should really use some standard subroutine
1797 whose definition is filename syntax dependent. */
1798 if (buf
[strlen (buf
) - 1] != '/')
1800 #endif /* not VMS */
1801 current_buffer
->directory
= build_string (buf
);
1804 /* initialize the buffer routines */
1807 extern Lisp_Object Qdisabled
;
1809 staticpro (&Vbuffer_defaults
);
1810 staticpro (&Vbuffer_local_symbols
);
1811 staticpro (&Qfundamental_mode
);
1812 staticpro (&Qmode_class
);
1813 staticpro (&QSFundamental
);
1814 staticpro (&Vbuffer_alist
);
1815 staticpro (&Qprotected_field
);
1816 staticpro (&Qpermanent_local
);
1817 staticpro (&Qkill_buffer_hook
);
1819 Fput (Qprotected_field
, Qerror_conditions
,
1820 Fcons (Qprotected_field
, Fcons (Qerror
, Qnil
)));
1821 Fput (Qprotected_field
, Qerror_message
,
1822 build_string ("Attempt to modify a protected field"));
1824 Fput (intern ("erase-buffer"), Qdisabled
, Qt
);
1826 /* All these use DEFVAR_LISP_NOPRO because the slots in
1827 buffer_defaults will all be marked via Vbuffer_defaults. */
1829 DEFVAR_LISP_NOPRO ("default-mode-line-format",
1830 &buffer_defaults
.mode_line_format
,
1831 "Default value of `mode-line-format' for buffers that don't override it.\n\
1832 This is the same as (default-value 'mode-line-format).");
1834 DEFVAR_LISP_NOPRO ("default-abbrev-mode",
1835 &buffer_defaults
.abbrev_mode
,
1836 "Default value of `abbrev-mode' for buffers that do not override it.\n\
1837 This is the same as (default-value 'abbrev-mode).");
1839 DEFVAR_LISP_NOPRO ("default-ctl-arrow",
1840 &buffer_defaults
.ctl_arrow
,
1841 "Default value of `ctl-arrow' for buffers that do not override it.\n\
1842 This is the same as (default-value 'ctl-arrow).");
1844 DEFVAR_LISP_NOPRO ("default-truncate-lines",
1845 &buffer_defaults
.truncate_lines
,
1846 "Default value of `truncate-lines' for buffers that do not override it.\n\
1847 This is the same as (default-value 'truncate-lines).");
1849 DEFVAR_LISP_NOPRO ("default-fill-column",
1850 &buffer_defaults
.fill_column
,
1851 "Default value of `fill-column' for buffers that do not override it.\n\
1852 This is the same as (default-value 'fill-column).");
1854 DEFVAR_LISP_NOPRO ("default-left-margin",
1855 &buffer_defaults
.left_margin
,
1856 "Default value of `left-margin' for buffers that do not override it.\n\
1857 This is the same as (default-value 'left-margin).");
1859 DEFVAR_LISP_NOPRO ("default-tab-width",
1860 &buffer_defaults
.tab_width
,
1861 "Default value of `tab-width' for buffers that do not override it.\n\
1862 This is the same as (default-value 'tab-width).");
1864 DEFVAR_LISP_NOPRO ("default-case-fold-search",
1865 &buffer_defaults
.case_fold_search
,
1866 "Default value of `case-fold-search' for buffers that don't override it.\n\
1867 This is the same as (default-value 'case-fold-search).");
1869 DEFVAR_PER_BUFFER ("mode-line-format", ¤t_buffer
->mode_line_format
,
1872 /* This doc string is too long for cpp; cpp dies if it isn't in a comment.
1873 But make-docfile finds it!
1874 DEFVAR_PER_BUFFER ("mode-line-format", ¤t_buffer->mode_line_format,
1876 "Template for displaying mode line for current buffer.\n\
1877 Each buffer has its own value of this variable.\n\
1878 Value may be a string, a symbol or a list or cons cell.\n\
1879 For a symbol, its value is used (but it is ignored if t or nil).\n\
1880 A string appearing directly as the value of a symbol is processed verbatim\n\
1881 in that the %-constructs below are not recognized.\n\
1882 For a list whose car is a symbol, the symbol's value is taken,\n\
1883 and if that is non-nil, the cadr of the list is processed recursively.\n\
1884 Otherwise, the caddr of the list (if there is one) is processed.\n\
1885 For a list whose car is a string or list, each element is processed\n\
1886 recursively and the results are effectively concatenated.\n\
1887 For a list whose car is an integer, the cdr of the list is processed\n\
1888 and padded (if the number is positive) or truncated (if negative)\n\
1889 to the width specified by that number.\n\
1890 A string is printed verbatim in the mode line except for %-constructs:\n\
1891 (%-constructs are allowed when the string is the entire mode-line-format\n\
1892 or when it is found in a cons-cell or a list)\n\
1893 %b -- print buffer name. %f -- print visited file name.\n\
1894 %* -- print *, % or hyphen. %m -- print value of mode-name (obsolete).\n\
1895 %s -- print process status. %M -- print value of global-mode-string. (obs)\n\
1896 %p -- print percent of buffer above top of window, or top, bot or all.\n\
1897 %n -- print Narrow if appropriate.\n\
1898 %[ -- print one [ for each recursive editing level. %] similar.\n\
1899 %% -- print %. %- -- print infinitely many dashes.\n\
1900 Decimal digits after the % specify field width to which to pad.");
1903 DEFVAR_LISP_NOPRO ("default-major-mode", &buffer_defaults
.major_mode
,
1904 "*Major mode for new buffers. Defaults to `fundamental-mode'.\n\
1905 nil here means use current buffer's major mode.");
1907 DEFVAR_PER_BUFFER ("major-mode", ¤t_buffer
->major_mode
,
1908 make_number (Lisp_Symbol
),
1909 "Symbol for current buffer's major mode.");
1911 DEFVAR_PER_BUFFER ("mode-name", ¤t_buffer
->mode_name
,
1912 make_number (Lisp_String
),
1913 "Pretty name of current buffer's major mode (a string).");
1915 DEFVAR_PER_BUFFER ("abbrev-mode", ¤t_buffer
->abbrev_mode
, Qnil
,
1916 "Non-nil turns on automatic expansion of abbrevs as they are inserted.\n\
1917 Automatically becomes buffer-local when set in any fashion.");
1919 DEFVAR_PER_BUFFER ("case-fold-search", ¤t_buffer
->case_fold_search
,
1921 "*Non-nil if searches should ignore case.\n\
1922 Automatically becomes buffer-local when set in any fashion.");
1924 DEFVAR_PER_BUFFER ("fill-column", ¤t_buffer
->fill_column
,
1925 make_number (Lisp_Int
),
1926 "*Column beyond which automatic line-wrapping should happen.\n\
1927 Automatically becomes buffer-local when set in any fashion.");
1929 DEFVAR_PER_BUFFER ("left-margin", ¤t_buffer
->left_margin
,
1930 make_number (Lisp_Int
),
1931 "*Column for the default indent-line-function to indent to.\n\
1932 Linefeed indents to this column in Fundamental mode.\n\
1933 Automatically becomes buffer-local when set in any fashion.");
1935 DEFVAR_PER_BUFFER ("tab-width", ¤t_buffer
->tab_width
,
1936 make_number (Lisp_Int
),
1937 "*Distance between tab stops (for display of tab characters), in columns.\n\
1938 Automatically becomes buffer-local when set in any fashion.");
1940 DEFVAR_PER_BUFFER ("ctl-arrow", ¤t_buffer
->ctl_arrow
, Qnil
,
1941 "*Non-nil means display control chars with uparrow.\n\
1942 Nil means use backslash and octal digits.\n\
1943 Automatically becomes buffer-local when set in any fashion.\n\
1944 This variable does not apply to characters whose display is specified\n\
1945 in the current display table (if there is one).");
1947 DEFVAR_PER_BUFFER ("truncate-lines", ¤t_buffer
->truncate_lines
, Qnil
,
1948 "*Non-nil means do not display continuation lines;\n\
1949 give each line of text one screen line.\n\
1950 Automatically becomes buffer-local when set in any fashion.\n\
1952 Note that this is overridden by the variable\n\
1953 `truncate-partial-width-windows' if that variable is non-nil\n\
1954 and this buffer is not full-frame width.");
1956 DEFVAR_PER_BUFFER ("default-directory", ¤t_buffer
->directory
,
1957 make_number (Lisp_String
),
1958 "Name of default directory of current buffer. Should end with slash.\n\
1959 Each buffer has its own value of this variable.");
1961 DEFVAR_PER_BUFFER ("auto-fill-function", ¤t_buffer
->auto_fill_function
,
1963 "Function called (if non-nil) to perform auto-fill.\n\
1964 It is called after self-inserting a space at a column beyond `fill-column'.\n\
1965 Each buffer has its own value of this variable.\n\
1966 NOTE: This variable is not an ordinary hook;\n\
1967 It may not be a list of functions.");
1969 DEFVAR_PER_BUFFER ("buffer-file-name", ¤t_buffer
->filename
,
1970 make_number (Lisp_String
),
1971 "Name of file visited in current buffer, or nil if not visiting a file.\n\
1972 Each buffer has its own value of this variable.");
1974 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
1975 ¤t_buffer
->auto_save_file_name
,
1976 make_number (Lisp_String
),
1977 "Name of file for auto-saving current buffer,\n\
1978 or nil if buffer should not be auto-saved.\n\
1979 Each buffer has its own value of this variable.");
1981 DEFVAR_PER_BUFFER ("buffer-read-only", ¤t_buffer
->read_only
, Qnil
,
1982 "Non-nil if this buffer is read-only.\n\
1983 Each buffer has its own value of this variable.");
1985 DEFVAR_PER_BUFFER ("buffer-backed-up", ¤t_buffer
->backed_up
, Qnil
,
1986 "Non-nil if this buffer's file has been backed up.\n\
1987 Backing up is done before the first time the file is saved.\n\
1988 Each buffer has its own value of this variable.");
1990 DEFVAR_PER_BUFFER ("buffer-saved-size", ¤t_buffer
->save_length
,
1991 make_number (Lisp_Int
),
1992 "Length of current buffer when last read in, saved or auto-saved.\n\
1994 Each buffer has its own value of this variable.");
1996 DEFVAR_PER_BUFFER ("selective-display", ¤t_buffer
->selective_display
,
1998 "Non-nil enables selective display:\n\
1999 Integer N as value means display only lines\n\
2000 that start with less than n columns of space.\n\
2001 A value of t means, after a ^M, all the rest of the line is invisible.\n\
2002 Then ^M's in the file are written into files as newlines.\n\n\
2003 Automatically becomes buffer-local when set in any fashion.");
2006 DEFVAR_PER_BUFFER ("selective-display-ellipses",
2007 ¤t_buffer
->selective_display_ellipses
,
2009 "t means display ... on previous line when a line is invisible.\n\
2010 Automatically becomes buffer-local when set in any fashion.");
2013 DEFVAR_PER_BUFFER ("overwrite-mode", ¤t_buffer
->overwrite_mode
, Qnil
,
2014 "Non-nil if self-insertion should replace existing text.\n\
2015 If non-nil and not `overwrite-mode-binary', self-insertion still\n\
2016 inserts at the end of a line, and inserts when point is before a tab,\n\
2017 until the tab is filled in.\n\
2018 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too.\n\
2019 Automatically becomes buffer-local when set in any fashion.");
2021 DEFVAR_PER_BUFFER ("buffer-display-table", ¤t_buffer
->display_table
,
2023 "Display table that controls display of the contents of current buffer.\n\
2024 Automatically becomes buffer-local when set in any fashion.\n\
2025 The display table is a vector created with `make-display-table'.\n\
2026 The first 256 elements control how to display each possible text character.\n\
2027 The value should be a \"rope\" (see `make-rope') or nil;\n\
2028 nil means display the character in the default fashion.\n\
2029 The remaining five elements are ropes that control the display of\n\
2030 the end of a truncated screen line (element 256);\n\
2031 the end of a continued line (element 257);\n\
2032 the escape character used to display character codes in octal (element 258);\n\
2033 the character used as an arrow for control characters (element 259);\n\
2034 the decoration indicating the presence of invisible lines (element 260).\n\
2035 If this variable is nil, the value of `standard-display-table' is used.\n\
2036 Each window can have its own, overriding display table.");
2038 /*DEFVAR_LISP ("debug-check-symbol", &Vcheck_symbol,
2041 DEFVAR_LISP ("before-change-function", &Vbefore_change_function
,
2042 "Function to call before each text change.\n\
2043 Two arguments are passed to the function: the positions of\n\
2044 the beginning and end of the range of old text to be changed.\n\
2045 \(For an insertion, the beginning and end are at the same place.)\n\
2046 No information is given about the length of the text after the change.\n\
2047 position of the change\n\
2049 While executing the `before-change-function', changes to buffers do not\n\
2050 cause calls to any `before-change-function' or `after-change-function'.");
2051 Vbefore_change_function
= Qnil
;
2053 DEFVAR_LISP ("after-change-function", &Vafter_change_function
,
2054 "Function to call after each text change.\n\
2055 Three arguments are passed to the function: the positions of\n\
2056 the beginning and end of the range of changed text,\n\
2057 and the length of the pre-change text replaced by that range.\n\
2058 \(For an insertion, the pre-change length is zero;\n\
2059 for a deletion, that length is the number of characters deleted,\n\
2060 and the post-change beginning and end are at the same place.)\n\
2062 While executing the `after-change-function', changes to buffers do not\n\
2063 cause calls to any `before-change-function' or `after-change-function'.");
2064 Vafter_change_function
= Qnil
;
2066 DEFVAR_LISP ("first-change-hook", &Vfirst_change_hook
,
2067 "A list of functions to call before changing a buffer which is unmodified.\n\
2068 The functions are run using the `run-hooks' function.");
2069 Vfirst_change_hook
= Qnil
;
2070 Qfirst_change_hook
= intern ("first-change-hook");
2071 staticpro (&Qfirst_change_hook
);
2073 DEFVAR_PER_BUFFER ("buffer-undo-list", ¤t_buffer
->undo_list
, Qnil
,
2074 "List of undo entries in current buffer.\n\
2075 Recent changes come first; older changes follow newer.\n\
2077 An entry (START . END) represents an insertion which begins at\n\
2078 position START and ends at position END.\n\
2080 An entry (TEXT . POSITION) represents the deletion of the string TEXT\n\
2081 from (abs POSITION). If POSITION is positive, point was at the front\n\
2082 of the text being deleted; if negative, point was at the end.\n\
2084 An entry (t HIGHWORD LOWWORD) indicates that the buffer had been\n\
2085 previously unmodified. HIGHWORD and LOWWORD are the high and low\n\
2086 16-bit words of the buffer's modification count at the time. If the\n\
2087 modification count of the most recent save is different, this entry is\n\
2090 An entry (nil PROP VAL BEG . END) indicates that a text property\n\
2091 was modified between BEG and END. PROP is the property name,\n\
2092 and VAL is the old value.\n\
2094 An entry of the form POSITION indicates that point was at the buffer\n\
2095 location given by the integer. Undoing an entry of this form places\n\
2096 point at POSITION.\n\
2098 nil marks undo boundaries. The undo command treats the changes\n\
2099 between two undo boundaries as a single step to be undone.\n\
2101 If the value of the variable is t, undo information is not recorded.");
2103 DEFVAR_PER_BUFFER ("mark-active", ¤t_buffer
->mark_active
, Qnil
,
2104 "Non-nil means the mark and region are currently active in this buffer.\n\
2105 Automatically local in all buffers.");
2107 DEFVAR_LISP ("transient-mark-mode", &Vtransient_mark_mode
,
2108 "*Non-nil means deactivate the mark when the buffer contents change.");
2109 Vtransient_mark_mode
= Qnil
;
2111 defsubr (&Sbuffer_list
);
2112 defsubr (&Sget_buffer
);
2113 defsubr (&Sget_file_buffer
);
2114 defsubr (&Sget_buffer_create
);
2115 defsubr (&Sgenerate_new_buffer_name
);
2116 defsubr (&Sbuffer_name
);
2117 /*defsubr (&Sbuffer_number);*/
2118 defsubr (&Sbuffer_file_name
);
2119 defsubr (&Sbuffer_local_variables
);
2120 defsubr (&Sbuffer_modified_p
);
2121 defsubr (&Sset_buffer_modified_p
);
2122 defsubr (&Sbuffer_modified_tick
);
2123 defsubr (&Srename_buffer
);
2124 defsubr (&Sother_buffer
);
2125 defsubr (&Sbuffer_disable_undo
);
2126 defsubr (&Sbuffer_enable_undo
);
2127 defsubr (&Skill_buffer
);
2128 defsubr (&Serase_buffer
);
2129 defsubr (&Sswitch_to_buffer
);
2130 defsubr (&Spop_to_buffer
);
2131 defsubr (&Scurrent_buffer
);
2132 defsubr (&Sset_buffer
);
2133 defsubr (&Sbarf_if_buffer_read_only
);
2134 defsubr (&Sbury_buffer
);
2135 defsubr (&Slist_buffers
);
2136 defsubr (&Skill_all_local_variables
);
2138 defsubr (&Smake_overlay
);
2139 defsubr (&Sdelete_overlay
);
2140 defsubr (&Smove_overlay
);
2141 defsubr (&Soverlays_at
);
2142 defsubr (&Snext_overlay_change
);
2143 defsubr (&Soverlay_recenter
);
2144 defsubr (&Soverlay_lists
);
2145 defsubr (&Soverlay_get
);
2146 defsubr (&Soverlay_put
);
2151 initial_define_key (control_x_map
, 'b', "switch-to-buffer");
2152 initial_define_key (control_x_map
, 'k', "kill-buffer");
2153 initial_define_key (control_x_map
, Ctl ('B'), "list-buffers");