1 /* Buffer manipulation primitives for GNU Emacs.
2 Copyright (C) 1985, 1986, 1987, 1988, 1989, 1993, 1994
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"
37 #include "region-cache.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 ();
103 static void call_overlay_mod_hooks ();
105 /* Alist of all buffer names vs the buffers. */
106 /* This used to be a variable, but is no longer,
107 to prevent lossage due to user rplac'ing this alist or its elements. */
108 Lisp_Object Vbuffer_alist
;
110 /* Functions to call before and after each text change. */
111 Lisp_Object Vbefore_change_function
;
112 Lisp_Object Vafter_change_function
;
113 Lisp_Object Vbefore_change_functions
;
114 Lisp_Object Vafter_change_functions
;
116 Lisp_Object Vtransient_mark_mode
;
118 /* t means ignore all read-only text properties.
119 A list means ignore such a property if its value is a member of the list.
120 Any non-nil value means ignore buffer-read-only. */
121 Lisp_Object Vinhibit_read_only
;
123 /* List of functions to call that can query about killing a buffer.
124 If any of these functions returns nil, we don't kill it. */
125 Lisp_Object Vkill_buffer_query_functions
;
127 /* List of functions to call before changing an unmodified buffer. */
128 Lisp_Object Vfirst_change_hook
;
129 Lisp_Object Qfirst_change_hook
;
131 Lisp_Object Qfundamental_mode
, Qmode_class
, Qpermanent_local
;
133 Lisp_Object Qprotected_field
;
135 Lisp_Object QSFundamental
; /* A string "Fundamental" */
137 Lisp_Object Qkill_buffer_hook
;
139 Lisp_Object Qget_file_buffer
;
141 Lisp_Object Qoverlayp
;
143 Lisp_Object Qpriority
, Qwindow
, Qevaporate
;
145 Lisp_Object Qmodification_hooks
;
146 Lisp_Object Qinsert_in_front_hooks
;
147 Lisp_Object Qinsert_behind_hooks
;
149 /* For debugging; temporary. See set_buffer_internal. */
150 /* Lisp_Object Qlisp_mode, Vcheck_symbol; */
156 error ("No buffer named %s", XSTRING (spec
)->data
);
157 error ("Invalid buffer argument");
160 DEFUN ("buffer-list", Fbuffer_list
, Sbuffer_list
, 0, 0, 0,
161 "Return a list of all existing live buffers.")
164 return Fmapcar (Qcdr
, Vbuffer_alist
);
167 DEFUN ("get-buffer", Fget_buffer
, Sget_buffer
, 1, 1, 0,
168 "Return the buffer named NAME (a string).\n\
169 If there is no live buffer named NAME, return nil.\n\
170 NAME may also be a buffer; if so, the value is that buffer.")
172 register Lisp_Object name
;
176 CHECK_STRING (name
, 0);
178 return Fcdr (Fassoc (name
, Vbuffer_alist
));
181 DEFUN ("get-file-buffer", Fget_file_buffer
, Sget_file_buffer
, 1, 1, 0,
182 "Return the buffer visiting file FILENAME (a string).\n\
183 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.\n\
184 If there is no such live buffer, return nil.\n\
185 See also `find-buffer-visiting'.")
187 register Lisp_Object filename
;
189 register Lisp_Object tail
, buf
, tem
;
192 CHECK_STRING (filename
, 0);
193 filename
= Fexpand_file_name (filename
, Qnil
);
195 /* If the file name has special constructs in it,
196 call the corresponding file handler. */
197 handler
= Ffind_file_name_handler (filename
, Qget_file_buffer
);
199 return call2 (handler
, Qget_file_buffer
, filename
);
201 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
203 buf
= Fcdr (XCONS (tail
)->car
);
204 if (!BUFFERP (buf
)) continue;
205 if (!STRINGP (XBUFFER (buf
)->filename
)) continue;
206 tem
= Fstring_equal (XBUFFER (buf
)->filename
, filename
);
213 /* Incremented for each buffer created, to assign the buffer number. */
216 DEFUN ("get-buffer-create", Fget_buffer_create
, Sget_buffer_create
, 1, 1, 0,
217 "Return the buffer named NAME, or create such a buffer and return it.\n\
218 A new buffer is created if there is no live buffer named NAME.\n\
219 If NAME starts with a space, the new buffer does not keep undo information.\n\
220 If NAME is a buffer instead of a string, then it is the value returned.\n\
221 The value is never nil.")
223 register Lisp_Object name
;
225 register Lisp_Object buf
, function
, tem
;
226 int count
= specpdl_ptr
- specpdl
;
227 register struct buffer
*b
;
229 buf
= Fget_buffer (name
);
233 if (XSTRING (name
)->size
== 0)
234 error ("Empty string for buffer name is not allowed");
236 b
= (struct buffer
*) xmalloc (sizeof (struct buffer
));
238 BUF_GAP_SIZE (b
) = 20;
240 BUFFER_ALLOC (BUF_BEG_ADDR (b
), BUF_GAP_SIZE (b
));
242 if (! BUF_BEG_ADDR (b
))
252 b
->newline_cache
= 0;
253 b
->width_run_cache
= 0;
254 b
->width_table
= Qnil
;
256 /* Put this on the chain of all buffers including killed ones. */
257 b
->next
= all_buffers
;
260 b
->mark
= Fmake_marker ();
261 /*b->number = make_number (++buffer_count);*/
263 if (XSTRING (name
)->data
[0] != ' ')
269 reset_buffer_local_variables (b
);
271 /* Put this in the alist of all live buffers. */
273 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buf
), Qnil
));
275 b
->mark
= Fmake_marker ();
279 function
= buffer_defaults
.major_mode
;
282 tem
= Fget (current_buffer
->major_mode
, Qmode_class
);
284 function
= current_buffer
->major_mode
;
287 if (NILP (function
) || EQ (function
, Qfundamental_mode
))
290 /* To select a nonfundamental mode,
291 select the buffer temporarily and then call the mode function. */
293 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
298 return unbind_to (count
, buf
);
301 /* Reinitialize everything about a buffer except its name and contents
302 and local variables. */
306 register struct buffer
*b
;
309 b
->directory
= (current_buffer
) ? current_buffer
->directory
: Qnil
;
311 b
->save_modified
= 1;
312 XSETFASTINT (b
->save_length
, 0);
313 b
->last_window_start
= 1;
315 b
->auto_save_modified
= 0;
316 b
->auto_save_failure_time
= -1;
317 b
->auto_save_file_name
= Qnil
;
319 b
->overlays_before
= Qnil
;
320 b
->overlays_after
= Qnil
;
321 XSETFASTINT (b
->overlay_center
, 1);
322 b
->mark_active
= Qnil
;
324 /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
325 INITIALIZE_INTERVAL (b
, NULL_INTERVAL
);
328 /* Reset buffer B's local variables info.
329 Don't use this on a buffer that has already been in use;
330 it does not treat permanent locals consistently.
331 Instead, use Fkill_all_local_variables. */
333 reset_buffer_local_variables (b
)
334 register struct buffer
*b
;
338 /* Reset the major mode to Fundamental, together with all the
339 things that depend on the major mode.
340 default-major-mode is handled at a higher level.
341 We ignore it here. */
342 b
->major_mode
= Qfundamental_mode
;
344 b
->abbrev_table
= Vfundamental_mode_abbrev_table
;
345 b
->mode_name
= QSFundamental
;
346 b
->minor_modes
= Qnil
;
347 b
->downcase_table
= Vascii_downcase_table
;
348 b
->upcase_table
= Vascii_upcase_table
;
349 b
->case_canon_table
= Vascii_canon_table
;
350 b
->case_eqv_table
= Vascii_eqv_table
;
352 b
->sort_table
= XSTRING (Vascii_sort_table
);
353 b
->folding_sort_table
= XSTRING (Vascii_folding_sort_table
);
356 /* Reset all per-buffer variables to their defaults. */
357 b
->local_var_alist
= Qnil
;
358 b
->local_var_flags
= 0;
360 /* For each slot that has a default value,
361 copy that into the slot. */
363 for (offset
= (char *)&buffer_local_flags
.name
- (char *)&buffer_local_flags
;
364 offset
< sizeof (struct buffer
);
365 offset
+= sizeof (Lisp_Object
)) /* sizeof EMACS_INT == sizeof Lisp_Object */
367 int flag
= XINT (*(Lisp_Object
*)(offset
+ (char *)&buffer_local_flags
));
368 if (flag
> 0 || flag
== -2)
369 *(Lisp_Object
*)(offset
+ (char *)b
) =
370 *(Lisp_Object
*)(offset
+ (char *)&buffer_defaults
);
374 /* We split this away from generate-new-buffer, because rename-buffer
375 and set-visited-file-name ought to be able to use this to really
376 rename the buffer properly. */
378 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name
, Sgenerate_new_buffer_name
,
380 "Return a string that is the name of no existing buffer based on NAME.\n\
381 If there is no live buffer named NAME, then return NAME.\n\
382 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER\n\
383 until an unused name is found, and then return that name.\n\
384 Optional second argument IGNORE specifies a name that is okay to use\n\
385 \(if it is in the sequence to be tried)\n\
386 even if a buffer with that name exists.")
388 register Lisp_Object name
, ignore
;
390 register Lisp_Object gentemp
, tem
;
394 CHECK_STRING (name
, 0);
396 tem
= Fget_buffer (name
);
403 sprintf (number
, "<%d>", ++count
);
404 gentemp
= concat2 (name
, build_string (number
));
405 tem
= Fstring_equal (gentemp
, ignore
);
408 tem
= Fget_buffer (gentemp
);
415 DEFUN ("buffer-name", Fbuffer_name
, Sbuffer_name
, 0, 1, 0,
416 "Return the name of BUFFER, as a string.\n\
417 With no argument or nil as argument, return the name of the current buffer.")
419 register Lisp_Object buffer
;
422 return current_buffer
->name
;
423 CHECK_BUFFER (buffer
, 0);
424 return XBUFFER (buffer
)->name
;
427 DEFUN ("buffer-file-name", Fbuffer_file_name
, Sbuffer_file_name
, 0, 1, 0,
428 "Return name of file BUFFER is visiting, or nil if none.\n\
429 No argument or nil as argument means use the current buffer.")
431 register Lisp_Object buffer
;
434 return current_buffer
->filename
;
435 CHECK_BUFFER (buffer
, 0);
436 return XBUFFER (buffer
)->filename
;
439 DEFUN ("buffer-local-variables", Fbuffer_local_variables
,
440 Sbuffer_local_variables
, 0, 1, 0,
441 "Return an alist of variables that are buffer-local in BUFFER.\n\
442 Most elements look like (SYMBOL . VALUE), describing one variable.\n\
443 For a symbol that is locally unbound, just the symbol appears in the value.\n\
444 Note that storing new VALUEs in these elements doesn't change the variables.\n\
445 No argument or nil as argument means use current buffer as BUFFER.")
447 register Lisp_Object buffer
;
449 register struct buffer
*buf
;
450 register Lisp_Object result
;
453 buf
= current_buffer
;
456 CHECK_BUFFER (buffer
, 0);
457 buf
= XBUFFER (buffer
);
463 /* Reference each variable in the alist in our current buffer.
464 If inquiring about the current buffer, this gets the current values,
465 so store them into the alist so the alist is up to date.
466 If inquiring about some other buffer, this swaps out any values
467 for that buffer, making the alist up to date automatically. */
468 register Lisp_Object tail
;
469 for (tail
= buf
->local_var_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
471 Lisp_Object val
, elt
;
473 elt
= XCONS (tail
)->car
;
475 if (buf
== current_buffer
)
476 val
= find_symbol_value (XCONS (elt
)->car
);
478 val
= XCONS (elt
)->cdr
;
480 /* If symbol is unbound, put just the symbol in the list. */
481 if (EQ (val
, Qunbound
))
482 result
= Fcons (XCONS (elt
)->car
, result
);
483 /* Otherwise, put (symbol . value) in the list. */
485 result
= Fcons (Fcons (XCONS (elt
)->car
, val
), result
);
489 /* Add on all the variables stored in special slots. */
491 register int offset
, mask
;
493 for (offset
= (char *)&buffer_local_symbols
.name
- (char *)&buffer_local_symbols
;
494 offset
< sizeof (struct buffer
);
495 offset
+= (sizeof (EMACS_INT
))) /* sizeof EMACS_INT == sizeof Lisp_Object */
497 mask
= XINT (*(Lisp_Object
*)(offset
+ (char *)&buffer_local_flags
));
498 if (mask
== -1 || (buf
->local_var_flags
& mask
))
499 if (SYMBOLP (*(Lisp_Object
*)(offset
500 + (char *)&buffer_local_symbols
)))
501 result
= Fcons (Fcons (*((Lisp_Object
*)
502 (offset
+ (char *)&buffer_local_symbols
)),
503 *(Lisp_Object
*)(offset
+ (char *)buf
)),
512 DEFUN ("buffer-modified-p", Fbuffer_modified_p
, Sbuffer_modified_p
,
514 "Return t if BUFFER was modified since its file was last read or saved.\n\
515 No argument or nil as argument means use current buffer as BUFFER.")
517 register Lisp_Object buffer
;
519 register struct buffer
*buf
;
521 buf
= current_buffer
;
524 CHECK_BUFFER (buffer
, 0);
525 buf
= XBUFFER (buffer
);
528 return buf
->save_modified
< BUF_MODIFF (buf
) ? Qt
: Qnil
;
531 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p
, Sset_buffer_modified_p
,
533 "Mark current buffer as modified or unmodified according to FLAG.\n\
534 A non-nil FLAG means mark the buffer modified.")
536 register Lisp_Object flag
;
538 register int already
;
539 register Lisp_Object fn
;
541 #ifdef CLASH_DETECTION
542 /* If buffer becoming modified, lock the file.
543 If buffer becoming unmodified, unlock the file. */
545 fn
= current_buffer
->filename
;
548 already
= current_buffer
->save_modified
< MODIFF
;
549 if (!already
&& !NILP (flag
))
551 else if (already
&& NILP (flag
))
554 #endif /* CLASH_DETECTION */
556 current_buffer
->save_modified
= NILP (flag
) ? MODIFF
: 0;
561 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick
, Sbuffer_modified_tick
,
563 "Return BUFFER's tick counter, incremented for each change in text.\n\
564 Each buffer has a tick counter which is incremented each time the text in\n\
565 that buffer is changed. It wraps around occasionally.\n\
566 No argument or nil as argument means use current buffer as BUFFER.")
568 register Lisp_Object buffer
;
570 register struct buffer
*buf
;
572 buf
= current_buffer
;
575 CHECK_BUFFER (buffer
, 0);
576 buf
= XBUFFER (buffer
);
579 return make_number (BUF_MODIFF (buf
));
582 DEFUN ("rename-buffer", Frename_buffer
, Srename_buffer
, 1, 2,
583 "sRename buffer (to new name): \nP",
584 "Change current buffer's name to NEWNAME (a string).\n\
585 If second arg UNIQUE is nil or omitted, it is an error if a\n\
586 buffer named NEWNAME already exists.\n\
587 If UNIQUE is non-nil, come up with a new name using\n\
588 `generate-new-buffer-name'.\n\
589 Interactively, you can set UNIQUE with a prefix argument.\n\
590 We return the name we actually gave the buffer.\n\
591 This does not change the name of the visited file (if any).")
593 register Lisp_Object name
, unique
;
595 register Lisp_Object tem
, buf
;
597 CHECK_STRING (name
, 0);
599 if (XSTRING (name
)->size
== 0)
600 error ("Empty string is invalid as a buffer name");
602 tem
= Fget_buffer (name
);
603 /* Don't short-circuit if UNIQUE is t. That is a useful way to rename
604 the buffer automatically so you can create another with the original name.
605 It makes UNIQUE equivalent to
606 (rename-buffer (generate-new-buffer-name NAME)). */
607 if (NILP (unique
) && XBUFFER (tem
) == current_buffer
)
608 return current_buffer
->name
;
612 name
= Fgenerate_new_buffer_name (name
, current_buffer
->name
);
614 error ("Buffer name \"%s\" is in use", XSTRING (name
)->data
);
617 current_buffer
->name
= name
;
619 /* Catch redisplay's attention. Unless we do this, the mode lines for
620 any windows displaying current_buffer will stay unchanged. */
623 XSETBUFFER (buf
, current_buffer
);
624 Fsetcar (Frassq (buf
, Vbuffer_alist
), name
);
625 if (NILP (current_buffer
->filename
)
626 && !NILP (current_buffer
->auto_save_file_name
))
627 call0 (intern ("rename-auto-save-file"));
628 /* refetch since that last call may have done GC */
629 return current_buffer
->name
;
632 DEFUN ("other-buffer", Fother_buffer
, Sother_buffer
, 0, 2, 0,
633 "Return most recently selected buffer other than BUFFER.\n\
634 Buffers not visible in windows are preferred to visible buffers,\n\
635 unless optional second argument VISIBLE-OK is non-nil.\n\
636 If no other buffer exists, the buffer `*scratch*' is returned.\n\
637 If BUFFER is omitted or nil, some interesting buffer is returned.")
639 register Lisp_Object buffer
, visible_ok
;
641 register Lisp_Object tail
, buf
, notsogood
, tem
;
644 for (tail
= Vbuffer_alist
; !NILP (tail
); tail
= Fcdr (tail
))
646 buf
= Fcdr (Fcar (tail
));
647 if (EQ (buf
, buffer
))
649 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
651 if (NILP (visible_ok
))
652 tem
= Fget_buffer_window (buf
, Qt
);
657 if (NILP (notsogood
))
660 if (!NILP (notsogood
))
662 return Fget_buffer_create (build_string ("*scratch*"));
665 DEFUN ("buffer-disable-undo", Fbuffer_disable_undo
, Sbuffer_disable_undo
, 0, 1,
667 "Make BUFFER stop keeping undo information.\n\
668 No argument or nil as argument means do this for the current buffer.")
670 register Lisp_Object buffer
;
672 Lisp_Object real_buffer
;
675 XSETBUFFER (real_buffer
, current_buffer
);
678 real_buffer
= Fget_buffer (buffer
);
679 if (NILP (real_buffer
))
683 XBUFFER (real_buffer
)->undo_list
= Qt
;
688 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo
, Sbuffer_enable_undo
,
690 "Start keeping undo information for buffer BUFFER.\n\
691 No argument or nil as argument means do this for the current buffer.")
693 register Lisp_Object buffer
;
695 Lisp_Object real_buffer
;
698 XSETBUFFER (real_buffer
, current_buffer
);
701 real_buffer
= Fget_buffer (buffer
);
702 if (NILP (real_buffer
))
706 if (EQ (XBUFFER (real_buffer
)->undo_list
, Qt
))
707 XBUFFER (real_buffer
)->undo_list
= Qnil
;
713 DEFVAR_LISP ("kill-buffer-hook", no_cell, "\
714 Hook to be run (by `run-hooks', which see) when a buffer is killed.\n\
715 The buffer being killed will be current while the hook is running.\n\
718 DEFUN ("kill-buffer", Fkill_buffer
, Skill_buffer
, 1, 1, "bKill buffer: ",
719 "Kill the buffer BUFFER.\n\
720 The argument may be a buffer or may be the name of a buffer.\n\
721 An argument of nil means kill the current buffer.\n\n\
722 Value is t if the buffer is actually killed, nil if user says no.\n\n\
723 The value of `kill-buffer-hook' (which may be local to that buffer),\n\
724 if not void, is a list of functions to be called, with no arguments,\n\
725 before the buffer is actually killed. The buffer to be killed is current\n\
726 when the hook functions are called.\n\n\
727 Any processes that have this buffer as the `process-buffer' are killed\n\
728 with `delete-process'.")
733 register struct buffer
*b
;
734 register Lisp_Object tem
;
735 register struct Lisp_Marker
*m
;
736 struct gcpro gcpro1
, gcpro2
;
739 buf
= Fcurrent_buffer ();
741 buf
= Fget_buffer (bufname
);
747 /* Query if the buffer is still modified. */
748 if (INTERACTIVE
&& !NILP (b
->filename
)
749 && BUF_MODIFF (b
) > b
->save_modified
)
751 GCPRO2 (buf
, bufname
);
752 tem
= do_yes_or_no_p (format1 ("Buffer %s modified; kill anyway? ",
753 XSTRING (b
->name
)->data
));
759 /* Run hooks with the buffer to be killed the current buffer. */
761 register Lisp_Object val
;
762 int count
= specpdl_ptr
- specpdl
;
765 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
766 set_buffer_internal (b
);
768 /* First run the query functions; if any query is answered no,
769 don't kill the buffer. */
770 for (list
= Vkill_buffer_query_functions
; !NILP (list
); list
= Fcdr (list
))
772 tem
= call0 (Fcar (list
));
774 return unbind_to (count
, Qnil
);
777 /* Then run the hooks. */
778 if (!NILP (Vrun_hooks
))
779 call1 (Vrun_hooks
, Qkill_buffer_hook
);
780 unbind_to (count
, Qnil
);
783 /* We have no more questions to ask. Verify that it is valid
784 to kill the buffer. This must be done after the questions
785 since anything can happen within do_yes_or_no_p. */
787 /* Don't kill the minibuffer now current. */
788 if (EQ (buf
, XWINDOW (minibuf_window
)->buffer
))
794 /* Make this buffer not be current.
795 In the process, notice if this is the sole visible buffer
796 and give up if so. */
797 if (b
== current_buffer
)
799 tem
= Fother_buffer (buf
, Qnil
);
801 if (b
== current_buffer
)
805 /* Now there is no question: we can kill the buffer. */
807 #ifdef CLASH_DETECTION
808 /* Unlock this buffer's file, if it is locked. */
810 #endif /* CLASH_DETECTION */
812 kill_buffer_processes (buf
);
816 Vbuffer_alist
= Fdelq (Frassq (buf
, Vbuffer_alist
), Vbuffer_alist
);
817 Freplace_buffer_in_windows (buf
);
820 /* Delete any auto-save file, if we saved it in this session. */
821 if (STRINGP (b
->auto_save_file_name
)
822 && b
->auto_save_modified
!= 0)
825 tem
= Fsymbol_value (intern ("delete-auto-save-files"));
827 unlink (XSTRING (b
->auto_save_file_name
)->data
);
830 /* Unchain all markers of this buffer
831 and leave them pointing nowhere. */
832 for (tem
= b
->markers
; !EQ (tem
, Qnil
); )
841 /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
842 INITIALIZE_INTERVAL (b
, NULL_INTERVAL
);
843 /* Perhaps we should explicitly free the interval tree here... */
847 BUFFER_FREE (BUF_BEG_ADDR (b
));
848 if (b
->newline_cache
)
850 free_region_cache (b
->newline_cache
);
851 b
->newline_cache
= 0;
853 if (b
->width_run_cache
)
855 free_region_cache (b
->width_run_cache
);
856 b
->width_run_cache
= 0;
858 b
->width_table
= Qnil
;
865 /* Move the assoc for buffer BUF to the front of buffer-alist. Since
866 we do this each time BUF is selected visibly, the more recently
867 selected buffers are always closer to the front of the list. This
868 means that other_buffer is more likely to choose a relevant buffer. */
873 register Lisp_Object link
, prev
;
876 for (link
= Vbuffer_alist
; CONSP (link
); link
= XCONS (link
)->cdr
)
878 if (EQ (XCONS (XCONS (link
)->car
)->cdr
, buf
))
883 /* Effectively do Vbuffer_alist = Fdelq (link, Vbuffer_alist);
884 we cannot use Fdelq itself here because it allows quitting. */
887 Vbuffer_alist
= XCONS (Vbuffer_alist
)->cdr
;
889 XCONS (prev
)->cdr
= XCONS (XCONS (prev
)->cdr
)->cdr
;
891 XCONS(link
)->cdr
= Vbuffer_alist
;
892 Vbuffer_alist
= link
;
895 DEFUN ("switch-to-buffer", Fswitch_to_buffer
, Sswitch_to_buffer
, 1, 2, "BSwitch to buffer: ",
896 "Select buffer BUFFER in the current window.\n\
897 BUFFER may be a buffer or a buffer name.\n\
898 Optional second arg NORECORD non-nil means\n\
899 do not put this buffer at the front of the list of recently selected ones.\n\
901 WARNING: This is NOT the way to work on another buffer temporarily\n\
902 within a Lisp program! Use `set-buffer' instead. That avoids messing with\n\
903 the window-buffer correspondences.")
905 Lisp_Object bufname
, norecord
;
907 register Lisp_Object buf
;
910 if (EQ (minibuf_window
, selected_window
))
911 error ("Cannot switch buffers in minibuffer window");
912 tem
= Fwindow_dedicated_p (selected_window
);
914 error ("Cannot switch buffers in a dedicated window");
917 buf
= Fother_buffer (Fcurrent_buffer (), Qnil
);
919 buf
= Fget_buffer_create (bufname
);
924 Fset_window_buffer (EQ (selected_window
, minibuf_window
)
925 ? Fnext_window (minibuf_window
, Qnil
, Qnil
)
932 DEFUN ("pop-to-buffer", Fpop_to_buffer
, Spop_to_buffer
, 1, 2, 0,
933 "Select buffer BUFFER in some window, preferably a different one.\n\
934 If BUFFER is nil, then some other buffer is chosen.\n\
935 If `pop-up-windows' is non-nil, windows can be split to do this.\n\
936 If optional second arg OTHER-WINDOW is non-nil, insist on finding another\n\
937 window even if BUFFER is already visible in the selected window.")
939 Lisp_Object bufname
, other
;
941 register Lisp_Object buf
;
943 buf
= Fother_buffer (Fcurrent_buffer (), Qnil
);
945 buf
= Fget_buffer_create (bufname
);
948 Fselect_window (Fdisplay_buffer (buf
, other
));
952 DEFUN ("current-buffer", Fcurrent_buffer
, Scurrent_buffer
, 0, 0, 0,
953 "Return the current buffer as a Lisp object.")
956 register Lisp_Object buf
;
957 XSETBUFFER (buf
, current_buffer
);
961 /* Set the current buffer to b */
964 set_buffer_internal (b
)
965 register struct buffer
*b
;
967 register struct buffer
*old_buf
;
968 register Lisp_Object tail
, valcontents
;
971 if (current_buffer
== b
)
974 windows_or_buffers_changed
= 1;
975 old_buf
= current_buffer
;
977 last_known_column_point
= -1; /* invalidate indentation cache */
979 /* Look down buffer's list of local Lisp variables
980 to find and update any that forward into C variables. */
982 for (tail
= b
->local_var_alist
; !NILP (tail
); tail
= XCONS (tail
)->cdr
)
984 valcontents
= XSYMBOL (XCONS (XCONS (tail
)->car
)->car
)->value
;
985 if ((BUFFER_LOCAL_VALUEP (valcontents
)
986 || SOME_BUFFER_LOCAL_VALUEP (valcontents
))
987 && (tem
= XCONS (valcontents
)->car
,
988 (BOOLFWDP (tem
) || INTFWDP (tem
) || OBJFWDP (tem
))))
989 /* Just reference the variable
990 to cause it to become set for this buffer. */
991 Fsymbol_value (XCONS (XCONS (tail
)->car
)->car
);
994 /* Do the same with any others that were local to the previous buffer */
997 for (tail
= old_buf
->local_var_alist
; !NILP (tail
); tail
= XCONS (tail
)->cdr
)
999 valcontents
= XSYMBOL (XCONS (XCONS (tail
)->car
)->car
)->value
;
1000 if ((BUFFER_LOCAL_VALUEP (valcontents
)
1001 || SOME_BUFFER_LOCAL_VALUEP (valcontents
))
1002 && (tem
= XCONS (valcontents
)->car
,
1003 (BOOLFWDP (tem
) || INTFWDP (tem
) || OBJFWDP (tem
))))
1004 /* Just reference the variable
1005 to cause it to become set for this buffer. */
1006 Fsymbol_value (XCONS (XCONS (tail
)->car
)->car
);
1010 DEFUN ("set-buffer", Fset_buffer
, Sset_buffer
, 1, 1, 0,
1011 "Make the buffer BUFFER current for editing operations.\n\
1012 BUFFER may be a buffer or the name of an existing buffer.\n\
1013 See also `save-excursion' when you want to make a buffer current temporarily.\n\
1014 This function does not display the buffer, so its effect ends\n\
1015 when the current command terminates.\n\
1016 Use `switch-to-buffer' or `pop-to-buffer' to switch buffers permanently.")
1018 register Lisp_Object bufname
;
1020 register Lisp_Object buffer
;
1021 buffer
= Fget_buffer (bufname
);
1024 if (NILP (XBUFFER (buffer
)->name
))
1025 error ("Selecting deleted buffer");
1026 set_buffer_internal (XBUFFER (buffer
));
1030 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only
,
1031 Sbarf_if_buffer_read_only
, 0, 0, 0,
1032 "Signal a `buffer-read-only' error if the current buffer is read-only.")
1035 if (!NILP (current_buffer
->read_only
)
1036 && NILP (Vinhibit_read_only
))
1037 Fsignal (Qbuffer_read_only
, (Fcons (Fcurrent_buffer (), Qnil
)));
1041 DEFUN ("bury-buffer", Fbury_buffer
, Sbury_buffer
, 0, 1, "",
1042 "Put BUFFER at the end of the list of all buffers.\n\
1043 There it is the least likely candidate for `other-buffer' to return;\n\
1044 thus, the least likely buffer for \\[switch-to-buffer] to select by default.\n\
1045 If BUFFER is nil or omitted, bury the current buffer.\n\
1046 Also, if BUFFER is nil or omitted, remove the current buffer from the\n\
1047 selected window if it is displayed there.")
1049 register Lisp_Object buf
;
1051 /* Figure out what buffer we're going to bury. */
1054 XSETBUFFER (buf
, current_buffer
);
1056 /* If we're burying the current buffer, unshow it. */
1057 Fswitch_to_buffer (Fother_buffer (buf
, Qnil
), Qnil
);
1063 buf1
= Fget_buffer (buf
);
1069 /* Move buf to the end of the buffer list. */
1071 register Lisp_Object aelt
, link
;
1073 aelt
= Frassq (buf
, Vbuffer_alist
);
1074 link
= Fmemq (aelt
, Vbuffer_alist
);
1075 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
1076 XCONS (link
)->cdr
= Qnil
;
1077 Vbuffer_alist
= nconc2 (Vbuffer_alist
, link
);
1083 DEFUN ("erase-buffer", Ferase_buffer
, Serase_buffer
, 0, 0, "*",
1084 "Delete the entire contents of the current buffer.\n\
1085 Any narrowing restriction in effect (see `narrow-to-region') is removed,\n\
1086 so the buffer is truly empty after this.")
1091 current_buffer
->last_window_start
= 1;
1092 /* Prevent warnings, or suspension of auto saving, that would happen
1093 if future size is less than past size. Use of erase-buffer
1094 implies that the future text is not really related to the past text. */
1095 XSETFASTINT (current_buffer
->save_length
, 0);
1099 validate_region (b
, e
)
1100 register Lisp_Object
*b
, *e
;
1102 CHECK_NUMBER_COERCE_MARKER (*b
, 0);
1103 CHECK_NUMBER_COERCE_MARKER (*e
, 1);
1105 if (XINT (*b
) > XINT (*e
))
1108 tem
= *b
; *b
= *e
; *e
= tem
;
1111 if (!(BEGV
<= XINT (*b
) && XINT (*b
) <= XINT (*e
)
1112 && XINT (*e
) <= ZV
))
1113 args_out_of_range (*b
, *e
);
1117 list_buffers_1 (files
)
1120 register Lisp_Object tail
, tem
, buf
;
1121 Lisp_Object col1
, col2
, col3
, minspace
;
1122 register struct buffer
*old
= current_buffer
, *b
;
1123 Lisp_Object desired_point
;
1124 Lisp_Object other_file_symbol
;
1126 desired_point
= Qnil
;
1127 other_file_symbol
= intern ("list-buffers-directory");
1129 XSETFASTINT (col1
, 19);
1130 XSETFASTINT (col2
, 26);
1131 XSETFASTINT (col3
, 40);
1132 XSETFASTINT (minspace
, 1);
1134 Fset_buffer (Vstandard_output
);
1135 Fbuffer_disable_undo (Vstandard_output
);
1136 current_buffer
->read_only
= Qnil
;
1139 MR Buffer Size Mode File\n\
1140 -- ------ ---- ---- ----\n", -1);
1142 for (tail
= Vbuffer_alist
; !NILP (tail
); tail
= Fcdr (tail
))
1144 buf
= Fcdr (Fcar (tail
));
1146 /* Don't mention the minibuffers. */
1147 if (XSTRING (b
->name
)->data
[0] == ' ')
1149 /* Optionally don't mention buffers that lack files. */
1150 if (!NILP (files
) && NILP (b
->filename
))
1152 /* Identify the current buffer. */
1154 XSETFASTINT (desired_point
, point
);
1155 write_string (b
== old
? "." : " ", -1);
1156 /* Identify modified buffers */
1157 write_string (BUF_MODIFF (b
) > b
->save_modified
? "*" : " ", -1);
1158 write_string (NILP (b
->read_only
) ? " " : "% ", -1);
1159 Fprinc (b
->name
, Qnil
);
1160 Findent_to (col1
, make_number (2));
1161 XSETFASTINT (tem
, BUF_Z (b
) - BUF_BEG (b
));
1163 Findent_to (col2
, minspace
);
1164 Fprinc (b
->mode_name
, Qnil
);
1165 Findent_to (col3
, minspace
);
1167 if (!NILP (b
->filename
))
1168 Fprinc (b
->filename
, Qnil
);
1171 /* No visited file; check local value of list-buffers-directory. */
1173 set_buffer_internal (b
);
1174 tem
= Fboundp (other_file_symbol
);
1177 tem
= Fsymbol_value (other_file_symbol
);
1178 Fset_buffer (Vstandard_output
);
1183 Fset_buffer (Vstandard_output
);
1185 write_string ("\n", -1);
1188 tail
= intern ("Buffer-menu-mode");
1189 if ((tem
= Ffboundp (tail
), !NILP (tem
)))
1191 set_buffer_internal (old
);
1192 return desired_point
;
1195 DEFUN ("list-buffers", Flist_buffers
, Slist_buffers
, 0, 1, "P",
1196 "Display a list of names of existing buffers.\n\
1197 The list is displayed in a buffer named `*Buffer List*'.\n\
1198 Note that buffers with names starting with spaces are omitted.\n\
1199 Non-null optional arg FILES-ONLY means mention only file buffers.\n\
1201 The M column contains a * for buffers that are modified.\n\
1202 The R column contains a % for buffers that are read-only.")
1206 Lisp_Object desired_point
;
1209 = internal_with_output_to_temp_buffer ("*Buffer List*",
1210 list_buffers_1
, files
);
1212 if (NUMBERP (desired_point
))
1214 int count
= specpdl_ptr
- specpdl
;
1215 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
1216 Fset_buffer (build_string ("*Buffer List*"));
1217 SET_PT (XINT (desired_point
));
1218 return unbind_to (count
, Qnil
);
1223 DEFUN ("kill-all-local-variables", Fkill_all_local_variables
, Skill_all_local_variables
,
1225 "Switch to Fundamental mode by killing current buffer's local variables.\n\
1226 Most local variable bindings are eliminated so that the default values\n\
1227 become effective once more. Also, the syntax table is set from\n\
1228 `standard-syntax-table', the local keymap is set to nil,\n\
1229 and the abbrev table from `fundamental-mode-abbrev-table'.\n\
1230 This function also forces redisplay of the mode line.\n\
1232 Every function to select a new major mode starts by\n\
1233 calling this function.\n\n\
1234 As a special exception, local variables whose names have\n\
1235 a non-nil `permanent-local' property are not eliminated by this function.\n\
1237 The first thing this function does is run\n\
1238 the normal hook `change-major-mode-hook'.")
1241 register Lisp_Object alist
, sym
, tem
;
1244 if (!NILP (Vrun_hooks
))
1245 call1 (Vrun_hooks
, intern ("change-major-mode-hook"));
1246 oalist
= current_buffer
->local_var_alist
;
1248 /* Make sure no local variables remain set up with this buffer
1249 for their current values. */
1251 for (alist
= oalist
; !NILP (alist
); alist
= XCONS (alist
)->cdr
)
1253 sym
= XCONS (XCONS (alist
)->car
)->car
;
1255 /* Need not do anything if some other buffer's binding is now encached. */
1256 tem
= XCONS (XCONS (XSYMBOL (sym
)->value
)->cdr
)->car
;
1257 if (XBUFFER (tem
) == current_buffer
)
1259 /* Symbol is set up for this buffer's old local value.
1260 Set it up for the current buffer with the default value. */
1262 tem
= XCONS (XCONS (XSYMBOL (sym
)->value
)->cdr
)->cdr
;
1263 /* Store the symbol's current value into the alist entry
1264 it is currently set up for. This is so that, if the
1265 local is marked permanent, and we make it local again below,
1266 we don't lose the value. */
1267 XCONS (XCONS (tem
)->car
)->cdr
1268 = do_symval_forwarding (XCONS (XSYMBOL (sym
)->value
)->car
);
1269 /* Switch to the symbol's default-value alist entry. */
1270 XCONS (tem
)->car
= tem
;
1271 /* Mark it as current for the current buffer. */
1272 XCONS (XCONS (XSYMBOL (sym
)->value
)->cdr
)->car
= Fcurrent_buffer ();
1273 /* Store the current value into any forwarding in the symbol. */
1274 store_symval_forwarding (sym
, XCONS (XSYMBOL (sym
)->value
)->car
,
1279 /* Actually eliminate all local bindings of this buffer. */
1281 reset_buffer_local_variables (current_buffer
);
1283 /* Redisplay mode lines; we are changing major mode. */
1285 update_mode_lines
++;
1287 /* Any which are supposed to be permanent,
1288 make local again, with the same values they had. */
1290 for (alist
= oalist
; !NILP (alist
); alist
= XCONS (alist
)->cdr
)
1292 sym
= XCONS (XCONS (alist
)->car
)->car
;
1293 tem
= Fget (sym
, Qpermanent_local
);
1296 Fmake_local_variable (sym
);
1297 Fset (sym
, XCONS (XCONS (alist
)->car
)->cdr
);
1301 /* Force mode-line redisplay. Useful here because all major mode
1302 commands call this function. */
1303 update_mode_lines
++;
1308 /* Find all the overlays in the current buffer that contain position POS.
1309 Return the number found, and store them in a vector in *VEC_PTR.
1310 Store in *LEN_PTR the size allocated for the vector.
1311 Store in *NEXT_PTR the next position after POS where an overlay starts,
1312 or ZV if there are no more overlays.
1313 Store in *PREV_PTR the previous position after POS where an overlay ends,
1314 or BEGV if there are no previous overlays.
1315 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
1317 *VEC_PTR and *LEN_PTR should contain a valid vector and size
1318 when this function is called.
1320 If EXTEND is non-zero, we make the vector bigger if necessary.
1321 If EXTEND is zero, we never extend the vector,
1322 and we store only as many overlays as will fit.
1323 But we still return the total number of overlays. */
1326 overlays_at (pos
, extend
, vec_ptr
, len_ptr
, next_ptr
, prev_ptr
)
1329 Lisp_Object
**vec_ptr
;
1334 Lisp_Object tail
, overlay
, start
, end
, result
;
1337 Lisp_Object
*vec
= *vec_ptr
;
1340 int inhibit_storing
= 0;
1342 for (tail
= current_buffer
->overlays_before
;
1343 XGCTYPE (tail
) == Lisp_Cons
;
1344 tail
= XCONS (tail
)->cdr
)
1346 int startpos
, endpos
;
1348 overlay
= XCONS (tail
)->car
;
1349 if (XGCTYPE (overlay
) != Lisp_Overlay
)
1352 start
= OVERLAY_START (overlay
);
1353 end
= OVERLAY_END (overlay
);
1354 endpos
= OVERLAY_POSITION (end
);
1363 startpos
= OVERLAY_POSITION (start
);
1364 if (startpos
<= pos
)
1368 /* The supplied vector is full.
1369 Either make it bigger, or don't store any more in it. */
1372 *len_ptr
= len
*= 2;
1373 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
1377 inhibit_storing
= 1;
1380 if (!inhibit_storing
)
1382 /* Keep counting overlays even if we can't return them all. */
1385 else if (startpos
< next
)
1389 for (tail
= current_buffer
->overlays_after
;
1390 XGCTYPE (tail
) == Lisp_Cons
;
1391 tail
= XCONS (tail
)->cdr
)
1393 int startpos
, endpos
;
1395 overlay
= XCONS (tail
)->car
;
1396 if (XGCTYPE (overlay
) != Lisp_Overlay
)
1399 start
= OVERLAY_START (overlay
);
1400 end
= OVERLAY_END (overlay
);
1401 startpos
= OVERLAY_POSITION (start
);
1404 if (startpos
< next
)
1408 endpos
= OVERLAY_POSITION (end
);
1415 *len_ptr
= len
*= 2;
1416 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
1420 inhibit_storing
= 1;
1423 if (!inhibit_storing
)
1427 else if (endpos
< pos
&& endpos
> prev
)
1440 Lisp_Object overlay
;
1446 compare_overlays (s1
, s2
)
1447 struct sortvec
*s1
, *s2
;
1449 if (s1
->priority
!= s2
->priority
)
1450 return s1
->priority
- s2
->priority
;
1451 if (s1
->beg
!= s2
->beg
)
1452 return s1
->beg
- s2
->beg
;
1453 if (s1
->end
!= s2
->end
)
1454 return s2
->end
- s1
->end
;
1458 /* Sort an array of overlays by priority. The array is modified in place.
1459 The return value is the new size; this may be smaller than the original
1460 size if some of the overlays were invalid or were window-specific. */
1462 sort_overlays (overlay_vec
, noverlays
, w
)
1463 Lisp_Object
*overlay_vec
;
1468 struct sortvec
*sortvec
;
1469 sortvec
= (struct sortvec
*) alloca (noverlays
* sizeof (struct sortvec
));
1471 /* Put the valid and relevant overlays into sortvec. */
1473 for (i
= 0, j
= 0; i
< noverlays
; i
++)
1476 Lisp_Object overlay
;
1478 overlay
= overlay_vec
[i
];
1479 if (OVERLAY_VALID (overlay
)
1480 && OVERLAY_POSITION (OVERLAY_START (overlay
)) > 0
1481 && OVERLAY_POSITION (OVERLAY_END (overlay
)) > 0)
1483 /* If we're interested in a specific window, then ignore
1484 overlays that are limited to some other window. */
1489 window
= Foverlay_get (overlay
, Qwindow
);
1490 if (WINDOWP (window
) && XWINDOW (window
) != w
)
1494 /* This overlay is good and counts: put it into sortvec. */
1495 sortvec
[j
].overlay
= overlay
;
1496 sortvec
[j
].beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
1497 sortvec
[j
].end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
1498 tem
= Foverlay_get (overlay
, Qpriority
);
1500 sortvec
[j
].priority
= XINT (tem
);
1502 sortvec
[j
].priority
= 0;
1508 /* Sort the overlays into the proper order: increasing priority. */
1511 qsort (sortvec
, noverlays
, sizeof (struct sortvec
), compare_overlays
);
1513 for (i
= 0; i
< noverlays
; i
++)
1514 overlay_vec
[i
] = sortvec
[i
].overlay
;
1518 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
1521 recenter_overlay_lists (buf
, pos
)
1525 Lisp_Object overlay
, tail
, next
, prev
, beg
, end
;
1527 /* See if anything in overlays_before should move to overlays_after. */
1529 /* We don't strictly need prev in this loop; it should always be nil.
1530 But we use it for symmetry and in case that should cease to be true
1531 with some future change. */
1533 for (tail
= buf
->overlays_before
;
1535 prev
= tail
, tail
= next
)
1537 next
= XCONS (tail
)->cdr
;
1538 overlay
= XCONS (tail
)->car
;
1540 /* If the overlay is not valid, get rid of it. */
1541 if (!OVERLAY_VALID (overlay
))
1546 /* Splice the cons cell TAIL out of overlays_before. */
1548 XCONS (prev
)->cdr
= next
;
1550 buf
->overlays_before
= next
;
1556 beg
= OVERLAY_START (overlay
);
1557 end
= OVERLAY_END (overlay
);
1559 if (OVERLAY_POSITION (end
) > pos
)
1561 /* OVERLAY needs to be moved. */
1562 int where
= OVERLAY_POSITION (beg
);
1563 Lisp_Object other
, other_prev
;
1565 /* Splice the cons cell TAIL out of overlays_before. */
1567 XCONS (prev
)->cdr
= next
;
1569 buf
->overlays_before
= next
;
1571 /* Search thru overlays_after for where to put it. */
1573 for (other
= buf
->overlays_after
;
1575 other_prev
= other
, other
= XCONS (other
)->cdr
)
1577 Lisp_Object otherbeg
, otheroverlay
, follower
;
1580 otheroverlay
= XCONS (other
)->car
;
1581 if (! OVERLAY_VALID (otheroverlay
))
1584 otherbeg
= OVERLAY_START (otheroverlay
);
1585 if (OVERLAY_POSITION (otherbeg
) >= where
)
1589 /* Add TAIL to overlays_after before OTHER. */
1590 XCONS (tail
)->cdr
= other
;
1591 if (!NILP (other_prev
))
1592 XCONS (other_prev
)->cdr
= tail
;
1594 buf
->overlays_after
= tail
;
1598 /* We've reached the things that should stay in overlays_before.
1599 All the rest of overlays_before must end even earlier,
1604 /* See if anything in overlays_after should be in overlays_before. */
1606 for (tail
= buf
->overlays_after
;
1608 prev
= tail
, tail
= next
)
1610 next
= XCONS (tail
)->cdr
;
1611 overlay
= XCONS (tail
)->car
;
1613 /* If the overlay is not valid, get rid of it. */
1614 if (!OVERLAY_VALID (overlay
))
1619 /* Splice the cons cell TAIL out of overlays_after. */
1621 XCONS (prev
)->cdr
= next
;
1623 buf
->overlays_after
= next
;
1629 beg
= OVERLAY_START (overlay
);
1630 end
= OVERLAY_END (overlay
);
1632 /* Stop looking, when we know that nothing further
1633 can possibly end before POS. */
1634 if (OVERLAY_POSITION (beg
) > pos
)
1637 if (OVERLAY_POSITION (end
) <= pos
)
1639 /* OVERLAY needs to be moved. */
1640 int where
= OVERLAY_POSITION (end
);
1641 Lisp_Object other
, other_prev
;
1643 /* Splice the cons cell TAIL out of overlays_after. */
1645 XCONS (prev
)->cdr
= next
;
1647 buf
->overlays_after
= next
;
1649 /* Search thru overlays_before for where to put it. */
1651 for (other
= buf
->overlays_before
;
1653 other_prev
= other
, other
= XCONS (other
)->cdr
)
1655 Lisp_Object otherend
, otheroverlay
;
1658 otheroverlay
= XCONS (other
)->car
;
1659 if (! OVERLAY_VALID (otheroverlay
))
1662 otherend
= OVERLAY_END (otheroverlay
);
1663 if (OVERLAY_POSITION (otherend
) <= where
)
1667 /* Add TAIL to overlays_before before OTHER. */
1668 XCONS (tail
)->cdr
= other
;
1669 if (!NILP (other_prev
))
1670 XCONS (other_prev
)->cdr
= tail
;
1672 buf
->overlays_before
= tail
;
1677 XSETFASTINT (buf
->overlay_center
, pos
);
1680 /* Fix up overlays that were garbled as a result of permuting markers
1681 in the range START through END. Any overlay with at least one
1682 endpoint in this range will need to be unlinked from the overlay
1683 list and reinserted in its proper place.
1684 Such an overlay might even have negative size at this point.
1685 If so, we'll reverse the endpoints. Can you think of anything
1686 better to do in this situation? */
1688 fix_overlays_in_range (start
, end
)
1689 register int start
, end
;
1691 Lisp_Object tem
, overlay
;
1692 Lisp_Object before_list
, after_list
;
1693 Lisp_Object
*ptail
, *pbefore
= &before_list
, *pafter
= &after_list
;
1694 int startpos
, endpos
;
1696 /* This algorithm shifts links around instead of consing and GCing.
1697 The loop invariant is that before_list (resp. after_list) is a
1698 well-formed list except that its last element, the one that
1699 *pbefore (resp. *pafter) points to, is still uninitialized.
1700 So it's not a bug that before_list isn't initialized, although
1701 it may look strange. */
1702 for (ptail
= ¤t_buffer
->overlays_before
; CONSP (*ptail
);)
1704 overlay
= XCONS (*ptail
)->car
;
1705 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
1708 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
1710 || (startpos
>= start
&& startpos
< end
))
1712 /* If the overlay is backwards, fix that now. */
1713 if (startpos
> endpos
)
1716 Fset_marker (OVERLAY_START (overlay
), endpos
, Qnil
);
1717 Fset_marker (OVERLAY_END (overlay
), startpos
, Qnil
);
1718 tem
= startpos
; startpos
= endpos
; endpos
= tem
;
1720 /* Add it to the end of the wrong list. Later on,
1721 recenter_overlay_lists will move it to the right place. */
1722 if (endpos
< XINT (current_buffer
->overlay_center
))
1725 pafter
= &XCONS (*ptail
)->cdr
;
1730 pbefore
= &XCONS (*ptail
)->cdr
;
1732 *ptail
= XCONS (*ptail
)->cdr
;
1735 ptail
= &XCONS (*ptail
)->cdr
;
1737 for (ptail
= ¤t_buffer
->overlays_after
; CONSP (*ptail
);)
1739 overlay
= XCONS (*ptail
)->car
;
1740 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
1741 if (startpos
>= end
)
1743 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
1744 if (startpos
>= start
1745 || (endpos
>= start
&& endpos
< end
))
1747 if (startpos
> endpos
)
1750 Fset_marker (OVERLAY_START (overlay
), endpos
, Qnil
);
1751 Fset_marker (OVERLAY_END (overlay
), startpos
, Qnil
);
1752 tem
= startpos
; startpos
= endpos
; endpos
= tem
;
1754 if (endpos
< XINT (current_buffer
->overlay_center
))
1757 pafter
= &XCONS (*ptail
)->cdr
;
1762 pbefore
= &XCONS (*ptail
)->cdr
;
1764 *ptail
= XCONS (*ptail
)->cdr
;
1767 ptail
= &XCONS (*ptail
)->cdr
;
1770 /* Splice the constructed (wrong) lists into the buffer's lists,
1771 and let the recenter function make it sane again. */
1772 *pbefore
= current_buffer
->overlays_before
;
1773 current_buffer
->overlays_before
= before_list
;
1774 recenter_overlay_lists (current_buffer
,
1775 XINT (current_buffer
->overlay_center
));
1777 *pafter
= current_buffer
->overlays_after
;
1778 current_buffer
->overlays_after
= after_list
;
1779 recenter_overlay_lists (current_buffer
,
1780 XINT (current_buffer
->overlay_center
));
1783 DEFUN ("overlayp", Foverlayp
, Soverlayp
, 1, 1, 0,
1784 "Return t if OBJECT is an overlay.")
1788 return (OVERLAYP (object
) ? Qt
: Qnil
);
1791 DEFUN ("make-overlay", Fmake_overlay
, Smake_overlay
, 2, 3, 0,
1792 "Create a new overlay with range BEG to END in BUFFER.\n\
1793 If omitted, BUFFER defaults to the current buffer.\n\
1794 BEG and END may be integers or markers.")
1796 Lisp_Object beg
, end
, buffer
;
1798 Lisp_Object overlay
;
1802 XSETBUFFER (buffer
, current_buffer
);
1804 CHECK_BUFFER (buffer
, 2);
1806 && ! EQ (Fmarker_buffer (beg
), buffer
))
1807 error ("Marker points into wrong buffer");
1809 && ! EQ (Fmarker_buffer (end
), buffer
))
1810 error ("Marker points into wrong buffer");
1812 CHECK_NUMBER_COERCE_MARKER (beg
, 1);
1813 CHECK_NUMBER_COERCE_MARKER (end
, 1);
1815 if (XINT (beg
) > XINT (end
))
1818 temp
= beg
; beg
= end
; end
= temp
;
1821 b
= XBUFFER (buffer
);
1823 beg
= Fset_marker (Fmake_marker (), beg
, buffer
);
1824 end
= Fset_marker (Fmake_marker (), end
, buffer
);
1826 overlay
= Fcons (Fcons (beg
, end
), Qnil
);
1827 XSETTYPE (overlay
, Lisp_Overlay
);
1829 /* Put the new overlay on the wrong list. */
1830 end
= OVERLAY_END (overlay
);
1831 if (OVERLAY_POSITION (end
) < XINT (b
->overlay_center
))
1832 b
->overlays_after
= Fcons (overlay
, b
->overlays_after
);
1834 b
->overlays_before
= Fcons (overlay
, b
->overlays_before
);
1836 /* This puts it in the right list, and in the right order. */
1837 recenter_overlay_lists (b
, XINT (b
->overlay_center
));
1839 /* We don't need to redisplay the region covered by the overlay, because
1840 the overlay has no properties at the moment. */
1845 DEFUN ("move-overlay", Fmove_overlay
, Smove_overlay
, 3, 4, 0,
1846 "Set the endpoints of OVERLAY to BEG and END in BUFFER.\n\
1847 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.\n\
1848 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current\n\
1850 (overlay
, beg
, end
, buffer
)
1851 Lisp_Object overlay
, beg
, end
, buffer
;
1853 struct buffer
*b
, *ob
;
1854 Lisp_Object obuffer
;
1855 int count
= specpdl_ptr
- specpdl
;
1857 CHECK_OVERLAY (overlay
, 0);
1859 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
1861 XSETBUFFER (buffer
, current_buffer
);
1862 CHECK_BUFFER (buffer
, 3);
1865 && ! EQ (Fmarker_buffer (beg
), buffer
))
1866 error ("Marker points into wrong buffer");
1868 && ! EQ (Fmarker_buffer (end
), buffer
))
1869 error ("Marker points into wrong buffer");
1871 CHECK_NUMBER_COERCE_MARKER (beg
, 1);
1872 CHECK_NUMBER_COERCE_MARKER (end
, 1);
1874 if (XINT (beg
) == XINT (end
) && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
1875 return Fdelete_overlay (overlay
);
1877 if (XINT (beg
) > XINT (end
))
1880 temp
= beg
; beg
= end
; end
= temp
;
1883 specbind (Qinhibit_quit
, Qt
);
1885 obuffer
= Fmarker_buffer (OVERLAY_START (overlay
));
1886 b
= XBUFFER (buffer
);
1887 ob
= XBUFFER (obuffer
);
1889 /* If the overlay has changed buffers, do a thorough redisplay. */
1890 if (!EQ (buffer
, obuffer
))
1892 /* Redisplay where the overlay was. */
1893 if (!NILP (obuffer
))
1898 o_beg
= OVERLAY_START (overlay
);
1899 o_end
= OVERLAY_END (overlay
);
1900 o_beg
= OVERLAY_POSITION (o_beg
);
1901 o_end
= OVERLAY_POSITION (o_end
);
1903 redisplay_region (ob
, XINT (o_beg
), XINT (o_end
));
1906 /* Redisplay where the overlay is going to be. */
1907 redisplay_region (b
, XINT (beg
), XINT (end
));
1909 /* Don't limit redisplay to the selected window. */
1910 windows_or_buffers_changed
= 1;
1913 /* Redisplay the area the overlay has just left, or just enclosed. */
1917 int change_beg
, change_end
;
1919 o_beg
= OVERLAY_START (overlay
);
1920 o_end
= OVERLAY_END (overlay
);
1921 o_beg
= OVERLAY_POSITION (o_beg
);
1922 o_end
= OVERLAY_POSITION (o_end
);
1924 if (XINT (o_beg
) == XINT (beg
))
1925 redisplay_region (b
, XINT (o_end
), XINT (end
));
1926 else if (XINT (o_end
) == XINT (end
))
1927 redisplay_region (b
, XINT (o_beg
), XINT (beg
));
1930 if (XINT (beg
) < XINT (o_beg
)) o_beg
= beg
;
1931 if (XINT (end
) > XINT (o_end
)) o_end
= end
;
1932 redisplay_region (b
, XINT (o_beg
), XINT (o_end
));
1936 if (!NILP (obuffer
))
1938 ob
->overlays_before
= Fdelq (overlay
, ob
->overlays_before
);
1939 ob
->overlays_after
= Fdelq (overlay
, ob
->overlays_after
);
1942 Fset_marker (OVERLAY_START (overlay
), beg
, buffer
);
1943 Fset_marker (OVERLAY_END (overlay
), end
, buffer
);
1945 /* Put the overlay on the wrong list. */
1946 end
= OVERLAY_END (overlay
);
1947 if (OVERLAY_POSITION (end
) < XINT (b
->overlay_center
))
1948 b
->overlays_after
= Fcons (overlay
, b
->overlays_after
);
1950 b
->overlays_before
= Fcons (overlay
, b
->overlays_before
);
1952 /* This puts it in the right list, and in the right order. */
1953 recenter_overlay_lists (b
, XINT (b
->overlay_center
));
1955 return unbind_to (count
, overlay
);
1958 DEFUN ("delete-overlay", Fdelete_overlay
, Sdelete_overlay
, 1, 1, 0,
1959 "Delete the overlay OVERLAY from its buffer.")
1961 Lisp_Object overlay
;
1965 int count
= specpdl_ptr
- specpdl
;
1967 CHECK_OVERLAY (overlay
, 0);
1969 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
1973 b
= XBUFFER (buffer
);
1975 specbind (Qinhibit_quit
, Qt
);
1977 b
->overlays_before
= Fdelq (overlay
, b
->overlays_before
);
1978 b
->overlays_after
= Fdelq (overlay
, b
->overlays_after
);
1980 redisplay_region (b
,
1981 marker_position (OVERLAY_START (overlay
)),
1982 marker_position (OVERLAY_END (overlay
)));
1984 Fset_marker (OVERLAY_START (overlay
), Qnil
, Qnil
);
1985 Fset_marker (OVERLAY_END (overlay
), Qnil
, Qnil
);
1987 return unbind_to (count
, Qnil
);
1990 /* Overlay dissection functions. */
1992 DEFUN ("overlay-start", Foverlay_start
, Soverlay_start
, 1, 1, 0,
1993 "Return the position at which OVERLAY starts.")
1995 Lisp_Object overlay
;
1997 CHECK_OVERLAY (overlay
, 0);
1999 return (Fmarker_position (OVERLAY_START (overlay
)));
2002 DEFUN ("overlay-end", Foverlay_end
, Soverlay_end
, 1, 1, 0,
2003 "Return the position at which OVERLAY ends.")
2005 Lisp_Object overlay
;
2007 CHECK_OVERLAY (overlay
, 0);
2009 return (Fmarker_position (OVERLAY_END (overlay
)));
2012 DEFUN ("overlay-buffer", Foverlay_buffer
, Soverlay_buffer
, 1, 1, 0,
2013 "Return the buffer OVERLAY belongs to.")
2015 Lisp_Object overlay
;
2017 CHECK_OVERLAY (overlay
, 0);
2019 return Fmarker_buffer (OVERLAY_START (overlay
));
2022 DEFUN ("overlay-properties", Foverlay_properties
, Soverlay_properties
, 1, 1, 0,
2023 "Return a list of the properties on OVERLAY.\n\
2024 This is a copy of OVERLAY's plist; modifying its conses has no effect on\n\
2027 Lisp_Object overlay
;
2029 CHECK_OVERLAY (overlay
, 0);
2031 return Fcopy_sequence (Fcdr_safe (XCONS (overlay
)->cdr
));
2035 DEFUN ("overlays-at", Foverlays_at
, Soverlays_at
, 1, 1, 0,
2036 "Return a list of the overlays that contain position POS.")
2041 Lisp_Object
*overlay_vec
;
2045 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
2048 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
2050 /* Put all the overlays we want in a vector in overlay_vec.
2051 Store the length in len. */
2052 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
, NULL
, NULL
);
2054 /* Make a list of them all. */
2055 result
= Flist (noverlays
, overlay_vec
);
2057 xfree (overlay_vec
);
2061 DEFUN ("next-overlay-change", Fnext_overlay_change
, Snext_overlay_change
,
2063 "Return the next position after POS where an overlay starts or ends.\n\
2064 If there are no more overlay boundaries after POS, return (point-max).")
2070 Lisp_Object
*overlay_vec
;
2074 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
2077 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
2079 /* Put all the overlays we want in a vector in overlay_vec.
2080 Store the length in len.
2081 endpos gets the position where the next overlay starts. */
2082 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
, &endpos
, NULL
);
2084 /* If any of these overlays ends before endpos,
2085 use its ending point instead. */
2086 for (i
= 0; i
< noverlays
; i
++)
2091 oend
= OVERLAY_END (overlay_vec
[i
]);
2092 oendpos
= OVERLAY_POSITION (oend
);
2093 if (oendpos
< endpos
)
2097 xfree (overlay_vec
);
2098 return make_number (endpos
);
2101 DEFUN ("previous-overlay-change", Fprevious_overlay_change
,
2102 Sprevious_overlay_change
, 1, 1, 0,
2103 "Return the previous position before POS where an overlay starts or ends.\n\
2104 If there are no more overlay boundaries after POS, return (point-min).")
2110 Lisp_Object
*overlay_vec
;
2114 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
2117 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
2119 /* Put all the overlays we want in a vector in overlay_vec.
2120 Store the length in len.
2121 prevpos gets the position of an overlay end. */
2122 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
, NULL
, &prevpos
);
2124 /* If any of these overlays starts before endpos,
2125 maybe use its starting point instead. */
2126 for (i
= 0; i
< noverlays
; i
++)
2131 ostart
= OVERLAY_START (overlay_vec
[i
]);
2132 ostartpos
= OVERLAY_POSITION (ostart
);
2133 if (ostartpos
> prevpos
&& ostartpos
< XINT (pos
))
2134 prevpos
= ostartpos
;
2137 xfree (overlay_vec
);
2138 return make_number (prevpos
);
2141 /* These functions are for debugging overlays. */
2143 DEFUN ("overlay-lists", Foverlay_lists
, Soverlay_lists
, 0, 0, 0,
2144 "Return a pair of lists giving all the overlays of the current buffer.\n\
2145 The car has all the overlays before the overlay center;\n\
2146 the cdr has all the overlays after the overlay center.\n\
2147 Recentering overlays moves overlays between these lists.\n\
2148 The lists you get are copies, so that changing them has no effect.\n\
2149 However, the overlays you get are the real objects that the buffer uses.")
2152 Lisp_Object before
, after
;
2153 before
= current_buffer
->overlays_before
;
2155 before
= Fcopy_sequence (before
);
2156 after
= current_buffer
->overlays_after
;
2158 after
= Fcopy_sequence (after
);
2160 return Fcons (before
, after
);
2163 DEFUN ("overlay-recenter", Foverlay_recenter
, Soverlay_recenter
, 1, 1, 0,
2164 "Recenter the overlays of the current buffer around position POS.")
2168 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
2170 recenter_overlay_lists (current_buffer
, XINT (pos
));
2174 DEFUN ("overlay-get", Foverlay_get
, Soverlay_get
, 2, 2, 0,
2175 "Get the property of overlay OVERLAY with property name NAME.")
2177 Lisp_Object overlay
, prop
;
2179 Lisp_Object plist
, fallback
;
2181 CHECK_OVERLAY (overlay
, 0);
2185 for (plist
= Fcdr_safe (XCONS (overlay
)->cdr
);
2186 CONSP (plist
) && CONSP (XCONS (plist
)->cdr
);
2187 plist
= XCONS (XCONS (plist
)->cdr
)->cdr
)
2189 if (EQ (XCONS (plist
)->car
, prop
))
2190 return XCONS (XCONS (plist
)->cdr
)->car
;
2191 else if (EQ (XCONS (plist
)->car
, Qcategory
))
2194 tem
= Fcar (Fcdr (plist
));
2196 fallback
= Fget (tem
, prop
);
2203 DEFUN ("overlay-put", Foverlay_put
, Soverlay_put
, 3, 3, 0,
2204 "Set one property of overlay OVERLAY: give property PROP value VALUE.")
2205 (overlay
, prop
, value
)
2206 Lisp_Object overlay
, prop
, value
;
2208 Lisp_Object plist
, tail
, buffer
;
2211 CHECK_OVERLAY (overlay
, 0);
2213 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
2215 plist
= Fcdr_safe (XCONS (overlay
)->cdr
);
2218 CONSP (tail
) && CONSP (XCONS (tail
)->cdr
);
2219 tail
= XCONS (XCONS (tail
)->cdr
)->cdr
)
2220 if (EQ (XCONS (tail
)->car
, prop
))
2222 changed
= !EQ (XCONS (XCONS (tail
)->cdr
)->car
, value
);
2223 XCONS (XCONS (tail
)->cdr
)->car
= value
;
2226 /* It wasn't in the list, so add it to the front. */
2227 changed
= !NILP (value
);
2228 if (! CONSP (XCONS (overlay
)->cdr
))
2229 XCONS (overlay
)->cdr
= Fcons (Qnil
, Qnil
);
2230 XCONS (XCONS (overlay
)->cdr
)->cdr
= Fcons (prop
, Fcons (value
, plist
));
2232 if (! NILP (buffer
))
2235 redisplay_region (XBUFFER (buffer
),
2236 marker_position (OVERLAY_START (overlay
)),
2237 marker_position (OVERLAY_END (overlay
)));
2238 if (EQ (prop
, Qevaporate
) && ! NILP (value
)
2239 && (OVERLAY_POSITION (OVERLAY_START (overlay
))
2240 == OVERLAY_POSITION (OVERLAY_END (overlay
))))
2241 Fdelete_overlay (overlay
);
2246 /* Run the modification-hooks of overlays that include
2247 any part of the text in START to END.
2248 Run the insert-before-hooks of overlay starting at END,
2249 and the insert-after-hooks of overlay ending at START. */
2252 verify_overlay_modification (start
, end
)
2253 Lisp_Object start
, end
;
2255 Lisp_Object prop
, overlay
, tail
;
2256 int insertion
= EQ (start
, end
);
2258 struct gcpro gcpro1
, gcpro2
;
2262 GCPRO2 (overlay
, tail
);
2265 for (tail
= current_buffer
->overlays_before
;
2267 tail
= XCONS (tail
)->cdr
)
2269 int startpos
, endpos
;
2270 Lisp_Object ostart
, oend
;
2272 overlay
= XCONS (tail
)->car
;
2274 ostart
= OVERLAY_START (overlay
);
2275 oend
= OVERLAY_END (overlay
);
2276 endpos
= OVERLAY_POSITION (oend
);
2277 if (XFASTINT (start
) > endpos
)
2279 startpos
= OVERLAY_POSITION (ostart
);
2280 if (XFASTINT (end
) == startpos
&& insertion
)
2282 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
2285 /* Copy TAIL in case the hook recenters the overlay lists. */
2287 tail
= Fcopy_sequence (tail
);
2289 call_overlay_mod_hooks (prop
, overlay
, start
, end
);
2292 if (XFASTINT (start
) == endpos
&& insertion
)
2294 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
2298 tail
= Fcopy_sequence (tail
);
2300 call_overlay_mod_hooks (prop
, overlay
, start
, end
);
2303 /* Test for intersecting intervals. This does the right thing
2304 for both insertion and deletion. */
2305 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
2307 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
2311 tail
= Fcopy_sequence (tail
);
2313 call_overlay_mod_hooks (prop
, overlay
, start
, end
);
2319 for (tail
= current_buffer
->overlays_after
;
2321 tail
= XCONS (tail
)->cdr
)
2323 int startpos
, endpos
;
2324 Lisp_Object ostart
, oend
;
2326 overlay
= XCONS (tail
)->car
;
2328 ostart
= OVERLAY_START (overlay
);
2329 oend
= OVERLAY_END (overlay
);
2330 startpos
= OVERLAY_POSITION (ostart
);
2331 endpos
= OVERLAY_POSITION (oend
);
2332 if (XFASTINT (end
) < startpos
)
2334 if (XFASTINT (end
) == startpos
&& insertion
)
2336 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
2340 tail
= Fcopy_sequence (tail
);
2342 call_overlay_mod_hooks (prop
, overlay
, start
, end
);
2345 if (XFASTINT (start
) == endpos
&& insertion
)
2347 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
2351 tail
= Fcopy_sequence (tail
);
2353 call_overlay_mod_hooks (prop
, overlay
, start
, end
);
2356 /* Test for intersecting intervals. This does the right thing
2357 for both insertion and deletion. */
2358 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
2360 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
2364 tail
= Fcopy_sequence (tail
);
2366 call_overlay_mod_hooks (prop
, overlay
, start
, end
);
2375 call_overlay_mod_hooks (list
, overlay
, start
, end
)
2376 Lisp_Object list
, overlay
, start
, end
;
2378 struct gcpro gcpro1
;
2380 while (!NILP (list
))
2382 call3 (Fcar (list
), overlay
, start
, end
);
2388 /* Delete any zero-sized overlays at position POS, if the `evaporate'
2391 evaporate_overlays (pos
)
2394 Lisp_Object tail
, overlay
, hit_list
;
2397 if (pos
<= XFASTINT (current_buffer
->overlay_center
))
2398 for (tail
= current_buffer
->overlays_before
; CONSP (tail
);
2399 tail
= XCONS (tail
)->cdr
)
2402 overlay
= XCONS (tail
)->car
;
2403 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2406 if (endpos
== pos
&& OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
2407 && Foverlay_get (overlay
, Qevaporate
))
2408 hit_list
= Fcons (overlay
, hit_list
);
2411 for (tail
= current_buffer
->overlays_after
; CONSP (tail
);
2412 tail
= XCONS (tail
)->cdr
)
2415 overlay
= XCONS (tail
)->car
;
2416 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2419 if (startpos
== pos
&& OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
2420 && Foverlay_get (overlay
, Qevaporate
))
2421 hit_list
= Fcons (overlay
, hit_list
);
2423 for (; CONSP (hit_list
); hit_list
= XCONS (hit_list
)->cdr
)
2424 Fdelete_overlay (XCONS (hit_list
)->car
);
2427 /* Somebody has tried to store NEWVAL into the buffer-local slot with
2428 offset XUINT (valcontents), and NEWVAL has an unacceptable type. */
2430 buffer_slot_type_mismatch (valcontents
, newval
)
2431 Lisp_Object valcontents
, newval
;
2433 unsigned int offset
= XUINT (valcontents
);
2434 unsigned char *symbol_name
=
2435 (XSYMBOL (*(Lisp_Object
*)(offset
+ (char *)&buffer_local_symbols
))
2439 switch (XINT (*(Lisp_Object
*)(offset
+ (char *)&buffer_local_types
)))
2441 case Lisp_Int
: type_name
= "integers"; break;
2442 case Lisp_String
: type_name
= "strings"; break;
2443 case Lisp_Marker
: type_name
= "markers"; break;
2444 case Lisp_Symbol
: type_name
= "symbols"; break;
2445 case Lisp_Cons
: type_name
= "lists"; break;
2446 case Lisp_Vector
: type_name
= "vectors"; break;
2451 error ("only %s should be stored in the buffer-local variable %s",
2452 type_name
, symbol_name
);
2457 register Lisp_Object tem
;
2459 /* Make sure all markable slots in buffer_defaults
2460 are initialized reasonably, so mark_buffer won't choke. */
2461 reset_buffer (&buffer_defaults
);
2462 reset_buffer_local_variables (&buffer_defaults
);
2463 reset_buffer (&buffer_local_symbols
);
2464 reset_buffer_local_variables (&buffer_local_symbols
);
2465 XSETBUFFER (Vbuffer_defaults
, &buffer_defaults
);
2466 XSETBUFFER (Vbuffer_local_symbols
, &buffer_local_symbols
);
2468 /* Set up the default values of various buffer slots. */
2469 /* Must do these before making the first buffer! */
2471 /* real setup is done in loaddefs.el */
2472 buffer_defaults
.mode_line_format
= build_string ("%-");
2473 buffer_defaults
.abbrev_mode
= Qnil
;
2474 buffer_defaults
.overwrite_mode
= Qnil
;
2475 buffer_defaults
.case_fold_search
= Qt
;
2476 buffer_defaults
.auto_fill_function
= Qnil
;
2477 buffer_defaults
.selective_display
= Qnil
;
2479 buffer_defaults
.selective_display_ellipses
= Qt
;
2481 buffer_defaults
.abbrev_table
= Qnil
;
2482 buffer_defaults
.display_table
= Qnil
;
2483 buffer_defaults
.undo_list
= Qnil
;
2484 buffer_defaults
.mark_active
= Qnil
;
2485 buffer_defaults
.overlays_before
= Qnil
;
2486 buffer_defaults
.overlays_after
= Qnil
;
2487 XSETFASTINT (buffer_defaults
.overlay_center
, 1);
2489 XSETFASTINT (buffer_defaults
.tab_width
, 8);
2490 buffer_defaults
.truncate_lines
= Qnil
;
2491 buffer_defaults
.ctl_arrow
= Qt
;
2494 buffer_defaults
.buffer_file_type
= Qnil
; /* TEXT */
2496 XSETFASTINT (buffer_defaults
.fill_column
, 70);
2497 XSETFASTINT (buffer_defaults
.left_margin
, 0);
2498 buffer_defaults
.cache_long_line_scans
= Qnil
;
2500 /* Assign the local-flags to the slots that have default values.
2501 The local flag is a bit that is used in the buffer
2502 to say that it has its own local value for the slot.
2503 The local flag bits are in the local_var_flags slot of the buffer. */
2505 /* Nothing can work if this isn't true */
2506 if (sizeof (EMACS_INT
) != sizeof (Lisp_Object
)) abort ();
2508 /* 0 means not a lisp var, -1 means always local, else mask */
2509 bzero (&buffer_local_flags
, sizeof buffer_local_flags
);
2510 XSETINT (buffer_local_flags
.filename
, -1);
2511 XSETINT (buffer_local_flags
.directory
, -1);
2512 XSETINT (buffer_local_flags
.backed_up
, -1);
2513 XSETINT (buffer_local_flags
.save_length
, -1);
2514 XSETINT (buffer_local_flags
.auto_save_file_name
, -1);
2515 XSETINT (buffer_local_flags
.read_only
, -1);
2516 XSETINT (buffer_local_flags
.major_mode
, -1);
2517 XSETINT (buffer_local_flags
.mode_name
, -1);
2518 XSETINT (buffer_local_flags
.undo_list
, -1);
2519 XSETINT (buffer_local_flags
.mark_active
, -1);
2521 XSETFASTINT (buffer_local_flags
.mode_line_format
, 1);
2522 XSETFASTINT (buffer_local_flags
.abbrev_mode
, 2);
2523 XSETFASTINT (buffer_local_flags
.overwrite_mode
, 4);
2524 XSETFASTINT (buffer_local_flags
.case_fold_search
, 8);
2525 XSETFASTINT (buffer_local_flags
.auto_fill_function
, 0x10);
2526 XSETFASTINT (buffer_local_flags
.selective_display
, 0x20);
2528 XSETFASTINT (buffer_local_flags
.selective_display_ellipses
, 0x40);
2530 XSETFASTINT (buffer_local_flags
.tab_width
, 0x80);
2531 XSETFASTINT (buffer_local_flags
.truncate_lines
, 0x100);
2532 XSETFASTINT (buffer_local_flags
.ctl_arrow
, 0x200);
2533 XSETFASTINT (buffer_local_flags
.fill_column
, 0x400);
2534 XSETFASTINT (buffer_local_flags
.left_margin
, 0x800);
2535 XSETFASTINT (buffer_local_flags
.abbrev_table
, 0x1000);
2536 XSETFASTINT (buffer_local_flags
.display_table
, 0x2000);
2537 XSETFASTINT (buffer_local_flags
.syntax_table
, 0x8000);
2538 XSETFASTINT (buffer_local_flags
.cache_long_line_scans
, 0x10000);
2540 XSETFASTINT (buffer_local_flags
.buffer_file_type
, 0x4000);
2543 Vbuffer_alist
= Qnil
;
2547 QSFundamental
= build_string ("Fundamental");
2549 Qfundamental_mode
= intern ("fundamental-mode");
2550 buffer_defaults
.major_mode
= Qfundamental_mode
;
2552 Qmode_class
= intern ("mode-class");
2554 Qprotected_field
= intern ("protected-field");
2556 Qpermanent_local
= intern ("permanent-local");
2558 Qkill_buffer_hook
= intern ("kill-buffer-hook");
2560 Vprin1_to_string_buffer
= Fget_buffer_create (build_string (" prin1"));
2561 /* super-magic invisible buffer */
2562 Vbuffer_alist
= Qnil
;
2564 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
2569 char buf
[MAXPATHLEN
+1];
2571 struct stat dotstat
, pwdstat
;
2574 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
2576 /* If PWD is accurate, use it instead of calling getwd. This is faster
2577 when PWD is right, and may avoid a fatal error. */
2578 if ((pwd
= getenv ("PWD")) != 0 && *pwd
== '/'
2579 && stat (pwd
, &pwdstat
) == 0
2580 && stat (".", &dotstat
) == 0
2581 && dotstat
.st_ino
== pwdstat
.st_ino
2582 && dotstat
.st_dev
== pwdstat
.st_dev
2583 && strlen (pwd
) < MAXPATHLEN
)
2585 else if (getwd (buf
) == 0)
2586 fatal ("`getwd' failed: %s.\n", buf
);
2589 /* Maybe this should really use some standard subroutine
2590 whose definition is filename syntax dependent. */
2591 if (buf
[strlen (buf
) - 1] != '/')
2593 #endif /* not VMS */
2594 current_buffer
->directory
= build_string (buf
);
2596 temp
= get_minibuffer (0);
2597 XBUFFER (temp
)->directory
= current_buffer
->directory
;
2600 /* initialize the buffer routines */
2603 extern Lisp_Object Qdisabled
;
2605 staticpro (&Vbuffer_defaults
);
2606 staticpro (&Vbuffer_local_symbols
);
2607 staticpro (&Qfundamental_mode
);
2608 staticpro (&Qmode_class
);
2609 staticpro (&QSFundamental
);
2610 staticpro (&Vbuffer_alist
);
2611 staticpro (&Qprotected_field
);
2612 staticpro (&Qpermanent_local
);
2613 staticpro (&Qkill_buffer_hook
);
2614 staticpro (&Qoverlayp
);
2615 Qevaporate
= intern ("evaporate");
2616 staticpro (&Qevaporate
);
2617 staticpro (&Qmodification_hooks
);
2618 Qmodification_hooks
= intern ("modification-hooks");
2619 staticpro (&Qinsert_in_front_hooks
);
2620 Qinsert_in_front_hooks
= intern ("insert-in-front-hooks");
2621 staticpro (&Qinsert_behind_hooks
);
2622 Qinsert_behind_hooks
= intern ("insert-behind-hooks");
2623 staticpro (&Qget_file_buffer
);
2624 Qget_file_buffer
= intern ("get-file-buffer");
2625 Qpriority
= intern ("priority");
2626 staticpro (&Qpriority
);
2627 Qwindow
= intern ("window");
2628 staticpro (&Qwindow
);
2630 Qoverlayp
= intern ("overlayp");
2632 Fput (Qprotected_field
, Qerror_conditions
,
2633 Fcons (Qprotected_field
, Fcons (Qerror
, Qnil
)));
2634 Fput (Qprotected_field
, Qerror_message
,
2635 build_string ("Attempt to modify a protected field"));
2637 /* All these use DEFVAR_LISP_NOPRO because the slots in
2638 buffer_defaults will all be marked via Vbuffer_defaults. */
2640 DEFVAR_LISP_NOPRO ("default-mode-line-format",
2641 &buffer_defaults
.mode_line_format
,
2642 "Default value of `mode-line-format' for buffers that don't override it.\n\
2643 This is the same as (default-value 'mode-line-format).");
2645 DEFVAR_LISP_NOPRO ("default-abbrev-mode",
2646 &buffer_defaults
.abbrev_mode
,
2647 "Default value of `abbrev-mode' for buffers that do not override it.\n\
2648 This is the same as (default-value 'abbrev-mode).");
2650 DEFVAR_LISP_NOPRO ("default-ctl-arrow",
2651 &buffer_defaults
.ctl_arrow
,
2652 "Default value of `ctl-arrow' for buffers that do not override it.\n\
2653 This is the same as (default-value 'ctl-arrow).");
2655 DEFVAR_LISP_NOPRO ("default-truncate-lines",
2656 &buffer_defaults
.truncate_lines
,
2657 "Default value of `truncate-lines' for buffers that do not override it.\n\
2658 This is the same as (default-value 'truncate-lines).");
2660 DEFVAR_LISP_NOPRO ("default-fill-column",
2661 &buffer_defaults
.fill_column
,
2662 "Default value of `fill-column' for buffers that do not override it.\n\
2663 This is the same as (default-value 'fill-column).");
2665 DEFVAR_LISP_NOPRO ("default-left-margin",
2666 &buffer_defaults
.left_margin
,
2667 "Default value of `left-margin' for buffers that do not override it.\n\
2668 This is the same as (default-value 'left-margin).");
2670 DEFVAR_LISP_NOPRO ("default-tab-width",
2671 &buffer_defaults
.tab_width
,
2672 "Default value of `tab-width' for buffers that do not override it.\n\
2673 This is the same as (default-value 'tab-width).");
2675 DEFVAR_LISP_NOPRO ("default-case-fold-search",
2676 &buffer_defaults
.case_fold_search
,
2677 "Default value of `case-fold-search' for buffers that don't override it.\n\
2678 This is the same as (default-value 'case-fold-search).");
2681 DEFVAR_LISP_NOPRO ("default-buffer-file-type",
2682 &buffer_defaults
.buffer_file_type
,
2683 "Default file type for buffers that do not override it.\n\
2684 This is the same as (default-value 'buffer-file-type).\n\
2685 The file type is nil for text, t for binary.");
2688 DEFVAR_PER_BUFFER ("mode-line-format", ¤t_buffer
->mode_line_format
,
2691 /* This doc string is too long for cpp; cpp dies if it isn't in a comment.
2692 But make-docfile finds it!
2693 DEFVAR_PER_BUFFER ("mode-line-format", ¤t_buffer->mode_line_format,
2695 "Template for displaying mode line for current buffer.\n\
2696 Each buffer has its own value of this variable.\n\
2697 Value may be a string, a symbol or a list or cons cell.\n\
2698 For a symbol, its value is used (but it is ignored if t or nil).\n\
2699 A string appearing directly as the value of a symbol is processed verbatim\n\
2700 in that the %-constructs below are not recognized.\n\
2701 For a list whose car is a symbol, the symbol's value is taken,\n\
2702 and if that is non-nil, the cadr of the list is processed recursively.\n\
2703 Otherwise, the caddr of the list (if there is one) is processed.\n\
2704 For a list whose car is a string or list, each element is processed\n\
2705 recursively and the results are effectively concatenated.\n\
2706 For a list whose car is an integer, the cdr of the list is processed\n\
2707 and padded (if the number is positive) or truncated (if negative)\n\
2708 to the width specified by that number.\n\
2709 A string is printed verbatim in the mode line except for %-constructs:\n\
2710 (%-constructs are allowed when the string is the entire mode-line-format\n\
2711 or when it is found in a cons-cell or a list)\n\
2712 %b -- print buffer name. %f -- print visited file name.\n\
2713 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.\n\
2714 % means buffer is read-only and * means it is modified.\n\
2715 For a modified read-only buffer, %* gives % and %+ gives *.\n\
2716 %s -- print process status. %l -- print the current line number.\n\
2717 %p -- print percent of buffer above top of window, or Top, Bot or All.\n\
2718 %P -- print percent of buffer above bottom of window, perhaps plus Top,\n\
2719 or print Bottom or All.\n\
2720 %n -- print Narrow if appropriate.\n\
2721 %t -- print T if files is text, B if binary.\n\
2722 %[ -- print one [ for each recursive editing level. %] similar.\n\
2723 %% -- print %. %- -- print infinitely many dashes.\n\
2724 Decimal digits after the % specify field width to which to pad.");
2727 DEFVAR_LISP_NOPRO ("default-major-mode", &buffer_defaults
.major_mode
,
2728 "*Major mode for new buffers. Defaults to `fundamental-mode'.\n\
2729 nil here means use current buffer's major mode.");
2731 DEFVAR_PER_BUFFER ("major-mode", ¤t_buffer
->major_mode
,
2732 make_number (Lisp_Symbol
),
2733 "Symbol for current buffer's major mode.");
2735 DEFVAR_PER_BUFFER ("mode-name", ¤t_buffer
->mode_name
,
2736 make_number (Lisp_String
),
2737 "Pretty name of current buffer's major mode (a string).");
2739 DEFVAR_PER_BUFFER ("abbrev-mode", ¤t_buffer
->abbrev_mode
, Qnil
,
2740 "Non-nil turns on automatic expansion of abbrevs as they are inserted.\n\
2741 Automatically becomes buffer-local when set in any fashion.");
2743 DEFVAR_PER_BUFFER ("case-fold-search", ¤t_buffer
->case_fold_search
,
2745 "*Non-nil if searches should ignore case.\n\
2746 Automatically becomes buffer-local when set in any fashion.");
2748 DEFVAR_PER_BUFFER ("fill-column", ¤t_buffer
->fill_column
,
2749 make_number (Lisp_Int
),
2750 "*Column beyond which automatic line-wrapping should happen.\n\
2751 Automatically becomes buffer-local when set in any fashion.");
2753 DEFVAR_PER_BUFFER ("left-margin", ¤t_buffer
->left_margin
,
2754 make_number (Lisp_Int
),
2755 "*Column for the default indent-line-function to indent to.\n\
2756 Linefeed indents to this column in Fundamental mode.\n\
2757 Automatically becomes buffer-local when set in any fashion.");
2759 DEFVAR_PER_BUFFER ("tab-width", ¤t_buffer
->tab_width
,
2760 make_number (Lisp_Int
),
2761 "*Distance between tab stops (for display of tab characters), in columns.\n\
2762 Automatically becomes buffer-local when set in any fashion.");
2764 DEFVAR_PER_BUFFER ("ctl-arrow", ¤t_buffer
->ctl_arrow
, Qnil
,
2765 "*Non-nil means display control chars with uparrow.\n\
2766 Nil means use backslash and octal digits.\n\
2767 Automatically becomes buffer-local when set in any fashion.\n\
2768 This variable does not apply to characters whose display is specified\n\
2769 in the current display table (if there is one).");
2771 DEFVAR_PER_BUFFER ("truncate-lines", ¤t_buffer
->truncate_lines
, Qnil
,
2772 "*Non-nil means do not display continuation lines;\n\
2773 give each line of text one screen line.\n\
2774 Automatically becomes buffer-local when set in any fashion.\n\
2776 Note that this is overridden by the variable\n\
2777 `truncate-partial-width-windows' if that variable is non-nil\n\
2778 and this buffer is not full-frame width.");
2781 DEFVAR_PER_BUFFER ("buffer-file-type", ¤t_buffer
->buffer_file_type
,
2783 "*If visited file is text, nil; otherwise, t.");
2786 DEFVAR_PER_BUFFER ("default-directory", ¤t_buffer
->directory
,
2787 make_number (Lisp_String
),
2788 "Name of default directory of current buffer. Should end with slash.\n\
2789 Each buffer has its own value of this variable.");
2791 DEFVAR_PER_BUFFER ("auto-fill-function", ¤t_buffer
->auto_fill_function
,
2793 "Function called (if non-nil) to perform auto-fill.\n\
2794 It is called after self-inserting a space at a column beyond `fill-column'.\n\
2795 Each buffer has its own value of this variable.\n\
2796 NOTE: This variable is not an ordinary hook;\n\
2797 It may not be a list of functions.");
2799 DEFVAR_PER_BUFFER ("buffer-file-name", ¤t_buffer
->filename
,
2800 make_number (Lisp_String
),
2801 "Name of file visited in current buffer, or nil if not visiting a file.\n\
2802 Each buffer has its own value of this variable.");
2804 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
2805 ¤t_buffer
->auto_save_file_name
,
2806 make_number (Lisp_String
),
2807 "Name of file for auto-saving current buffer,\n\
2808 or nil if buffer should not be auto-saved.\n\
2809 Each buffer has its own value of this variable.");
2811 DEFVAR_PER_BUFFER ("buffer-read-only", ¤t_buffer
->read_only
, Qnil
,
2812 "Non-nil if this buffer is read-only.\n\
2813 Each buffer has its own value of this variable.");
2815 DEFVAR_PER_BUFFER ("buffer-backed-up", ¤t_buffer
->backed_up
, Qnil
,
2816 "Non-nil if this buffer's file has been backed up.\n\
2817 Backing up is done before the first time the file is saved.\n\
2818 Each buffer has its own value of this variable.");
2820 DEFVAR_PER_BUFFER ("buffer-saved-size", ¤t_buffer
->save_length
,
2821 make_number (Lisp_Int
),
2822 "Length of current buffer when last read in, saved or auto-saved.\n\
2824 Each buffer has its own value of this variable.");
2826 DEFVAR_PER_BUFFER ("selective-display", ¤t_buffer
->selective_display
,
2828 "Non-nil enables selective display:\n\
2829 Integer N as value means display only lines\n\
2830 that start with less than n columns of space.\n\
2831 A value of t means, after a ^M, all the rest of the line is invisible.\n\
2832 Then ^M's in the file are written into files as newlines.\n\n\
2833 Automatically becomes buffer-local when set in any fashion.");
2836 DEFVAR_PER_BUFFER ("selective-display-ellipses",
2837 ¤t_buffer
->selective_display_ellipses
,
2839 "t means display ... on previous line when a line is invisible.\n\
2840 Automatically becomes buffer-local when set in any fashion.");
2843 DEFVAR_PER_BUFFER ("overwrite-mode", ¤t_buffer
->overwrite_mode
, Qnil
,
2844 "Non-nil if self-insertion should replace existing text.\n\
2845 If non-nil and not `overwrite-mode-binary', self-insertion still\n\
2846 inserts at the end of a line, and inserts when point is before a tab,\n\
2847 until the tab is filled in.\n\
2848 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too.\n\
2849 Automatically becomes buffer-local when set in any fashion.");
2851 #if 0 /* The doc string is too long for some compilers,
2852 but make-docfile can find it in this comment. */
2853 DEFVAR_PER_BUFFER ("buffer-display-table", ¤t_buffer
->display_table
,
2855 "Display table that controls display of the contents of current buffer.\n\
2856 Automatically becomes buffer-local when set in any fashion.\n\
2857 The display table is a vector created with `make-display-table'.\n\
2858 The first 256 elements control how to display each possible text character.\n\
2859 Each value should be a vector of characters or nil;\n\
2860 nil means display the character in the default fashion.\n\
2861 The remaining six elements control the display of\n\
2862 the end of a truncated screen line (element 256, a single character);\n\
2863 the end of a continued line (element 257, a single character);\n\
2864 the escape character used to display character codes in octal\n\
2865 (element 258, a single character);\n\
2866 the character used as an arrow for control characters (element 259,\n\
2867 a single character);\n\
2868 the decoration indicating the presence of invisible lines (element 260,\n\
2869 a vector of characters);\n\
2870 the character used to draw the border between side-by-side windows\n\
2871 (element 261, a single character).\n\
2872 If this variable is nil, the value of `standard-display-table' is used.\n\
2873 Each window can have its own, overriding display table.");
2875 DEFVAR_PER_BUFFER ("buffer-display-table", ¤t_buffer
->display_table
,
2878 /*DEFVAR_LISP ("debug-check-symbol", &Vcheck_symbol,
2881 DEFVAR_LISP ("before-change-function", &Vbefore_change_function
,
2882 "Function to call before each text change.\n\
2883 Two arguments are passed to the function: the positions of\n\
2884 the beginning and end of the range of old text to be changed.\n\
2885 \(For an insertion, the beginning and end are at the same place.)\n\
2886 No information is given about the length of the text after the change.\n\
2888 Buffer changes made while executing the `before-change-function'\n\
2889 don't call any before-change or after-change functions.\n\
2890 That's because these variables are temporarily set to nil.\n\
2891 As a result, a hook function cannot straightforwardly alter the value of\n\
2892 these variables. See the Emacs Lisp manual for a way of\n\
2893 accomplishing an equivalent result by using other variables.");
2894 Vbefore_change_function
= Qnil
;
2896 DEFVAR_LISP ("after-change-function", &Vafter_change_function
,
2897 "Function to call after each text change.\n\
2898 Three arguments are passed to the function: the positions of\n\
2899 the beginning and end of the range of changed text,\n\
2900 and the length of the pre-change text replaced by that range.\n\
2901 \(For an insertion, the pre-change length is zero;\n\
2902 for a deletion, that length is the number of characters deleted,\n\
2903 and the post-change beginning and end are at the same place.)\n\
2905 Buffer changes made while executing the `after-change-function'\n\
2906 don't call any before-change or after-change functions.\n\
2907 That's because these variables are temporarily set to nil.\n\
2908 As a result, a hook function cannot straightforwardly alter the value of\n\
2909 these variables. See the Emacs Lisp manual for a way of\n\
2910 accomplishing an equivalent result by using other variables.");
2911 Vafter_change_function
= Qnil
;
2913 DEFVAR_LISP ("before-change-functions", &Vbefore_change_functions
,
2914 "List of functions to call before each text change.\n\
2915 Two arguments are passed to each function: the positions of\n\
2916 the beginning and end of the range of old text to be changed.\n\
2917 \(For an insertion, the beginning and end are at the same place.)\n\
2918 No information is given about the length of the text after the change.\n\
2920 Buffer changes made while executing the `before-change-functions'\n\
2921 don't call any before-change or after-change functions.\n\
2922 That's because these variables are temporarily set to nil.\n\
2923 As a result, a hook function cannot straightforwardly alter the value of\n\
2924 these variables. See the Emacs Lisp manual for a way of\n\
2925 accomplishing an equivalent result by using other variables.");
2926 Vbefore_change_functions
= Qnil
;
2928 DEFVAR_LISP ("after-change-functions", &Vafter_change_functions
,
2929 "List of function to call after each text change.\n\
2930 Three arguments are passed to each function: the positions of\n\
2931 the beginning and end of the range of changed text,\n\
2932 and the length of the pre-change text replaced by that range.\n\
2933 \(For an insertion, the pre-change length is zero;\n\
2934 for a deletion, that length is the number of characters deleted,\n\
2935 and the post-change beginning and end are at the same place.)\n\
2937 Buffer changes made while executing the `after-change-functions'\n\
2938 don't call any before-change or after-change functions.\n\
2939 That's because these variables are temporarily set to nil.\n\
2940 As a result, a hook function cannot straightforwardly alter the value of\n\
2941 these variables. See the Emacs Lisp manual for a way of\n\
2942 accomplishing an equivalent result by using other variables.");
2944 Vafter_change_functions
= Qnil
;
2946 DEFVAR_LISP ("first-change-hook", &Vfirst_change_hook
,
2947 "A list of functions to call before changing a buffer which is unmodified.\n\
2948 The functions are run using the `run-hooks' function.");
2949 Vfirst_change_hook
= Qnil
;
2950 Qfirst_change_hook
= intern ("first-change-hook");
2951 staticpro (&Qfirst_change_hook
);
2953 #if 0 /* The doc string is too long for some compilers,
2954 but make-docfile can find it in this comment. */
2955 DEFVAR_PER_BUFFER ("buffer-undo-list", ¤t_buffer
->undo_list
, Qnil
,
2956 "List of undo entries in current buffer.\n\
2957 Recent changes come first; older changes follow newer.\n\
2959 An entry (START . END) represents an insertion which begins at\n\
2960 position START and ends at position END.\n\
2962 An entry (TEXT . POSITION) represents the deletion of the string TEXT\n\
2963 from (abs POSITION). If POSITION is positive, point was at the front\n\
2964 of the text being deleted; if negative, point was at the end.\n\
2966 An entry (t HIGHWORD LOWWORD) indicates that the buffer had been\n\
2967 previously unmodified. HIGHWORD and LOWWORD are the high and low\n\
2968 16-bit words of the buffer's modification count at the time. If the\n\
2969 modification count of the most recent save is different, this entry is\n\
2972 An entry (nil PROP VAL BEG . END) indicates that a text property\n\
2973 was modified between BEG and END. PROP is the property name,\n\
2974 and VAL is the old value.\n\
2976 An entry of the form POSITION indicates that point was at the buffer\n\
2977 location given by the integer. Undoing an entry of this form places\n\
2978 point at POSITION.\n\
2980 nil marks undo boundaries. The undo command treats the changes\n\
2981 between two undo boundaries as a single step to be undone.\n\
2983 If the value of the variable is t, undo information is not recorded.");
2985 DEFVAR_PER_BUFFER ("buffer-undo-list", ¤t_buffer
->undo_list
, Qnil
,
2988 DEFVAR_PER_BUFFER ("mark-active", ¤t_buffer
->mark_active
, Qnil
,
2989 "Non-nil means the mark and region are currently active in this buffer.\n\
2990 Automatically local in all buffers.");
2992 DEFVAR_PER_BUFFER ("cache-long-line-scans", ¤t_buffer
->cache_long_line_scans
, Qnil
,
2993 "Non-nil means that Emacs should use caches to handle long lines faster.\n\
2995 Emacs moves from one line to the next by scanning the buffer for\n\
2996 newlines, and it implements columnar operations like move-to-column by\n\
2997 scanning the buffer, adding character widths as it goes. If the\n\
2998 buffer's lines are very long (say, more than 500 characters), these\n\
2999 scans can slow Emacs down a great deal.\n\
3001 If this variable is non-nil, Emacs caches the results of its scans,\n\
3002 and avoids rescanning regions of the buffer until they are modified.\n\
3004 If this variable is non-nil, short scans will become slightly slower,\n\
3005 and the caches will use memory roughly proportional to the number of\n\
3006 newlines and characters whose visual representation can occupy more than\n\
3009 DEFVAR_LISP ("transient-mark-mode", &Vtransient_mark_mode
,
3010 "*Non-nil means deactivate the mark when the buffer contents change.");
3011 Vtransient_mark_mode
= Qnil
;
3013 DEFVAR_LISP ("inhibit-read-only", &Vinhibit_read_only
,
3014 "*Non-nil means disregard read-only status of buffers or characters.\n\
3015 If the value is t, disregard `buffer-read-only' and all `read-only'\n\
3016 text properties. If the value is a list, disregard `buffer-read-only'\n\
3017 and disregard a `read-only' text property if the property value\n\
3018 is a member of the list.");
3019 Vinhibit_read_only
= Qnil
;
3021 DEFVAR_LISP ("kill-buffer-query-functions", &Vkill_buffer_query_functions
,
3022 "List of functions called with no args to query before killing a buffer.");
3023 Vkill_buffer_query_functions
= Qnil
;
3025 defsubr (&Sbuffer_list
);
3026 defsubr (&Sget_buffer
);
3027 defsubr (&Sget_file_buffer
);
3028 defsubr (&Sget_buffer_create
);
3029 defsubr (&Sgenerate_new_buffer_name
);
3030 defsubr (&Sbuffer_name
);
3031 /*defsubr (&Sbuffer_number);*/
3032 defsubr (&Sbuffer_file_name
);
3033 defsubr (&Sbuffer_local_variables
);
3034 defsubr (&Sbuffer_modified_p
);
3035 defsubr (&Sset_buffer_modified_p
);
3036 defsubr (&Sbuffer_modified_tick
);
3037 defsubr (&Srename_buffer
);
3038 defsubr (&Sother_buffer
);
3039 defsubr (&Sbuffer_disable_undo
);
3040 defsubr (&Sbuffer_enable_undo
);
3041 defsubr (&Skill_buffer
);
3042 defsubr (&Serase_buffer
);
3043 defsubr (&Sswitch_to_buffer
);
3044 defsubr (&Spop_to_buffer
);
3045 defsubr (&Scurrent_buffer
);
3046 defsubr (&Sset_buffer
);
3047 defsubr (&Sbarf_if_buffer_read_only
);
3048 defsubr (&Sbury_buffer
);
3049 defsubr (&Slist_buffers
);
3050 defsubr (&Skill_all_local_variables
);
3052 defsubr (&Soverlayp
);
3053 defsubr (&Smake_overlay
);
3054 defsubr (&Sdelete_overlay
);
3055 defsubr (&Smove_overlay
);
3056 defsubr (&Soverlay_start
);
3057 defsubr (&Soverlay_end
);
3058 defsubr (&Soverlay_buffer
);
3059 defsubr (&Soverlay_properties
);
3060 defsubr (&Soverlays_at
);
3061 defsubr (&Snext_overlay_change
);
3062 defsubr (&Sprevious_overlay_change
);
3063 defsubr (&Soverlay_recenter
);
3064 defsubr (&Soverlay_lists
);
3065 defsubr (&Soverlay_get
);
3066 defsubr (&Soverlay_put
);
3071 initial_define_key (control_x_map
, 'b', "switch-to-buffer");
3072 initial_define_key (control_x_map
, 'k', "kill-buffer");
3073 initial_define_key (control_x_map
, Ctl ('B'), "list-buffers");
3075 /* This must not be in syms_of_buffer, because Qdisabled is not
3076 initialized when that function gets called. */
3077 Fput (intern ("erase-buffer"), Qdisabled
, Qt
);