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 /* The current buffer is special-cased to be marked read-only.
1159 It is actually made read-only by the call to
1160 Buffer-menu-mode, below. */
1161 write_string ((b
!= current_buffer
&& NILP (b
->read_only
))
1163 Fprinc (b
->name
, Qnil
);
1164 Findent_to (col1
, make_number (2));
1165 XSETFASTINT (tem
, BUF_Z (b
) - BUF_BEG (b
));
1167 Findent_to (col2
, minspace
);
1168 Fprinc (b
->mode_name
, Qnil
);
1169 Findent_to (col3
, minspace
);
1171 if (!NILP (b
->filename
))
1172 Fprinc (b
->filename
, Qnil
);
1175 /* No visited file; check local value of list-buffers-directory. */
1177 set_buffer_internal (b
);
1178 tem
= Fboundp (other_file_symbol
);
1181 tem
= Fsymbol_value (other_file_symbol
);
1182 Fset_buffer (Vstandard_output
);
1187 Fset_buffer (Vstandard_output
);
1189 write_string ("\n", -1);
1192 tail
= intern ("Buffer-menu-mode");
1193 if ((tem
= Ffboundp (tail
), !NILP (tem
)))
1195 set_buffer_internal (old
);
1196 return desired_point
;
1199 DEFUN ("list-buffers", Flist_buffers
, Slist_buffers
, 0, 1, "P",
1200 "Display a list of names of existing buffers.\n\
1201 The list is displayed in a buffer named `*Buffer List*'.\n\
1202 Note that buffers with names starting with spaces are omitted.\n\
1203 Non-null optional arg FILES-ONLY means mention only file buffers.\n\
1205 The M column contains a * for buffers that are modified.\n\
1206 The R column contains a % for buffers that are read-only.")
1210 Lisp_Object desired_point
;
1213 = internal_with_output_to_temp_buffer ("*Buffer List*",
1214 list_buffers_1
, files
);
1216 if (NUMBERP (desired_point
))
1218 int count
= specpdl_ptr
- specpdl
;
1219 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
1220 Fset_buffer (build_string ("*Buffer List*"));
1221 SET_PT (XINT (desired_point
));
1222 return unbind_to (count
, Qnil
);
1227 DEFUN ("kill-all-local-variables", Fkill_all_local_variables
, Skill_all_local_variables
,
1229 "Switch to Fundamental mode by killing current buffer's local variables.\n\
1230 Most local variable bindings are eliminated so that the default values\n\
1231 become effective once more. Also, the syntax table is set from\n\
1232 `standard-syntax-table', the local keymap is set to nil,\n\
1233 and the abbrev table from `fundamental-mode-abbrev-table'.\n\
1234 This function also forces redisplay of the mode line.\n\
1236 Every function to select a new major mode starts by\n\
1237 calling this function.\n\n\
1238 As a special exception, local variables whose names have\n\
1239 a non-nil `permanent-local' property are not eliminated by this function.\n\
1241 The first thing this function does is run\n\
1242 the normal hook `change-major-mode-hook'.")
1245 register Lisp_Object alist
, sym
, tem
;
1248 if (!NILP (Vrun_hooks
))
1249 call1 (Vrun_hooks
, intern ("change-major-mode-hook"));
1250 oalist
= current_buffer
->local_var_alist
;
1252 /* Make sure no local variables remain set up with this buffer
1253 for their current values. */
1255 for (alist
= oalist
; !NILP (alist
); alist
= XCONS (alist
)->cdr
)
1257 sym
= XCONS (XCONS (alist
)->car
)->car
;
1259 /* Need not do anything if some other buffer's binding is now encached. */
1260 tem
= XCONS (XCONS (XSYMBOL (sym
)->value
)->cdr
)->car
;
1261 if (XBUFFER (tem
) == current_buffer
)
1263 /* Symbol is set up for this buffer's old local value.
1264 Set it up for the current buffer with the default value. */
1266 tem
= XCONS (XCONS (XSYMBOL (sym
)->value
)->cdr
)->cdr
;
1267 /* Store the symbol's current value into the alist entry
1268 it is currently set up for. This is so that, if the
1269 local is marked permanent, and we make it local again below,
1270 we don't lose the value. */
1271 XCONS (XCONS (tem
)->car
)->cdr
1272 = do_symval_forwarding (XCONS (XSYMBOL (sym
)->value
)->car
);
1273 /* Switch to the symbol's default-value alist entry. */
1274 XCONS (tem
)->car
= tem
;
1275 /* Mark it as current for the current buffer. */
1276 XCONS (XCONS (XSYMBOL (sym
)->value
)->cdr
)->car
= Fcurrent_buffer ();
1277 /* Store the current value into any forwarding in the symbol. */
1278 store_symval_forwarding (sym
, XCONS (XSYMBOL (sym
)->value
)->car
,
1283 /* Actually eliminate all local bindings of this buffer. */
1285 reset_buffer_local_variables (current_buffer
);
1287 /* Redisplay mode lines; we are changing major mode. */
1289 update_mode_lines
++;
1291 /* Any which are supposed to be permanent,
1292 make local again, with the same values they had. */
1294 for (alist
= oalist
; !NILP (alist
); alist
= XCONS (alist
)->cdr
)
1296 sym
= XCONS (XCONS (alist
)->car
)->car
;
1297 tem
= Fget (sym
, Qpermanent_local
);
1300 Fmake_local_variable (sym
);
1301 Fset (sym
, XCONS (XCONS (alist
)->car
)->cdr
);
1305 /* Force mode-line redisplay. Useful here because all major mode
1306 commands call this function. */
1307 update_mode_lines
++;
1312 /* Find all the overlays in the current buffer that contain position POS.
1313 Return the number found, and store them in a vector in *VEC_PTR.
1314 Store in *LEN_PTR the size allocated for the vector.
1315 Store in *NEXT_PTR the next position after POS where an overlay starts,
1316 or ZV if there are no more overlays.
1317 Store in *PREV_PTR the previous position after POS where an overlay ends,
1318 or BEGV if there are no previous overlays.
1319 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
1321 *VEC_PTR and *LEN_PTR should contain a valid vector and size
1322 when this function is called.
1324 If EXTEND is non-zero, we make the vector bigger if necessary.
1325 If EXTEND is zero, we never extend the vector,
1326 and we store only as many overlays as will fit.
1327 But we still return the total number of overlays. */
1330 overlays_at (pos
, extend
, vec_ptr
, len_ptr
, next_ptr
, prev_ptr
)
1333 Lisp_Object
**vec_ptr
;
1338 Lisp_Object tail
, overlay
, start
, end
, result
;
1341 Lisp_Object
*vec
= *vec_ptr
;
1344 int inhibit_storing
= 0;
1346 for (tail
= current_buffer
->overlays_before
;
1347 XGCTYPE (tail
) == Lisp_Cons
;
1348 tail
= XCONS (tail
)->cdr
)
1350 int startpos
, endpos
;
1352 overlay
= XCONS (tail
)->car
;
1353 if (XGCTYPE (overlay
) != Lisp_Overlay
)
1356 start
= OVERLAY_START (overlay
);
1357 end
= OVERLAY_END (overlay
);
1358 endpos
= OVERLAY_POSITION (end
);
1367 startpos
= OVERLAY_POSITION (start
);
1368 if (startpos
<= pos
)
1372 /* The supplied vector is full.
1373 Either make it bigger, or don't store any more in it. */
1376 *len_ptr
= len
*= 2;
1377 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
1381 inhibit_storing
= 1;
1384 if (!inhibit_storing
)
1386 /* Keep counting overlays even if we can't return them all. */
1389 else if (startpos
< next
)
1393 for (tail
= current_buffer
->overlays_after
;
1394 XGCTYPE (tail
) == Lisp_Cons
;
1395 tail
= XCONS (tail
)->cdr
)
1397 int startpos
, endpos
;
1399 overlay
= XCONS (tail
)->car
;
1400 if (XGCTYPE (overlay
) != Lisp_Overlay
)
1403 start
= OVERLAY_START (overlay
);
1404 end
= OVERLAY_END (overlay
);
1405 startpos
= OVERLAY_POSITION (start
);
1408 if (startpos
< next
)
1412 endpos
= OVERLAY_POSITION (end
);
1419 *len_ptr
= len
*= 2;
1420 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
1424 inhibit_storing
= 1;
1427 if (!inhibit_storing
)
1431 else if (endpos
< pos
&& endpos
> prev
)
1444 Lisp_Object overlay
;
1450 compare_overlays (s1
, s2
)
1451 struct sortvec
*s1
, *s2
;
1453 if (s1
->priority
!= s2
->priority
)
1454 return s1
->priority
- s2
->priority
;
1455 if (s1
->beg
!= s2
->beg
)
1456 return s1
->beg
- s2
->beg
;
1457 if (s1
->end
!= s2
->end
)
1458 return s2
->end
- s1
->end
;
1462 /* Sort an array of overlays by priority. The array is modified in place.
1463 The return value is the new size; this may be smaller than the original
1464 size if some of the overlays were invalid or were window-specific. */
1466 sort_overlays (overlay_vec
, noverlays
, w
)
1467 Lisp_Object
*overlay_vec
;
1472 struct sortvec
*sortvec
;
1473 sortvec
= (struct sortvec
*) alloca (noverlays
* sizeof (struct sortvec
));
1475 /* Put the valid and relevant overlays into sortvec. */
1477 for (i
= 0, j
= 0; i
< noverlays
; i
++)
1480 Lisp_Object overlay
;
1482 overlay
= overlay_vec
[i
];
1483 if (OVERLAY_VALID (overlay
)
1484 && OVERLAY_POSITION (OVERLAY_START (overlay
)) > 0
1485 && OVERLAY_POSITION (OVERLAY_END (overlay
)) > 0)
1487 /* If we're interested in a specific window, then ignore
1488 overlays that are limited to some other window. */
1493 window
= Foverlay_get (overlay
, Qwindow
);
1494 if (WINDOWP (window
) && XWINDOW (window
) != w
)
1498 /* This overlay is good and counts: put it into sortvec. */
1499 sortvec
[j
].overlay
= overlay
;
1500 sortvec
[j
].beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
1501 sortvec
[j
].end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
1502 tem
= Foverlay_get (overlay
, Qpriority
);
1504 sortvec
[j
].priority
= XINT (tem
);
1506 sortvec
[j
].priority
= 0;
1512 /* Sort the overlays into the proper order: increasing priority. */
1515 qsort (sortvec
, noverlays
, sizeof (struct sortvec
), compare_overlays
);
1517 for (i
= 0; i
< noverlays
; i
++)
1518 overlay_vec
[i
] = sortvec
[i
].overlay
;
1522 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
1525 recenter_overlay_lists (buf
, pos
)
1529 Lisp_Object overlay
, tail
, next
, prev
, beg
, end
;
1531 /* See if anything in overlays_before should move to overlays_after. */
1533 /* We don't strictly need prev in this loop; it should always be nil.
1534 But we use it for symmetry and in case that should cease to be true
1535 with some future change. */
1537 for (tail
= buf
->overlays_before
;
1539 prev
= tail
, tail
= next
)
1541 next
= XCONS (tail
)->cdr
;
1542 overlay
= XCONS (tail
)->car
;
1544 /* If the overlay is not valid, get rid of it. */
1545 if (!OVERLAY_VALID (overlay
))
1550 /* Splice the cons cell TAIL out of overlays_before. */
1552 XCONS (prev
)->cdr
= next
;
1554 buf
->overlays_before
= next
;
1560 beg
= OVERLAY_START (overlay
);
1561 end
= OVERLAY_END (overlay
);
1563 if (OVERLAY_POSITION (end
) > pos
)
1565 /* OVERLAY needs to be moved. */
1566 int where
= OVERLAY_POSITION (beg
);
1567 Lisp_Object other
, other_prev
;
1569 /* Splice the cons cell TAIL out of overlays_before. */
1571 XCONS (prev
)->cdr
= next
;
1573 buf
->overlays_before
= next
;
1575 /* Search thru overlays_after for where to put it. */
1577 for (other
= buf
->overlays_after
;
1579 other_prev
= other
, other
= XCONS (other
)->cdr
)
1581 Lisp_Object otherbeg
, otheroverlay
, follower
;
1584 otheroverlay
= XCONS (other
)->car
;
1585 if (! OVERLAY_VALID (otheroverlay
))
1588 otherbeg
= OVERLAY_START (otheroverlay
);
1589 if (OVERLAY_POSITION (otherbeg
) >= where
)
1593 /* Add TAIL to overlays_after before OTHER. */
1594 XCONS (tail
)->cdr
= other
;
1595 if (!NILP (other_prev
))
1596 XCONS (other_prev
)->cdr
= tail
;
1598 buf
->overlays_after
= tail
;
1602 /* We've reached the things that should stay in overlays_before.
1603 All the rest of overlays_before must end even earlier,
1608 /* See if anything in overlays_after should be in overlays_before. */
1610 for (tail
= buf
->overlays_after
;
1612 prev
= tail
, tail
= next
)
1614 next
= XCONS (tail
)->cdr
;
1615 overlay
= XCONS (tail
)->car
;
1617 /* If the overlay is not valid, get rid of it. */
1618 if (!OVERLAY_VALID (overlay
))
1623 /* Splice the cons cell TAIL out of overlays_after. */
1625 XCONS (prev
)->cdr
= next
;
1627 buf
->overlays_after
= next
;
1633 beg
= OVERLAY_START (overlay
);
1634 end
= OVERLAY_END (overlay
);
1636 /* Stop looking, when we know that nothing further
1637 can possibly end before POS. */
1638 if (OVERLAY_POSITION (beg
) > pos
)
1641 if (OVERLAY_POSITION (end
) <= pos
)
1643 /* OVERLAY needs to be moved. */
1644 int where
= OVERLAY_POSITION (end
);
1645 Lisp_Object other
, other_prev
;
1647 /* Splice the cons cell TAIL out of overlays_after. */
1649 XCONS (prev
)->cdr
= next
;
1651 buf
->overlays_after
= next
;
1653 /* Search thru overlays_before for where to put it. */
1655 for (other
= buf
->overlays_before
;
1657 other_prev
= other
, other
= XCONS (other
)->cdr
)
1659 Lisp_Object otherend
, otheroverlay
;
1662 otheroverlay
= XCONS (other
)->car
;
1663 if (! OVERLAY_VALID (otheroverlay
))
1666 otherend
= OVERLAY_END (otheroverlay
);
1667 if (OVERLAY_POSITION (otherend
) <= where
)
1671 /* Add TAIL to overlays_before before OTHER. */
1672 XCONS (tail
)->cdr
= other
;
1673 if (!NILP (other_prev
))
1674 XCONS (other_prev
)->cdr
= tail
;
1676 buf
->overlays_before
= tail
;
1681 XSETFASTINT (buf
->overlay_center
, pos
);
1684 /* Fix up overlays that were garbled as a result of permuting markers
1685 in the range START through END. Any overlay with at least one
1686 endpoint in this range will need to be unlinked from the overlay
1687 list and reinserted in its proper place.
1688 Such an overlay might even have negative size at this point.
1689 If so, we'll reverse the endpoints. Can you think of anything
1690 better to do in this situation? */
1692 fix_overlays_in_range (start
, end
)
1693 register int start
, end
;
1695 Lisp_Object tem
, overlay
;
1696 Lisp_Object before_list
, after_list
;
1697 Lisp_Object
*ptail
, *pbefore
= &before_list
, *pafter
= &after_list
;
1698 int startpos
, endpos
;
1700 /* This algorithm shifts links around instead of consing and GCing.
1701 The loop invariant is that before_list (resp. after_list) is a
1702 well-formed list except that its last element, the one that
1703 *pbefore (resp. *pafter) points to, is still uninitialized.
1704 So it's not a bug that before_list isn't initialized, although
1705 it may look strange. */
1706 for (ptail
= ¤t_buffer
->overlays_before
; CONSP (*ptail
);)
1708 overlay
= XCONS (*ptail
)->car
;
1709 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
1712 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
1714 || (startpos
>= start
&& startpos
< end
))
1716 /* If the overlay is backwards, fix that now. */
1717 if (startpos
> endpos
)
1720 Fset_marker (OVERLAY_START (overlay
), endpos
, Qnil
);
1721 Fset_marker (OVERLAY_END (overlay
), startpos
, Qnil
);
1722 tem
= startpos
; startpos
= endpos
; endpos
= tem
;
1724 /* Add it to the end of the wrong list. Later on,
1725 recenter_overlay_lists will move it to the right place. */
1726 if (endpos
< XINT (current_buffer
->overlay_center
))
1729 pafter
= &XCONS (*ptail
)->cdr
;
1734 pbefore
= &XCONS (*ptail
)->cdr
;
1736 *ptail
= XCONS (*ptail
)->cdr
;
1739 ptail
= &XCONS (*ptail
)->cdr
;
1741 for (ptail
= ¤t_buffer
->overlays_after
; CONSP (*ptail
);)
1743 overlay
= XCONS (*ptail
)->car
;
1744 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
1745 if (startpos
>= end
)
1747 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
1748 if (startpos
>= start
1749 || (endpos
>= start
&& endpos
< end
))
1751 if (startpos
> endpos
)
1754 Fset_marker (OVERLAY_START (overlay
), endpos
, Qnil
);
1755 Fset_marker (OVERLAY_END (overlay
), startpos
, Qnil
);
1756 tem
= startpos
; startpos
= endpos
; endpos
= tem
;
1758 if (endpos
< XINT (current_buffer
->overlay_center
))
1761 pafter
= &XCONS (*ptail
)->cdr
;
1766 pbefore
= &XCONS (*ptail
)->cdr
;
1768 *ptail
= XCONS (*ptail
)->cdr
;
1771 ptail
= &XCONS (*ptail
)->cdr
;
1774 /* Splice the constructed (wrong) lists into the buffer's lists,
1775 and let the recenter function make it sane again. */
1776 *pbefore
= current_buffer
->overlays_before
;
1777 current_buffer
->overlays_before
= before_list
;
1778 recenter_overlay_lists (current_buffer
,
1779 XINT (current_buffer
->overlay_center
));
1781 *pafter
= current_buffer
->overlays_after
;
1782 current_buffer
->overlays_after
= after_list
;
1783 recenter_overlay_lists (current_buffer
,
1784 XINT (current_buffer
->overlay_center
));
1787 DEFUN ("overlayp", Foverlayp
, Soverlayp
, 1, 1, 0,
1788 "Return t if OBJECT is an overlay.")
1792 return (OVERLAYP (object
) ? Qt
: Qnil
);
1795 DEFUN ("make-overlay", Fmake_overlay
, Smake_overlay
, 2, 3, 0,
1796 "Create a new overlay with range BEG to END in BUFFER.\n\
1797 If omitted, BUFFER defaults to the current buffer.\n\
1798 BEG and END may be integers or markers.")
1800 Lisp_Object beg
, end
, buffer
;
1802 Lisp_Object overlay
;
1806 XSETBUFFER (buffer
, current_buffer
);
1808 CHECK_BUFFER (buffer
, 2);
1810 && ! EQ (Fmarker_buffer (beg
), buffer
))
1811 error ("Marker points into wrong buffer");
1813 && ! EQ (Fmarker_buffer (end
), buffer
))
1814 error ("Marker points into wrong buffer");
1816 CHECK_NUMBER_COERCE_MARKER (beg
, 1);
1817 CHECK_NUMBER_COERCE_MARKER (end
, 1);
1819 if (XINT (beg
) > XINT (end
))
1822 temp
= beg
; beg
= end
; end
= temp
;
1825 b
= XBUFFER (buffer
);
1827 beg
= Fset_marker (Fmake_marker (), beg
, buffer
);
1828 end
= Fset_marker (Fmake_marker (), end
, buffer
);
1830 overlay
= Fcons (Fcons (beg
, end
), Qnil
);
1831 XSETTYPE (overlay
, Lisp_Overlay
);
1833 /* Put the new overlay on the wrong list. */
1834 end
= OVERLAY_END (overlay
);
1835 if (OVERLAY_POSITION (end
) < XINT (b
->overlay_center
))
1836 b
->overlays_after
= Fcons (overlay
, b
->overlays_after
);
1838 b
->overlays_before
= Fcons (overlay
, b
->overlays_before
);
1840 /* This puts it in the right list, and in the right order. */
1841 recenter_overlay_lists (b
, XINT (b
->overlay_center
));
1843 /* We don't need to redisplay the region covered by the overlay, because
1844 the overlay has no properties at the moment. */
1849 DEFUN ("move-overlay", Fmove_overlay
, Smove_overlay
, 3, 4, 0,
1850 "Set the endpoints of OVERLAY to BEG and END in BUFFER.\n\
1851 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.\n\
1852 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current\n\
1854 (overlay
, beg
, end
, buffer
)
1855 Lisp_Object overlay
, beg
, end
, buffer
;
1857 struct buffer
*b
, *ob
;
1858 Lisp_Object obuffer
;
1859 int count
= specpdl_ptr
- specpdl
;
1861 CHECK_OVERLAY (overlay
, 0);
1863 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
1865 XSETBUFFER (buffer
, current_buffer
);
1866 CHECK_BUFFER (buffer
, 3);
1869 && ! EQ (Fmarker_buffer (beg
), buffer
))
1870 error ("Marker points into wrong buffer");
1872 && ! EQ (Fmarker_buffer (end
), buffer
))
1873 error ("Marker points into wrong buffer");
1875 CHECK_NUMBER_COERCE_MARKER (beg
, 1);
1876 CHECK_NUMBER_COERCE_MARKER (end
, 1);
1878 if (XINT (beg
) == XINT (end
) && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
1879 return Fdelete_overlay (overlay
);
1881 if (XINT (beg
) > XINT (end
))
1884 temp
= beg
; beg
= end
; end
= temp
;
1887 specbind (Qinhibit_quit
, Qt
);
1889 obuffer
= Fmarker_buffer (OVERLAY_START (overlay
));
1890 b
= XBUFFER (buffer
);
1891 ob
= XBUFFER (obuffer
);
1893 /* If the overlay has changed buffers, do a thorough redisplay. */
1894 if (!EQ (buffer
, obuffer
))
1896 /* Redisplay where the overlay was. */
1897 if (!NILP (obuffer
))
1902 o_beg
= OVERLAY_START (overlay
);
1903 o_end
= OVERLAY_END (overlay
);
1904 o_beg
= OVERLAY_POSITION (o_beg
);
1905 o_end
= OVERLAY_POSITION (o_end
);
1907 redisplay_region (ob
, XINT (o_beg
), XINT (o_end
));
1910 /* Redisplay where the overlay is going to be. */
1911 redisplay_region (b
, XINT (beg
), XINT (end
));
1913 /* Don't limit redisplay to the selected window. */
1914 windows_or_buffers_changed
= 1;
1917 /* Redisplay the area the overlay has just left, or just enclosed. */
1921 int change_beg
, change_end
;
1923 o_beg
= OVERLAY_START (overlay
);
1924 o_end
= OVERLAY_END (overlay
);
1925 o_beg
= OVERLAY_POSITION (o_beg
);
1926 o_end
= OVERLAY_POSITION (o_end
);
1928 if (XINT (o_beg
) == XINT (beg
))
1929 redisplay_region (b
, XINT (o_end
), XINT (end
));
1930 else if (XINT (o_end
) == XINT (end
))
1931 redisplay_region (b
, XINT (o_beg
), XINT (beg
));
1934 if (XINT (beg
) < XINT (o_beg
)) o_beg
= beg
;
1935 if (XINT (end
) > XINT (o_end
)) o_end
= end
;
1936 redisplay_region (b
, XINT (o_beg
), XINT (o_end
));
1940 if (!NILP (obuffer
))
1942 ob
->overlays_before
= Fdelq (overlay
, ob
->overlays_before
);
1943 ob
->overlays_after
= Fdelq (overlay
, ob
->overlays_after
);
1946 Fset_marker (OVERLAY_START (overlay
), beg
, buffer
);
1947 Fset_marker (OVERLAY_END (overlay
), end
, buffer
);
1949 /* Put the overlay on the wrong list. */
1950 end
= OVERLAY_END (overlay
);
1951 if (OVERLAY_POSITION (end
) < XINT (b
->overlay_center
))
1952 b
->overlays_after
= Fcons (overlay
, b
->overlays_after
);
1954 b
->overlays_before
= Fcons (overlay
, b
->overlays_before
);
1956 /* This puts it in the right list, and in the right order. */
1957 recenter_overlay_lists (b
, XINT (b
->overlay_center
));
1959 return unbind_to (count
, overlay
);
1962 DEFUN ("delete-overlay", Fdelete_overlay
, Sdelete_overlay
, 1, 1, 0,
1963 "Delete the overlay OVERLAY from its buffer.")
1965 Lisp_Object overlay
;
1969 int count
= specpdl_ptr
- specpdl
;
1971 CHECK_OVERLAY (overlay
, 0);
1973 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
1977 b
= XBUFFER (buffer
);
1979 specbind (Qinhibit_quit
, Qt
);
1981 b
->overlays_before
= Fdelq (overlay
, b
->overlays_before
);
1982 b
->overlays_after
= Fdelq (overlay
, b
->overlays_after
);
1984 redisplay_region (b
,
1985 marker_position (OVERLAY_START (overlay
)),
1986 marker_position (OVERLAY_END (overlay
)));
1988 Fset_marker (OVERLAY_START (overlay
), Qnil
, Qnil
);
1989 Fset_marker (OVERLAY_END (overlay
), Qnil
, Qnil
);
1991 return unbind_to (count
, Qnil
);
1994 /* Overlay dissection functions. */
1996 DEFUN ("overlay-start", Foverlay_start
, Soverlay_start
, 1, 1, 0,
1997 "Return the position at which OVERLAY starts.")
1999 Lisp_Object overlay
;
2001 CHECK_OVERLAY (overlay
, 0);
2003 return (Fmarker_position (OVERLAY_START (overlay
)));
2006 DEFUN ("overlay-end", Foverlay_end
, Soverlay_end
, 1, 1, 0,
2007 "Return the position at which OVERLAY ends.")
2009 Lisp_Object overlay
;
2011 CHECK_OVERLAY (overlay
, 0);
2013 return (Fmarker_position (OVERLAY_END (overlay
)));
2016 DEFUN ("overlay-buffer", Foverlay_buffer
, Soverlay_buffer
, 1, 1, 0,
2017 "Return the buffer OVERLAY belongs to.")
2019 Lisp_Object overlay
;
2021 CHECK_OVERLAY (overlay
, 0);
2023 return Fmarker_buffer (OVERLAY_START (overlay
));
2026 DEFUN ("overlay-properties", Foverlay_properties
, Soverlay_properties
, 1, 1, 0,
2027 "Return a list of the properties on OVERLAY.\n\
2028 This is a copy of OVERLAY's plist; modifying its conses has no effect on\n\
2031 Lisp_Object overlay
;
2033 CHECK_OVERLAY (overlay
, 0);
2035 return Fcopy_sequence (Fcdr_safe (XCONS (overlay
)->cdr
));
2039 DEFUN ("overlays-at", Foverlays_at
, Soverlays_at
, 1, 1, 0,
2040 "Return a list of the overlays that contain position POS.")
2045 Lisp_Object
*overlay_vec
;
2049 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
2052 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
2054 /* Put all the overlays we want in a vector in overlay_vec.
2055 Store the length in len. */
2056 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
, NULL
, NULL
);
2058 /* Make a list of them all. */
2059 result
= Flist (noverlays
, overlay_vec
);
2061 xfree (overlay_vec
);
2065 DEFUN ("next-overlay-change", Fnext_overlay_change
, Snext_overlay_change
,
2067 "Return the next position after POS where an overlay starts or ends.\n\
2068 If there are no more overlay boundaries after POS, return (point-max).")
2074 Lisp_Object
*overlay_vec
;
2078 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
2081 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
2083 /* Put all the overlays we want in a vector in overlay_vec.
2084 Store the length in len.
2085 endpos gets the position where the next overlay starts. */
2086 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
, &endpos
, NULL
);
2088 /* If any of these overlays ends before endpos,
2089 use its ending point instead. */
2090 for (i
= 0; i
< noverlays
; i
++)
2095 oend
= OVERLAY_END (overlay_vec
[i
]);
2096 oendpos
= OVERLAY_POSITION (oend
);
2097 if (oendpos
< endpos
)
2101 xfree (overlay_vec
);
2102 return make_number (endpos
);
2105 DEFUN ("previous-overlay-change", Fprevious_overlay_change
,
2106 Sprevious_overlay_change
, 1, 1, 0,
2107 "Return the previous position before POS where an overlay starts or ends.\n\
2108 If there are no more overlay boundaries after POS, return (point-min).")
2114 Lisp_Object
*overlay_vec
;
2118 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
2121 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
2123 /* Put all the overlays we want in a vector in overlay_vec.
2124 Store the length in len.
2125 prevpos gets the position of an overlay end. */
2126 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
, NULL
, &prevpos
);
2128 /* If any of these overlays starts before endpos,
2129 maybe use its starting point instead. */
2130 for (i
= 0; i
< noverlays
; i
++)
2135 ostart
= OVERLAY_START (overlay_vec
[i
]);
2136 ostartpos
= OVERLAY_POSITION (ostart
);
2137 if (ostartpos
> prevpos
&& ostartpos
< XINT (pos
))
2138 prevpos
= ostartpos
;
2141 xfree (overlay_vec
);
2142 return make_number (prevpos
);
2145 /* These functions are for debugging overlays. */
2147 DEFUN ("overlay-lists", Foverlay_lists
, Soverlay_lists
, 0, 0, 0,
2148 "Return a pair of lists giving all the overlays of the current buffer.\n\
2149 The car has all the overlays before the overlay center;\n\
2150 the cdr has all the overlays after the overlay center.\n\
2151 Recentering overlays moves overlays between these lists.\n\
2152 The lists you get are copies, so that changing them has no effect.\n\
2153 However, the overlays you get are the real objects that the buffer uses.")
2156 Lisp_Object before
, after
;
2157 before
= current_buffer
->overlays_before
;
2159 before
= Fcopy_sequence (before
);
2160 after
= current_buffer
->overlays_after
;
2162 after
= Fcopy_sequence (after
);
2164 return Fcons (before
, after
);
2167 DEFUN ("overlay-recenter", Foverlay_recenter
, Soverlay_recenter
, 1, 1, 0,
2168 "Recenter the overlays of the current buffer around position POS.")
2172 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
2174 recenter_overlay_lists (current_buffer
, XINT (pos
));
2178 DEFUN ("overlay-get", Foverlay_get
, Soverlay_get
, 2, 2, 0,
2179 "Get the property of overlay OVERLAY with property name NAME.")
2181 Lisp_Object overlay
, prop
;
2183 Lisp_Object plist
, fallback
;
2185 CHECK_OVERLAY (overlay
, 0);
2189 for (plist
= Fcdr_safe (XCONS (overlay
)->cdr
);
2190 CONSP (plist
) && CONSP (XCONS (plist
)->cdr
);
2191 plist
= XCONS (XCONS (plist
)->cdr
)->cdr
)
2193 if (EQ (XCONS (plist
)->car
, prop
))
2194 return XCONS (XCONS (plist
)->cdr
)->car
;
2195 else if (EQ (XCONS (plist
)->car
, Qcategory
))
2198 tem
= Fcar (Fcdr (plist
));
2200 fallback
= Fget (tem
, prop
);
2207 DEFUN ("overlay-put", Foverlay_put
, Soverlay_put
, 3, 3, 0,
2208 "Set one property of overlay OVERLAY: give property PROP value VALUE.")
2209 (overlay
, prop
, value
)
2210 Lisp_Object overlay
, prop
, value
;
2212 Lisp_Object plist
, tail
, buffer
;
2215 CHECK_OVERLAY (overlay
, 0);
2217 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
2219 plist
= Fcdr_safe (XCONS (overlay
)->cdr
);
2222 CONSP (tail
) && CONSP (XCONS (tail
)->cdr
);
2223 tail
= XCONS (XCONS (tail
)->cdr
)->cdr
)
2224 if (EQ (XCONS (tail
)->car
, prop
))
2226 changed
= !EQ (XCONS (XCONS (tail
)->cdr
)->car
, value
);
2227 XCONS (XCONS (tail
)->cdr
)->car
= value
;
2230 /* It wasn't in the list, so add it to the front. */
2231 changed
= !NILP (value
);
2232 if (! CONSP (XCONS (overlay
)->cdr
))
2233 XCONS (overlay
)->cdr
= Fcons (Qnil
, Qnil
);
2234 XCONS (XCONS (overlay
)->cdr
)->cdr
= Fcons (prop
, Fcons (value
, plist
));
2236 if (! NILP (buffer
))
2239 redisplay_region (XBUFFER (buffer
),
2240 marker_position (OVERLAY_START (overlay
)),
2241 marker_position (OVERLAY_END (overlay
)));
2242 if (EQ (prop
, Qevaporate
) && ! NILP (value
)
2243 && (OVERLAY_POSITION (OVERLAY_START (overlay
))
2244 == OVERLAY_POSITION (OVERLAY_END (overlay
))))
2245 Fdelete_overlay (overlay
);
2250 /* Run the modification-hooks of overlays that include
2251 any part of the text in START to END.
2252 Run the insert-before-hooks of overlay starting at END,
2253 and the insert-after-hooks of overlay ending at START. */
2256 verify_overlay_modification (start
, end
)
2257 Lisp_Object start
, end
;
2259 Lisp_Object prop
, overlay
, tail
;
2260 int insertion
= EQ (start
, end
);
2262 struct gcpro gcpro1
, gcpro2
;
2266 GCPRO2 (overlay
, tail
);
2269 for (tail
= current_buffer
->overlays_before
;
2271 tail
= XCONS (tail
)->cdr
)
2273 int startpos
, endpos
;
2274 Lisp_Object ostart
, oend
;
2276 overlay
= XCONS (tail
)->car
;
2278 ostart
= OVERLAY_START (overlay
);
2279 oend
= OVERLAY_END (overlay
);
2280 endpos
= OVERLAY_POSITION (oend
);
2281 if (XFASTINT (start
) > endpos
)
2283 startpos
= OVERLAY_POSITION (ostart
);
2284 if (XFASTINT (end
) == startpos
&& insertion
)
2286 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
2289 /* Copy TAIL in case the hook recenters the overlay lists. */
2291 tail
= Fcopy_sequence (tail
);
2293 call_overlay_mod_hooks (prop
, overlay
, start
, end
);
2296 if (XFASTINT (start
) == endpos
&& insertion
)
2298 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
2302 tail
= Fcopy_sequence (tail
);
2304 call_overlay_mod_hooks (prop
, overlay
, start
, end
);
2307 /* Test for intersecting intervals. This does the right thing
2308 for both insertion and deletion. */
2309 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
2311 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
2315 tail
= Fcopy_sequence (tail
);
2317 call_overlay_mod_hooks (prop
, overlay
, start
, end
);
2323 for (tail
= current_buffer
->overlays_after
;
2325 tail
= XCONS (tail
)->cdr
)
2327 int startpos
, endpos
;
2328 Lisp_Object ostart
, oend
;
2330 overlay
= XCONS (tail
)->car
;
2332 ostart
= OVERLAY_START (overlay
);
2333 oend
= OVERLAY_END (overlay
);
2334 startpos
= OVERLAY_POSITION (ostart
);
2335 endpos
= OVERLAY_POSITION (oend
);
2336 if (XFASTINT (end
) < startpos
)
2338 if (XFASTINT (end
) == startpos
&& insertion
)
2340 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
2344 tail
= Fcopy_sequence (tail
);
2346 call_overlay_mod_hooks (prop
, overlay
, start
, end
);
2349 if (XFASTINT (start
) == endpos
&& insertion
)
2351 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
2355 tail
= Fcopy_sequence (tail
);
2357 call_overlay_mod_hooks (prop
, overlay
, start
, end
);
2360 /* Test for intersecting intervals. This does the right thing
2361 for both insertion and deletion. */
2362 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
2364 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
2368 tail
= Fcopy_sequence (tail
);
2370 call_overlay_mod_hooks (prop
, overlay
, start
, end
);
2379 call_overlay_mod_hooks (list
, overlay
, start
, end
)
2380 Lisp_Object list
, overlay
, start
, end
;
2382 struct gcpro gcpro1
;
2384 while (!NILP (list
))
2386 call3 (Fcar (list
), overlay
, start
, end
);
2392 /* Delete any zero-sized overlays at position POS, if the `evaporate'
2395 evaporate_overlays (pos
)
2398 Lisp_Object tail
, overlay
, hit_list
;
2401 if (pos
<= XFASTINT (current_buffer
->overlay_center
))
2402 for (tail
= current_buffer
->overlays_before
; CONSP (tail
);
2403 tail
= XCONS (tail
)->cdr
)
2406 overlay
= XCONS (tail
)->car
;
2407 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2410 if (endpos
== pos
&& OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
2411 && Foverlay_get (overlay
, Qevaporate
))
2412 hit_list
= Fcons (overlay
, hit_list
);
2415 for (tail
= current_buffer
->overlays_after
; CONSP (tail
);
2416 tail
= XCONS (tail
)->cdr
)
2419 overlay
= XCONS (tail
)->car
;
2420 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2423 if (startpos
== pos
&& OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
2424 && Foverlay_get (overlay
, Qevaporate
))
2425 hit_list
= Fcons (overlay
, hit_list
);
2427 for (; CONSP (hit_list
); hit_list
= XCONS (hit_list
)->cdr
)
2428 Fdelete_overlay (XCONS (hit_list
)->car
);
2431 /* Somebody has tried to store a value with an unacceptable type
2432 into the buffer-local slot with offset OFFSET. */
2434 buffer_slot_type_mismatch (offset
)
2439 sym
= *(Lisp_Object
*)(offset
+ (char *)&buffer_local_symbols
);
2440 switch (XINT (*(Lisp_Object
*)(offset
+ (char *)&buffer_local_types
)))
2442 case Lisp_Int
: type_name
= "integers"; break;
2443 case Lisp_String
: type_name
= "strings"; break;
2444 case Lisp_Symbol
: type_name
= "symbols"; break;
2449 error ("only %s should be stored in the buffer-local variable %s",
2450 type_name
, XSYMBOL (sym
)->name
->data
);
2455 register Lisp_Object tem
;
2457 /* Make sure all markable slots in buffer_defaults
2458 are initialized reasonably, so mark_buffer won't choke. */
2459 reset_buffer (&buffer_defaults
);
2460 reset_buffer_local_variables (&buffer_defaults
);
2461 reset_buffer (&buffer_local_symbols
);
2462 reset_buffer_local_variables (&buffer_local_symbols
);
2463 XSETBUFFER (Vbuffer_defaults
, &buffer_defaults
);
2464 XSETBUFFER (Vbuffer_local_symbols
, &buffer_local_symbols
);
2466 /* Set up the default values of various buffer slots. */
2467 /* Must do these before making the first buffer! */
2469 /* real setup is done in loaddefs.el */
2470 buffer_defaults
.mode_line_format
= build_string ("%-");
2471 buffer_defaults
.abbrev_mode
= Qnil
;
2472 buffer_defaults
.overwrite_mode
= Qnil
;
2473 buffer_defaults
.case_fold_search
= Qt
;
2474 buffer_defaults
.auto_fill_function
= Qnil
;
2475 buffer_defaults
.selective_display
= Qnil
;
2477 buffer_defaults
.selective_display_ellipses
= Qt
;
2479 buffer_defaults
.abbrev_table
= Qnil
;
2480 buffer_defaults
.display_table
= Qnil
;
2481 buffer_defaults
.undo_list
= Qnil
;
2482 buffer_defaults
.mark_active
= Qnil
;
2483 buffer_defaults
.overlays_before
= Qnil
;
2484 buffer_defaults
.overlays_after
= Qnil
;
2485 XSETFASTINT (buffer_defaults
.overlay_center
, 1);
2487 XSETFASTINT (buffer_defaults
.tab_width
, 8);
2488 buffer_defaults
.truncate_lines
= Qnil
;
2489 buffer_defaults
.ctl_arrow
= Qt
;
2492 buffer_defaults
.buffer_file_type
= Qnil
; /* TEXT */
2494 XSETFASTINT (buffer_defaults
.fill_column
, 70);
2495 XSETFASTINT (buffer_defaults
.left_margin
, 0);
2496 buffer_defaults
.cache_long_line_scans
= Qnil
;
2498 /* Assign the local-flags to the slots that have default values.
2499 The local flag is a bit that is used in the buffer
2500 to say that it has its own local value for the slot.
2501 The local flag bits are in the local_var_flags slot of the buffer. */
2503 /* Nothing can work if this isn't true */
2504 if (sizeof (EMACS_INT
) != sizeof (Lisp_Object
)) abort ();
2506 /* 0 means not a lisp var, -1 means always local, else mask */
2507 bzero (&buffer_local_flags
, sizeof buffer_local_flags
);
2508 XSETINT (buffer_local_flags
.filename
, -1);
2509 XSETINT (buffer_local_flags
.directory
, -1);
2510 XSETINT (buffer_local_flags
.backed_up
, -1);
2511 XSETINT (buffer_local_flags
.save_length
, -1);
2512 XSETINT (buffer_local_flags
.auto_save_file_name
, -1);
2513 XSETINT (buffer_local_flags
.read_only
, -1);
2514 XSETINT (buffer_local_flags
.major_mode
, -1);
2515 XSETINT (buffer_local_flags
.mode_name
, -1);
2516 XSETINT (buffer_local_flags
.undo_list
, -1);
2517 XSETINT (buffer_local_flags
.mark_active
, -1);
2519 XSETFASTINT (buffer_local_flags
.mode_line_format
, 1);
2520 XSETFASTINT (buffer_local_flags
.abbrev_mode
, 2);
2521 XSETFASTINT (buffer_local_flags
.overwrite_mode
, 4);
2522 XSETFASTINT (buffer_local_flags
.case_fold_search
, 8);
2523 XSETFASTINT (buffer_local_flags
.auto_fill_function
, 0x10);
2524 XSETFASTINT (buffer_local_flags
.selective_display
, 0x20);
2526 XSETFASTINT (buffer_local_flags
.selective_display_ellipses
, 0x40);
2528 XSETFASTINT (buffer_local_flags
.tab_width
, 0x80);
2529 XSETFASTINT (buffer_local_flags
.truncate_lines
, 0x100);
2530 XSETFASTINT (buffer_local_flags
.ctl_arrow
, 0x200);
2531 XSETFASTINT (buffer_local_flags
.fill_column
, 0x400);
2532 XSETFASTINT (buffer_local_flags
.left_margin
, 0x800);
2533 XSETFASTINT (buffer_local_flags
.abbrev_table
, 0x1000);
2534 XSETFASTINT (buffer_local_flags
.display_table
, 0x2000);
2535 XSETFASTINT (buffer_local_flags
.syntax_table
, 0x8000);
2536 XSETFASTINT (buffer_local_flags
.cache_long_line_scans
, 0x10000);
2538 XSETFASTINT (buffer_local_flags
.buffer_file_type
, 0x4000);
2541 Vbuffer_alist
= Qnil
;
2545 QSFundamental
= build_string ("Fundamental");
2547 Qfundamental_mode
= intern ("fundamental-mode");
2548 buffer_defaults
.major_mode
= Qfundamental_mode
;
2550 Qmode_class
= intern ("mode-class");
2552 Qprotected_field
= intern ("protected-field");
2554 Qpermanent_local
= intern ("permanent-local");
2556 Qkill_buffer_hook
= intern ("kill-buffer-hook");
2558 Vprin1_to_string_buffer
= Fget_buffer_create (build_string (" prin1"));
2559 /* super-magic invisible buffer */
2560 Vbuffer_alist
= Qnil
;
2562 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
2567 char buf
[MAXPATHLEN
+1];
2569 struct stat dotstat
, pwdstat
;
2572 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
2574 /* If PWD is accurate, use it instead of calling getwd. This is faster
2575 when PWD is right, and may avoid a fatal error. */
2576 if ((pwd
= getenv ("PWD")) != 0 && *pwd
== '/'
2577 && stat (pwd
, &pwdstat
) == 0
2578 && stat (".", &dotstat
) == 0
2579 && dotstat
.st_ino
== pwdstat
.st_ino
2580 && dotstat
.st_dev
== pwdstat
.st_dev
2581 && strlen (pwd
) < MAXPATHLEN
)
2583 else if (getwd (buf
) == 0)
2584 fatal ("`getwd' failed: %s.\n", buf
);
2587 /* Maybe this should really use some standard subroutine
2588 whose definition is filename syntax dependent. */
2589 if (buf
[strlen (buf
) - 1] != '/')
2591 #endif /* not VMS */
2592 current_buffer
->directory
= build_string (buf
);
2594 temp
= get_minibuffer (0);
2595 XBUFFER (temp
)->directory
= current_buffer
->directory
;
2598 /* initialize the buffer routines */
2601 extern Lisp_Object Qdisabled
;
2603 staticpro (&Vbuffer_defaults
);
2604 staticpro (&Vbuffer_local_symbols
);
2605 staticpro (&Qfundamental_mode
);
2606 staticpro (&Qmode_class
);
2607 staticpro (&QSFundamental
);
2608 staticpro (&Vbuffer_alist
);
2609 staticpro (&Qprotected_field
);
2610 staticpro (&Qpermanent_local
);
2611 staticpro (&Qkill_buffer_hook
);
2612 staticpro (&Qoverlayp
);
2613 Qevaporate
= intern ("evaporate");
2614 staticpro (&Qevaporate
);
2615 staticpro (&Qmodification_hooks
);
2616 Qmodification_hooks
= intern ("modification-hooks");
2617 staticpro (&Qinsert_in_front_hooks
);
2618 Qinsert_in_front_hooks
= intern ("insert-in-front-hooks");
2619 staticpro (&Qinsert_behind_hooks
);
2620 Qinsert_behind_hooks
= intern ("insert-behind-hooks");
2621 staticpro (&Qget_file_buffer
);
2622 Qget_file_buffer
= intern ("get-file-buffer");
2623 Qpriority
= intern ("priority");
2624 staticpro (&Qpriority
);
2625 Qwindow
= intern ("window");
2626 staticpro (&Qwindow
);
2628 Qoverlayp
= intern ("overlayp");
2630 Fput (Qprotected_field
, Qerror_conditions
,
2631 Fcons (Qprotected_field
, Fcons (Qerror
, Qnil
)));
2632 Fput (Qprotected_field
, Qerror_message
,
2633 build_string ("Attempt to modify a protected field"));
2635 /* All these use DEFVAR_LISP_NOPRO because the slots in
2636 buffer_defaults will all be marked via Vbuffer_defaults. */
2638 DEFVAR_LISP_NOPRO ("default-mode-line-format",
2639 &buffer_defaults
.mode_line_format
,
2640 "Default value of `mode-line-format' for buffers that don't override it.\n\
2641 This is the same as (default-value 'mode-line-format).");
2643 DEFVAR_LISP_NOPRO ("default-abbrev-mode",
2644 &buffer_defaults
.abbrev_mode
,
2645 "Default value of `abbrev-mode' for buffers that do not override it.\n\
2646 This is the same as (default-value 'abbrev-mode).");
2648 DEFVAR_LISP_NOPRO ("default-ctl-arrow",
2649 &buffer_defaults
.ctl_arrow
,
2650 "Default value of `ctl-arrow' for buffers that do not override it.\n\
2651 This is the same as (default-value 'ctl-arrow).");
2653 DEFVAR_LISP_NOPRO ("default-truncate-lines",
2654 &buffer_defaults
.truncate_lines
,
2655 "Default value of `truncate-lines' for buffers that do not override it.\n\
2656 This is the same as (default-value 'truncate-lines).");
2658 DEFVAR_LISP_NOPRO ("default-fill-column",
2659 &buffer_defaults
.fill_column
,
2660 "Default value of `fill-column' for buffers that do not override it.\n\
2661 This is the same as (default-value 'fill-column).");
2663 DEFVAR_LISP_NOPRO ("default-left-margin",
2664 &buffer_defaults
.left_margin
,
2665 "Default value of `left-margin' for buffers that do not override it.\n\
2666 This is the same as (default-value 'left-margin).");
2668 DEFVAR_LISP_NOPRO ("default-tab-width",
2669 &buffer_defaults
.tab_width
,
2670 "Default value of `tab-width' for buffers that do not override it.\n\
2671 This is the same as (default-value 'tab-width).");
2673 DEFVAR_LISP_NOPRO ("default-case-fold-search",
2674 &buffer_defaults
.case_fold_search
,
2675 "Default value of `case-fold-search' for buffers that don't override it.\n\
2676 This is the same as (default-value 'case-fold-search).");
2679 DEFVAR_LISP_NOPRO ("default-buffer-file-type",
2680 &buffer_defaults
.buffer_file_type
,
2681 "Default file type for buffers that do not override it.\n\
2682 This is the same as (default-value 'buffer-file-type).\n\
2683 The file type is nil for text, t for binary.");
2686 DEFVAR_PER_BUFFER ("mode-line-format", ¤t_buffer
->mode_line_format
,
2689 /* This doc string is too long for cpp; cpp dies if it isn't in a comment.
2690 But make-docfile finds it!
2691 DEFVAR_PER_BUFFER ("mode-line-format", ¤t_buffer->mode_line_format,
2693 "Template for displaying mode line for current buffer.\n\
2694 Each buffer has its own value of this variable.\n\
2695 Value may be a string, a symbol or a list or cons cell.\n\
2696 For a symbol, its value is used (but it is ignored if t or nil).\n\
2697 A string appearing directly as the value of a symbol is processed verbatim\n\
2698 in that the %-constructs below are not recognized.\n\
2699 For a list whose car is a symbol, the symbol's value is taken,\n\
2700 and if that is non-nil, the cadr of the list is processed recursively.\n\
2701 Otherwise, the caddr of the list (if there is one) is processed.\n\
2702 For a list whose car is a string or list, each element is processed\n\
2703 recursively and the results are effectively concatenated.\n\
2704 For a list whose car is an integer, the cdr of the list is processed\n\
2705 and padded (if the number is positive) or truncated (if negative)\n\
2706 to the width specified by that number.\n\
2707 A string is printed verbatim in the mode line except for %-constructs:\n\
2708 (%-constructs are allowed when the string is the entire mode-line-format\n\
2709 or when it is found in a cons-cell or a list)\n\
2710 %b -- print buffer name. %f -- print visited file name.\n\
2711 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.\n\
2712 % means buffer is read-only and * means it is modified.\n\
2713 For a modified read-only buffer, %* gives % and %+ gives *.\n\
2714 %s -- print process status. %l -- print the current line number.\n\
2715 %p -- print percent of buffer above top of window, or Top, Bot or All.\n\
2716 %P -- print percent of buffer above bottom of window, perhaps plus Top,\n\
2717 or print Bottom or All.\n\
2718 %n -- print Narrow if appropriate.\n\
2719 %t -- print T if files is text, B if binary.\n\
2720 %[ -- print one [ for each recursive editing level. %] similar.\n\
2721 %% -- print %. %- -- print infinitely many dashes.\n\
2722 Decimal digits after the % specify field width to which to pad.");
2725 DEFVAR_LISP_NOPRO ("default-major-mode", &buffer_defaults
.major_mode
,
2726 "*Major mode for new buffers. Defaults to `fundamental-mode'.\n\
2727 nil here means use current buffer's major mode.");
2729 DEFVAR_PER_BUFFER ("major-mode", ¤t_buffer
->major_mode
,
2730 make_number (Lisp_Symbol
),
2731 "Symbol for current buffer's major mode.");
2733 DEFVAR_PER_BUFFER ("mode-name", ¤t_buffer
->mode_name
,
2734 make_number (Lisp_String
),
2735 "Pretty name of current buffer's major mode (a string).");
2737 DEFVAR_PER_BUFFER ("abbrev-mode", ¤t_buffer
->abbrev_mode
, Qnil
,
2738 "Non-nil turns on automatic expansion of abbrevs as they are inserted.\n\
2739 Automatically becomes buffer-local when set in any fashion.");
2741 DEFVAR_PER_BUFFER ("case-fold-search", ¤t_buffer
->case_fold_search
,
2743 "*Non-nil if searches should ignore case.\n\
2744 Automatically becomes buffer-local when set in any fashion.");
2746 DEFVAR_PER_BUFFER ("fill-column", ¤t_buffer
->fill_column
,
2747 make_number (Lisp_Int
),
2748 "*Column beyond which automatic line-wrapping should happen.\n\
2749 Automatically becomes buffer-local when set in any fashion.");
2751 DEFVAR_PER_BUFFER ("left-margin", ¤t_buffer
->left_margin
,
2752 make_number (Lisp_Int
),
2753 "*Column for the default indent-line-function to indent to.\n\
2754 Linefeed indents to this column in Fundamental mode.\n\
2755 Automatically becomes buffer-local when set in any fashion.");
2757 DEFVAR_PER_BUFFER ("tab-width", ¤t_buffer
->tab_width
,
2758 make_number (Lisp_Int
),
2759 "*Distance between tab stops (for display of tab characters), in columns.\n\
2760 Automatically becomes buffer-local when set in any fashion.");
2762 DEFVAR_PER_BUFFER ("ctl-arrow", ¤t_buffer
->ctl_arrow
, Qnil
,
2763 "*Non-nil means display control chars with uparrow.\n\
2764 Nil means use backslash and octal digits.\n\
2765 Automatically becomes buffer-local when set in any fashion.\n\
2766 This variable does not apply to characters whose display is specified\n\
2767 in the current display table (if there is one).");
2769 DEFVAR_PER_BUFFER ("truncate-lines", ¤t_buffer
->truncate_lines
, Qnil
,
2770 "*Non-nil means do not display continuation lines;\n\
2771 give each line of text one screen line.\n\
2772 Automatically becomes buffer-local when set in any fashion.\n\
2774 Note that this is overridden by the variable\n\
2775 `truncate-partial-width-windows' if that variable is non-nil\n\
2776 and this buffer is not full-frame width.");
2779 DEFVAR_PER_BUFFER ("buffer-file-type", ¤t_buffer
->buffer_file_type
,
2781 "*If visited file is text, nil; otherwise, t.");
2784 DEFVAR_PER_BUFFER ("default-directory", ¤t_buffer
->directory
,
2785 make_number (Lisp_String
),
2786 "Name of default directory of current buffer. Should end with slash.\n\
2787 Each buffer has its own value of this variable.");
2789 DEFVAR_PER_BUFFER ("auto-fill-function", ¤t_buffer
->auto_fill_function
,
2791 "Function called (if non-nil) to perform auto-fill.\n\
2792 It is called after self-inserting a space at a column beyond `fill-column'.\n\
2793 Each buffer has its own value of this variable.\n\
2794 NOTE: This variable is not an ordinary hook;\n\
2795 It may not be a list of functions.");
2797 DEFVAR_PER_BUFFER ("buffer-file-name", ¤t_buffer
->filename
,
2798 make_number (Lisp_String
),
2799 "Name of file visited in current buffer, or nil if not visiting a file.\n\
2800 Each buffer has its own value of this variable.");
2802 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
2803 ¤t_buffer
->auto_save_file_name
,
2804 make_number (Lisp_String
),
2805 "Name of file for auto-saving current buffer,\n\
2806 or nil if buffer should not be auto-saved.\n\
2807 Each buffer has its own value of this variable.");
2809 DEFVAR_PER_BUFFER ("buffer-read-only", ¤t_buffer
->read_only
, Qnil
,
2810 "Non-nil if this buffer is read-only.\n\
2811 Each buffer has its own value of this variable.");
2813 DEFVAR_PER_BUFFER ("buffer-backed-up", ¤t_buffer
->backed_up
, Qnil
,
2814 "Non-nil if this buffer's file has been backed up.\n\
2815 Backing up is done before the first time the file is saved.\n\
2816 Each buffer has its own value of this variable.");
2818 DEFVAR_PER_BUFFER ("buffer-saved-size", ¤t_buffer
->save_length
,
2819 make_number (Lisp_Int
),
2820 "Length of current buffer when last read in, saved or auto-saved.\n\
2822 Each buffer has its own value of this variable.");
2824 DEFVAR_PER_BUFFER ("selective-display", ¤t_buffer
->selective_display
,
2826 "Non-nil enables selective display:\n\
2827 Integer N as value means display only lines\n\
2828 that start with less than n columns of space.\n\
2829 A value of t means, after a ^M, all the rest of the line is invisible.\n\
2830 Then ^M's in the file are written into files as newlines.\n\n\
2831 Automatically becomes buffer-local when set in any fashion.");
2834 DEFVAR_PER_BUFFER ("selective-display-ellipses",
2835 ¤t_buffer
->selective_display_ellipses
,
2837 "t means display ... on previous line when a line is invisible.\n\
2838 Automatically becomes buffer-local when set in any fashion.");
2841 DEFVAR_PER_BUFFER ("overwrite-mode", ¤t_buffer
->overwrite_mode
, Qnil
,
2842 "Non-nil if self-insertion should replace existing text.\n\
2843 If non-nil and not `overwrite-mode-binary', self-insertion still\n\
2844 inserts at the end of a line, and inserts when point is before a tab,\n\
2845 until the tab is filled in.\n\
2846 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too.\n\
2847 Automatically becomes buffer-local when set in any fashion.");
2849 #if 0 /* The doc string is too long for some compilers,
2850 but make-docfile can find it in this comment. */
2851 DEFVAR_PER_BUFFER ("buffer-display-table", ¤t_buffer
->display_table
,
2853 "Display table that controls display of the contents of current buffer.\n\
2854 Automatically becomes buffer-local when set in any fashion.\n\
2855 The display table is a vector created with `make-display-table'.\n\
2856 The first 256 elements control how to display each possible text character.\n\
2857 Each value should be a vector of characters or nil;\n\
2858 nil means display the character in the default fashion.\n\
2859 The remaining six elements control the display of\n\
2860 the end of a truncated screen line (element 256, a single character);\n\
2861 the end of a continued line (element 257, a single character);\n\
2862 the escape character used to display character codes in octal\n\
2863 (element 258, a single character);\n\
2864 the character used as an arrow for control characters (element 259,\n\
2865 a single character);\n\
2866 the decoration indicating the presence of invisible lines (element 260,\n\
2867 a vector of characters);\n\
2868 the character used to draw the border between side-by-side windows\n\
2869 (element 261, a single character).\n\
2870 If this variable is nil, the value of `standard-display-table' is used.\n\
2871 Each window can have its own, overriding display table.");
2873 DEFVAR_PER_BUFFER ("buffer-display-table", ¤t_buffer
->display_table
,
2876 /*DEFVAR_LISP ("debug-check-symbol", &Vcheck_symbol,
2879 DEFVAR_LISP ("before-change-function", &Vbefore_change_function
,
2880 "Function to call before each text change.\n\
2881 Two arguments are passed to the function: the positions of\n\
2882 the beginning and end of the range of old text to be changed.\n\
2883 \(For an insertion, the beginning and end are at the same place.)\n\
2884 No information is given about the length of the text after the change.\n\
2886 Buffer changes made while executing the `before-change-function'\n\
2887 don't call any before-change or after-change functions.\n\
2888 That's because these variables are temporarily set to nil.\n\
2889 As a result, a hook function cannot straightforwardly alter the value of\n\
2890 these variables. See the Emacs Lisp manual for a way of\n\
2891 accomplishing an equivalent result by using other variables.");
2892 Vbefore_change_function
= Qnil
;
2894 DEFVAR_LISP ("after-change-function", &Vafter_change_function
,
2895 "Function to call after each text change.\n\
2896 Three arguments are passed to the function: the positions of\n\
2897 the beginning and end of the range of changed text,\n\
2898 and the length of the pre-change text replaced by that range.\n\
2899 \(For an insertion, the pre-change length is zero;\n\
2900 for a deletion, that length is the number of characters deleted,\n\
2901 and the post-change beginning and end are at the same place.)\n\
2903 Buffer changes made while executing the `after-change-function'\n\
2904 don't call any before-change or after-change functions.\n\
2905 That's because these variables are temporarily set to nil.\n\
2906 As a result, a hook function cannot straightforwardly alter the value of\n\
2907 these variables. See the Emacs Lisp manual for a way of\n\
2908 accomplishing an equivalent result by using other variables.");
2909 Vafter_change_function
= Qnil
;
2911 DEFVAR_LISP ("before-change-functions", &Vbefore_change_functions
,
2912 "List of functions to call before each text change.\n\
2913 Two arguments are passed to each function: the positions of\n\
2914 the beginning and end of the range of old text to be changed.\n\
2915 \(For an insertion, the beginning and end are at the same place.)\n\
2916 No information is given about the length of the text after the change.\n\
2918 Buffer changes made while executing the `before-change-functions'\n\
2919 don't call any before-change or after-change functions.\n\
2920 That's because these variables are temporarily set to nil.\n\
2921 As a result, a hook function cannot straightforwardly alter the value of\n\
2922 these variables. See the Emacs Lisp manual for a way of\n\
2923 accomplishing an equivalent result by using other variables.");
2924 Vbefore_change_functions
= Qnil
;
2926 DEFVAR_LISP ("after-change-functions", &Vafter_change_functions
,
2927 "List of function to call after each text change.\n\
2928 Three arguments are passed to each function: the positions of\n\
2929 the beginning and end of the range of changed text,\n\
2930 and the length of the pre-change text replaced by that range.\n\
2931 \(For an insertion, the pre-change length is zero;\n\
2932 for a deletion, that length is the number of characters deleted,\n\
2933 and the post-change beginning and end are at the same place.)\n\
2935 Buffer changes made while executing the `after-change-functions'\n\
2936 don't call any before-change or after-change functions.\n\
2937 That's because these variables are temporarily set to nil.\n\
2938 As a result, a hook function cannot straightforwardly alter the value of\n\
2939 these variables. See the Emacs Lisp manual for a way of\n\
2940 accomplishing an equivalent result by using other variables.");
2942 Vafter_change_functions
= Qnil
;
2944 DEFVAR_LISP ("first-change-hook", &Vfirst_change_hook
,
2945 "A list of functions to call before changing a buffer which is unmodified.\n\
2946 The functions are run using the `run-hooks' function.");
2947 Vfirst_change_hook
= Qnil
;
2948 Qfirst_change_hook
= intern ("first-change-hook");
2949 staticpro (&Qfirst_change_hook
);
2951 #if 0 /* The doc string is too long for some compilers,
2952 but make-docfile can find it in this comment. */
2953 DEFVAR_PER_BUFFER ("buffer-undo-list", ¤t_buffer
->undo_list
, Qnil
,
2954 "List of undo entries in current buffer.\n\
2955 Recent changes come first; older changes follow newer.\n\
2957 An entry (START . END) represents an insertion which begins at\n\
2958 position START and ends at position END.\n\
2960 An entry (TEXT . POSITION) represents the deletion of the string TEXT\n\
2961 from (abs POSITION). If POSITION is positive, point was at the front\n\
2962 of the text being deleted; if negative, point was at the end.\n\
2964 An entry (t HIGHWORD LOWWORD) indicates that the buffer had been\n\
2965 previously unmodified. HIGHWORD and LOWWORD are the high and low\n\
2966 16-bit words of the buffer's modification count at the time. If the\n\
2967 modification count of the most recent save is different, this entry is\n\
2970 An entry (nil PROP VAL BEG . END) indicates that a text property\n\
2971 was modified between BEG and END. PROP is the property name,\n\
2972 and VAL is the old value.\n\
2974 An entry of the form POSITION indicates that point was at the buffer\n\
2975 location given by the integer. Undoing an entry of this form places\n\
2976 point at POSITION.\n\
2978 nil marks undo boundaries. The undo command treats the changes\n\
2979 between two undo boundaries as a single step to be undone.\n\
2981 If the value of the variable is t, undo information is not recorded.");
2983 DEFVAR_PER_BUFFER ("buffer-undo-list", ¤t_buffer
->undo_list
, Qnil
,
2986 DEFVAR_PER_BUFFER ("mark-active", ¤t_buffer
->mark_active
, Qnil
,
2987 "Non-nil means the mark and region are currently active in this buffer.\n\
2988 Automatically local in all buffers.");
2990 DEFVAR_PER_BUFFER ("cache-long-line-scans", ¤t_buffer
->cache_long_line_scans
, Qnil
,
2991 "Non-nil means that Emacs should use caches to handle long lines more quickly.\n\
2992 This variable is buffer-local, in all buffers.\n\
2994 Normally, the line-motion functions work by scanning the buffer for\n\
2995 newlines. Columnar operations (like move-to-column and\n\
2996 compute-motion) also work by scanning the buffer, summing character\n\
2997 widths as they go. This works well for ordinary text, but if the\n\
2998 buffer's lines are very long (say, more than 500 characters), these\n\
2999 motion functions will take longer to execute. Emacs may also take\n\
3000 longer to update the display.\n\
3002 If cache-long-line-scans is non-nil, these motion functions cache the\n\
3003 results of their scans, and consult the cache to avoid rescanning\n\
3004 regions of the buffer until the text is modified. The caches are most\n\
3005 beneficial when they prevent the most searching---that is, when the\n\
3006 buffer contains long lines and large regions of characters with the\n\
3007 same, fixed screen width.\n\
3009 When cache-long-line-scans is non-nil, processing short lines will\n\
3010 become slightly slower (because of the overhead of consulting the\n\
3011 cache), and the caches will use memory roughly proportional to the\n\
3012 number of newlines and characters whose screen width varies.\n\
3014 The caches require no explicit maintenance; their accuracy is\n\
3015 maintained internally by the Emacs primitives. Enabling or disabling\n\
3016 the cache should not affect the behavior of any of the motion\n\
3017 functions; it should only affect their performance.");
3019 DEFVAR_LISP ("transient-mark-mode", &Vtransient_mark_mode
,
3020 "*Non-nil means deactivate the mark when the buffer contents change.");
3021 Vtransient_mark_mode
= Qnil
;
3023 DEFVAR_LISP ("inhibit-read-only", &Vinhibit_read_only
,
3024 "*Non-nil means disregard read-only status of buffers or characters.\n\
3025 If the value is t, disregard `buffer-read-only' and all `read-only'\n\
3026 text properties. If the value is a list, disregard `buffer-read-only'\n\
3027 and disregard a `read-only' text property if the property value\n\
3028 is a member of the list.");
3029 Vinhibit_read_only
= Qnil
;
3031 DEFVAR_LISP ("kill-buffer-query-functions", &Vkill_buffer_query_functions
,
3032 "List of functions called with no args to query before killing a buffer.");
3033 Vkill_buffer_query_functions
= Qnil
;
3035 defsubr (&Sbuffer_list
);
3036 defsubr (&Sget_buffer
);
3037 defsubr (&Sget_file_buffer
);
3038 defsubr (&Sget_buffer_create
);
3039 defsubr (&Sgenerate_new_buffer_name
);
3040 defsubr (&Sbuffer_name
);
3041 /*defsubr (&Sbuffer_number);*/
3042 defsubr (&Sbuffer_file_name
);
3043 defsubr (&Sbuffer_local_variables
);
3044 defsubr (&Sbuffer_modified_p
);
3045 defsubr (&Sset_buffer_modified_p
);
3046 defsubr (&Sbuffer_modified_tick
);
3047 defsubr (&Srename_buffer
);
3048 defsubr (&Sother_buffer
);
3049 defsubr (&Sbuffer_disable_undo
);
3050 defsubr (&Sbuffer_enable_undo
);
3051 defsubr (&Skill_buffer
);
3052 defsubr (&Serase_buffer
);
3053 defsubr (&Sswitch_to_buffer
);
3054 defsubr (&Spop_to_buffer
);
3055 defsubr (&Scurrent_buffer
);
3056 defsubr (&Sset_buffer
);
3057 defsubr (&Sbarf_if_buffer_read_only
);
3058 defsubr (&Sbury_buffer
);
3059 defsubr (&Slist_buffers
);
3060 defsubr (&Skill_all_local_variables
);
3062 defsubr (&Soverlayp
);
3063 defsubr (&Smake_overlay
);
3064 defsubr (&Sdelete_overlay
);
3065 defsubr (&Smove_overlay
);
3066 defsubr (&Soverlay_start
);
3067 defsubr (&Soverlay_end
);
3068 defsubr (&Soverlay_buffer
);
3069 defsubr (&Soverlay_properties
);
3070 defsubr (&Soverlays_at
);
3071 defsubr (&Snext_overlay_change
);
3072 defsubr (&Sprevious_overlay_change
);
3073 defsubr (&Soverlay_recenter
);
3074 defsubr (&Soverlay_lists
);
3075 defsubr (&Soverlay_get
);
3076 defsubr (&Soverlay_put
);
3081 initial_define_key (control_x_map
, 'b', "switch-to-buffer");
3082 initial_define_key (control_x_map
, 'k', "kill-buffer");
3083 initial_define_key (control_x_map
, Ctl ('B'), "list-buffers");
3085 /* This must not be in syms_of_buffer, because Qdisabled is not
3086 initialized when that function gets called. */
3087 Fput (intern ("erase-buffer"), Qdisabled
, Qt
);