1 /* Buffer manipulation primitives for GNU Emacs.
2 Copyright (C) 1985, 1986, 1987, 1988, 1989, 1993, 1994,
3 1995, 1997, 1998, 1999, 2000, 2001, 2002,
4 2003, 2004, 2005, 2006, 2007, 2008
5 Free Software Foundation, Inc.
7 This file is part of GNU Emacs.
9 GNU Emacs is free software: you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation, either version 3 of the License, or
12 (at your option) any later version.
14 GNU Emacs is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
24 #include <sys/types.h>
26 #include <sys/param.h>
40 #include "intervals.h"
44 #include "character.h"
45 #include "region-cache.h"
47 #include "blockinput.h"
52 struct buffer
*current_buffer
; /* the current buffer */
54 /* First buffer in chain of all buffers (in reverse order of creation).
55 Threaded through ->next. */
57 struct buffer
*all_buffers
;
59 /* This structure holds the default values of the buffer-local variables
60 defined with DEFVAR_PER_BUFFER, that have special slots in each buffer.
61 The default value occupies the same slot in this structure
62 as an individual buffer's value occupies in that buffer.
63 Setting the default value also goes through the alist of buffers
64 and stores into each buffer that does not say it has a local value. */
66 DECL_ALIGN (struct buffer
, buffer_defaults
);
68 /* A Lisp_Object pointer to the above, used for staticpro */
70 static Lisp_Object Vbuffer_defaults
;
72 /* This structure marks which slots in a buffer have corresponding
73 default values in buffer_defaults.
74 Each such slot has a nonzero value in this structure.
75 The value has only one nonzero bit.
77 When a buffer has its own local value for a slot,
78 the entry for that slot (found in the same slot in this structure)
79 is turned on in the buffer's local_flags array.
81 If a slot in this structure is -1, then even though there may
82 be a DEFVAR_PER_BUFFER for the slot, there is no default value for it;
83 and the corresponding slot in buffer_defaults is not used.
85 If a slot is -2, then there is no DEFVAR_PER_BUFFER for it,
86 but there is a default value which is copied into each buffer.
88 If a slot in this structure corresponding to a DEFVAR_PER_BUFFER is
89 zero, that is a bug */
91 struct buffer buffer_local_flags
;
93 /* This structure holds the names of symbols whose values may be
94 buffer-local. It is indexed and accessed in the same way as the above. */
96 DECL_ALIGN (struct buffer
, buffer_local_symbols
);
98 /* A Lisp_Object pointer to the above, used for staticpro */
99 static Lisp_Object Vbuffer_local_symbols
;
101 /* Flags indicating which built-in buffer-local variables
102 are permanent locals. */
103 static char buffer_permanent_local_flags
[MAX_PER_BUFFER_VARS
];
105 /* Number of per-buffer variables used. */
107 int last_per_buffer_idx
;
109 EXFUN (Fset_buffer
, 1);
110 void set_buffer_internal
P_ ((struct buffer
*b
));
111 void set_buffer_internal_1
P_ ((struct buffer
*b
));
112 static void call_overlay_mod_hooks
P_ ((Lisp_Object list
, Lisp_Object overlay
,
113 int after
, Lisp_Object arg1
,
114 Lisp_Object arg2
, Lisp_Object arg3
));
115 static void swap_out_buffer_local_variables
P_ ((struct buffer
*b
));
116 static void reset_buffer_local_variables
P_ ((struct buffer
*b
, int permanent_too
));
118 /* Alist of all buffer names vs the buffers. */
119 /* This used to be a variable, but is no longer,
120 to prevent lossage due to user rplac'ing this alist or its elements. */
121 Lisp_Object Vbuffer_alist
;
123 /* Functions to call before and after each text change. */
124 Lisp_Object Vbefore_change_functions
;
125 Lisp_Object Vafter_change_functions
;
127 Lisp_Object Vtransient_mark_mode
;
129 /* t means ignore all read-only text properties.
130 A list means ignore such a property if its value is a member of the list.
131 Any non-nil value means ignore buffer-read-only. */
132 Lisp_Object Vinhibit_read_only
;
134 /* List of functions to call that can query about killing a buffer.
135 If any of these functions returns nil, we don't kill it. */
136 Lisp_Object Vkill_buffer_query_functions
;
137 Lisp_Object Qkill_buffer_query_functions
;
139 /* Hook run before changing a major mode. */
140 Lisp_Object Vchange_major_mode_hook
, Qchange_major_mode_hook
;
142 /* List of functions to call before changing an unmodified buffer. */
143 Lisp_Object Vfirst_change_hook
;
145 Lisp_Object Qfirst_change_hook
;
146 Lisp_Object Qbefore_change_functions
;
147 Lisp_Object Qafter_change_functions
;
148 Lisp_Object Qucs_set_table_for_input
;
150 /* If nonzero, all modification hooks are suppressed. */
151 int inhibit_modification_hooks
;
153 Lisp_Object Qfundamental_mode
, Qmode_class
, Qpermanent_local
;
154 Lisp_Object Qpermanent_local_hook
;
156 Lisp_Object Qprotected_field
;
158 Lisp_Object QSFundamental
; /* A string "Fundamental" */
160 Lisp_Object Qkill_buffer_hook
;
162 Lisp_Object Qget_file_buffer
;
164 Lisp_Object Qoverlayp
;
166 Lisp_Object Qpriority
, Qwindow
, Qevaporate
, Qbefore_string
, Qafter_string
;
168 Lisp_Object Qmodification_hooks
;
169 Lisp_Object Qinsert_in_front_hooks
;
170 Lisp_Object Qinsert_behind_hooks
;
172 static void alloc_buffer_text
P_ ((struct buffer
*, size_t));
173 static void free_buffer_text
P_ ((struct buffer
*b
));
174 static struct Lisp_Overlay
* copy_overlays
P_ ((struct buffer
*, struct Lisp_Overlay
*));
175 static void modify_overlay
P_ ((struct buffer
*, EMACS_INT
, EMACS_INT
));
176 static Lisp_Object buffer_lisp_local_variables
P_ ((struct buffer
*));
178 extern char * emacs_strerror
P_ ((int));
180 /* For debugging; temporary. See set_buffer_internal. */
181 /* Lisp_Object Qlisp_mode, Vcheck_symbol; */
188 error ("No buffer named %s", SDATA (spec
));
189 error ("Invalid buffer argument");
192 DEFUN ("buffer-live-p", Fbuffer_live_p
, Sbuffer_live_p
, 1, 1, 0,
193 doc
: /* Return non-nil if OBJECT is a buffer which has not been killed.
194 Value is nil if OBJECT is not a buffer or if it has been killed. */)
198 return ((BUFFERP (object
) && ! NILP (XBUFFER (object
)->name
))
202 DEFUN ("buffer-list", Fbuffer_list
, Sbuffer_list
, 0, 1, 0,
203 doc
: /* Return a list of all existing live buffers.
204 If the optional arg FRAME is a frame, we return the buffer list
205 in the proper order for that frame: the buffers in FRAME's `buffer-list'
206 frame parameter come first, followed by the rest of the buffers. */)
211 general
= Fmapcar (Qcdr
, Vbuffer_alist
);
215 Lisp_Object framelist
, prevlist
, tail
;
220 framelist
= Fcopy_sequence (XFRAME (frame
)->buffer_list
);
221 prevlist
= Fnreverse (Fcopy_sequence (XFRAME (frame
)->buried_buffer_list
));
223 /* Remove from GENERAL any buffer that duplicates one in
224 FRAMELIST or PREVLIST. */
228 general
= Fdelq (XCAR (tail
), general
);
234 general
= Fdelq (XCAR (tail
), general
);
241 return Fnconc (3, args
);
247 /* Like Fassoc, but use Fstring_equal to compare
248 (which ignores text properties),
249 and don't ever QUIT. */
252 assoc_ignore_text_properties (key
, list
)
253 register Lisp_Object key
;
256 register Lisp_Object tail
;
257 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
259 register Lisp_Object elt
, tem
;
261 tem
= Fstring_equal (Fcar (elt
), key
);
268 DEFUN ("get-buffer", Fget_buffer
, Sget_buffer
, 1, 1, 0,
269 doc
: /* Return the buffer named BUFFER-OR-NAME.
270 BUFFER-OR-NAME must be either a string or a buffer. If BUFFER-OR-NAME
271 is a string and there is no buffer with that name, return nil. If
272 BUFFER-OR-NAME is a buffer, return it as given. */)
274 register Lisp_Object buffer_or_name
;
276 if (BUFFERP (buffer_or_name
))
277 return buffer_or_name
;
278 CHECK_STRING (buffer_or_name
);
280 return Fcdr (assoc_ignore_text_properties (buffer_or_name
, Vbuffer_alist
));
283 DEFUN ("get-file-buffer", Fget_file_buffer
, Sget_file_buffer
, 1, 1, 0,
284 doc
: /* Return the buffer visiting file FILENAME (a string).
285 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
286 If there is no such live buffer, return nil.
287 See also `find-buffer-visiting'. */)
289 register Lisp_Object filename
;
291 register Lisp_Object tail
, buf
, tem
;
294 CHECK_STRING (filename
);
295 filename
= Fexpand_file_name (filename
, Qnil
);
297 /* If the file name has special constructs in it,
298 call the corresponding file handler. */
299 handler
= Ffind_file_name_handler (filename
, Qget_file_buffer
);
301 return call2 (handler
, Qget_file_buffer
, filename
);
303 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
305 buf
= Fcdr (XCAR (tail
));
306 if (!BUFFERP (buf
)) continue;
307 if (!STRINGP (XBUFFER (buf
)->filename
)) continue;
308 tem
= Fstring_equal (XBUFFER (buf
)->filename
, filename
);
316 get_truename_buffer (filename
)
317 register Lisp_Object filename
;
319 register Lisp_Object tail
, buf
, tem
;
321 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
323 buf
= Fcdr (XCAR (tail
));
324 if (!BUFFERP (buf
)) continue;
325 if (!STRINGP (XBUFFER (buf
)->file_truename
)) continue;
326 tem
= Fstring_equal (XBUFFER (buf
)->file_truename
, filename
);
333 /* Incremented for each buffer created, to assign the buffer number. */
336 DEFUN ("get-buffer-create", Fget_buffer_create
, Sget_buffer_create
, 1, 1, 0,
337 doc
: /* Return the buffer specified by BUFFER-OR-NAME, creating a new one if needed.
338 If BUFFER-OR-NAME is a string and a live buffer with that name exists,
339 return that buffer. If no such buffer exists, create a new buffer with
340 that name and return it. If BUFFER-OR-NAME starts with a space, the new
341 buffer does not keep undo information.
343 If BUFFER-OR-NAME is a buffer instead of a string, return it as given,
344 even if it is dead. The return value is never nil. */)
346 register Lisp_Object buffer_or_name
;
348 register Lisp_Object buffer
, name
;
349 register struct buffer
*b
;
351 buffer
= Fget_buffer (buffer_or_name
);
355 if (SCHARS (buffer_or_name
) == 0)
356 error ("Empty string for buffer name is not allowed");
358 b
= allocate_buffer ();
360 /* An ordinary buffer uses its own struct buffer_text. */
361 b
->text
= &b
->own_text
;
364 BUF_GAP_SIZE (b
) = 20;
366 /* We allocate extra 1-byte at the tail and keep it always '\0' for
367 anchoring a search. */
368 alloc_buffer_text (b
, BUF_GAP_SIZE (b
) + 1);
370 if (! BUF_BEG_ADDR (b
))
371 buffer_memory_full ();
378 BUF_PT_BYTE (b
) = BEG_BYTE
;
379 BUF_GPT_BYTE (b
) = BEG_BYTE
;
380 BUF_BEGV_BYTE (b
) = BEG_BYTE
;
381 BUF_ZV_BYTE (b
) = BEG_BYTE
;
382 BUF_Z_BYTE (b
) = BEG_BYTE
;
384 BUF_CHARS_MODIFF (b
) = 1;
385 BUF_OVERLAY_MODIFF (b
) = 1;
386 BUF_SAVE_MODIFF (b
) = 1;
387 BUF_INTERVALS (b
) = 0;
388 BUF_UNCHANGED_MODIFIED (b
) = 1;
389 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = 1;
390 BUF_END_UNCHANGED (b
) = 0;
391 BUF_BEG_UNCHANGED (b
) = 0;
392 *(BUF_GPT_ADDR (b
)) = *(BUF_Z_ADDR (b
)) = 0; /* Put an anchor '\0'. */
394 b
->newline_cache
= 0;
395 b
->width_run_cache
= 0;
396 b
->width_table
= Qnil
;
397 b
->prevent_redisplay_optimizations_p
= 1;
399 /* Put this on the chain of all buffers including killed ones. */
400 b
->next
= all_buffers
;
403 /* An ordinary buffer normally doesn't need markers
404 to handle BEGV and ZV. */
406 b
->begv_marker
= Qnil
;
409 name
= Fcopy_sequence (buffer_or_name
);
410 STRING_SET_INTERVALS (name
, NULL_INTERVAL
);
413 b
->undo_list
= (SREF (name
, 0) != ' ') ? Qnil
: Qt
;
416 reset_buffer_local_variables (b
, 1);
418 b
->mark
= Fmake_marker ();
419 BUF_MARKERS (b
) = NULL
;
422 /* Put this in the alist of all live buffers. */
423 XSETBUFFER (buffer
, b
);
424 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buffer
), Qnil
));
426 /* An error in calling the function here (should someone redefine it)
427 can lead to infinite regress until you run out of stack. rms
428 says that's not worth protecting against. */
429 if (!NILP (Ffboundp (Qucs_set_table_for_input
)))
430 /* buffer is on buffer-alist, so no gcpro. */
431 call1 (Qucs_set_table_for_input
, buffer
);
437 /* Return a list of overlays which is a copy of the overlay list
438 LIST, but for buffer B. */
440 static struct Lisp_Overlay
*
441 copy_overlays (b
, list
)
443 struct Lisp_Overlay
*list
;
446 struct Lisp_Overlay
*result
= NULL
, *tail
= NULL
;
448 XSETBUFFER (buffer
, b
);
450 for (; list
; list
= list
->next
)
452 Lisp_Object overlay
, start
, end
, old_overlay
;
455 XSETMISC (old_overlay
, list
);
456 charpos
= marker_position (OVERLAY_START (old_overlay
));
457 start
= Fmake_marker ();
458 Fset_marker (start
, make_number (charpos
), buffer
);
459 XMARKER (start
)->insertion_type
460 = XMARKER (OVERLAY_START (old_overlay
))->insertion_type
;
462 charpos
= marker_position (OVERLAY_END (old_overlay
));
463 end
= Fmake_marker ();
464 Fset_marker (end
, make_number (charpos
), buffer
);
465 XMARKER (end
)->insertion_type
466 = XMARKER (OVERLAY_END (old_overlay
))->insertion_type
;
468 overlay
= allocate_misc ();
469 XMISCTYPE (overlay
) = Lisp_Misc_Overlay
;
470 OVERLAY_START (overlay
) = start
;
471 OVERLAY_END (overlay
) = end
;
472 OVERLAY_PLIST (overlay
) = Fcopy_sequence (OVERLAY_PLIST (old_overlay
));
473 XOVERLAY (overlay
)->next
= NULL
;
476 tail
= tail
->next
= XOVERLAY (overlay
);
478 result
= tail
= XOVERLAY (overlay
);
485 /* Clone per-buffer values of buffer FROM.
487 Buffer TO gets the same per-buffer values as FROM, with the
488 following exceptions: (1) TO's name is left untouched, (2) markers
489 are copied and made to refer to TO, and (3) overlay lists are
493 clone_per_buffer_values (from
, to
)
494 struct buffer
*from
, *to
;
496 Lisp_Object to_buffer
;
499 XSETBUFFER (to_buffer
, to
);
501 /* buffer-local Lisp variables start at `undo_list',
502 tho only the ones from `name' on are GC'd normally. */
503 for (offset
= PER_BUFFER_VAR_OFFSET (undo_list
);
505 offset
+= sizeof (Lisp_Object
))
509 /* Don't touch the `name' which should be unique for every buffer. */
510 if (offset
== PER_BUFFER_VAR_OFFSET (name
))
513 obj
= PER_BUFFER_VALUE (from
, offset
);
516 struct Lisp_Marker
*m
= XMARKER (obj
);
517 obj
= Fmake_marker ();
518 XMARKER (obj
)->insertion_type
= m
->insertion_type
;
519 set_marker_both (obj
, to_buffer
, m
->charpos
, m
->bytepos
);
522 PER_BUFFER_VALUE (to
, offset
) = obj
;
525 bcopy (from
->local_flags
, to
->local_flags
, sizeof to
->local_flags
);
527 to
->overlays_before
= copy_overlays (to
, from
->overlays_before
);
528 to
->overlays_after
= copy_overlays (to
, from
->overlays_after
);
530 /* Get (a copy of) the alist of Lisp-level local variables of FROM
531 and install that in TO. */
532 to
->local_var_alist
= buffer_lisp_local_variables (from
);
535 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer
, Smake_indirect_buffer
,
537 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ",
538 doc
: /* Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.
539 BASE-BUFFER should be a live buffer, or the name of an existing buffer.
540 NAME should be a string which is not the name of an existing buffer.
541 Optional argument CLONE non-nil means preserve BASE-BUFFER's state,
542 such as major and minor modes, in the indirect buffer.
543 CLONE nil means the indirect buffer's state is reset to default values. */)
544 (base_buffer
, name
, clone
)
545 Lisp_Object base_buffer
, name
, clone
;
547 Lisp_Object buf
, tem
;
551 buf
= Fget_buffer (name
);
553 error ("Buffer name `%s' is in use", SDATA (name
));
556 base_buffer
= Fget_buffer (base_buffer
);
557 if (NILP (base_buffer
))
558 error ("No such buffer: `%s'", SDATA (tem
));
559 if (NILP (XBUFFER (base_buffer
)->name
))
560 error ("Base buffer has been killed");
562 if (SCHARS (name
) == 0)
563 error ("Empty string for buffer name is not allowed");
565 b
= allocate_buffer ();
567 b
->base_buffer
= (XBUFFER (base_buffer
)->base_buffer
568 ? XBUFFER (base_buffer
)->base_buffer
569 : XBUFFER (base_buffer
));
571 /* Use the base buffer's text object. */
572 b
->text
= b
->base_buffer
->text
;
574 BUF_BEGV (b
) = BUF_BEGV (b
->base_buffer
);
575 BUF_ZV (b
) = BUF_ZV (b
->base_buffer
);
576 BUF_PT (b
) = BUF_PT (b
->base_buffer
);
577 BUF_BEGV_BYTE (b
) = BUF_BEGV_BYTE (b
->base_buffer
);
578 BUF_ZV_BYTE (b
) = BUF_ZV_BYTE (b
->base_buffer
);
579 BUF_PT_BYTE (b
) = BUF_PT_BYTE (b
->base_buffer
);
581 b
->newline_cache
= 0;
582 b
->width_run_cache
= 0;
583 b
->width_table
= Qnil
;
585 /* Put this on the chain of all buffers including killed ones. */
586 b
->next
= all_buffers
;
589 name
= Fcopy_sequence (name
);
590 STRING_SET_INTERVALS (name
, NULL_INTERVAL
);
594 reset_buffer_local_variables (b
, 1);
596 /* Put this in the alist of all live buffers. */
598 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buf
), Qnil
));
600 b
->mark
= Fmake_marker ();
603 /* The multibyte status belongs to the base buffer. */
604 b
->enable_multibyte_characters
= b
->base_buffer
->enable_multibyte_characters
;
606 /* Make sure the base buffer has markers for its narrowing. */
607 if (NILP (b
->base_buffer
->pt_marker
))
609 b
->base_buffer
->pt_marker
= Fmake_marker ();
610 set_marker_both (b
->base_buffer
->pt_marker
, base_buffer
,
611 BUF_PT (b
->base_buffer
),
612 BUF_PT_BYTE (b
->base_buffer
));
614 if (NILP (b
->base_buffer
->begv_marker
))
616 b
->base_buffer
->begv_marker
= Fmake_marker ();
617 set_marker_both (b
->base_buffer
->begv_marker
, base_buffer
,
618 BUF_BEGV (b
->base_buffer
),
619 BUF_BEGV_BYTE (b
->base_buffer
));
621 if (NILP (b
->base_buffer
->zv_marker
))
623 b
->base_buffer
->zv_marker
= Fmake_marker ();
624 set_marker_both (b
->base_buffer
->zv_marker
, base_buffer
,
625 BUF_ZV (b
->base_buffer
),
626 BUF_ZV_BYTE (b
->base_buffer
));
627 XMARKER (b
->base_buffer
->zv_marker
)->insertion_type
= 1;
632 /* Give the indirect buffer markers for its narrowing. */
633 b
->pt_marker
= Fmake_marker ();
634 set_marker_both (b
->pt_marker
, buf
, BUF_PT (b
), BUF_PT_BYTE (b
));
635 b
->begv_marker
= Fmake_marker ();
636 set_marker_both (b
->begv_marker
, buf
, BUF_BEGV (b
), BUF_BEGV_BYTE (b
));
637 b
->zv_marker
= Fmake_marker ();
638 set_marker_both (b
->zv_marker
, buf
, BUF_ZV (b
), BUF_ZV_BYTE (b
));
639 XMARKER (b
->zv_marker
)->insertion_type
= 1;
643 struct buffer
*old_b
= current_buffer
;
645 clone_per_buffer_values (b
->base_buffer
, b
);
647 b
->file_truename
= Qnil
;
648 b
->display_count
= make_number (0);
650 b
->auto_save_file_name
= Qnil
;
651 set_buffer_internal_1 (b
);
652 Fset (intern ("buffer-save-without-query"), Qnil
);
653 Fset (intern ("buffer-file-number"), Qnil
);
654 Fset (intern ("buffer-stale-function"), Qnil
);
655 set_buffer_internal_1 (old_b
);
662 delete_all_overlays (b
)
667 /* `reset_buffer' blindly sets the list of overlays to NULL, so we
668 have to empty the list, otherwise we end up with overlays that
669 think they belong to this buffer while the buffer doesn't know about
671 while (b
->overlays_before
)
673 XSETMISC (overlay
, b
->overlays_before
);
674 Fdelete_overlay (overlay
);
676 while (b
->overlays_after
)
678 XSETMISC (overlay
, b
->overlays_after
);
679 Fdelete_overlay (overlay
);
681 eassert (b
->overlays_before
== NULL
);
682 eassert (b
->overlays_after
== NULL
);
685 /* Reinitialize everything about a buffer except its name and contents
687 If called on an already-initialized buffer, the list of overlays
688 should be deleted before calling this function, otherwise we end up
689 with overlays that claim to belong to the buffer but the buffer
690 claims it doesn't belong to it. */
694 register struct buffer
*b
;
697 b
->file_truename
= Qnil
;
698 b
->directory
= (current_buffer
) ? current_buffer
->directory
: Qnil
;
700 XSETFASTINT (b
->save_length
, 0);
701 b
->last_window_start
= 1;
702 /* It is more conservative to start out "changed" than "unchanged". */
704 b
->prevent_redisplay_optimizations_p
= 1;
706 b
->auto_save_modified
= 0;
707 b
->auto_save_failure_time
= -1;
708 b
->auto_save_file_name
= Qnil
;
710 b
->overlays_before
= NULL
;
711 b
->overlays_after
= NULL
;
712 b
->overlay_center
= BEG
;
713 b
->mark_active
= Qnil
;
714 b
->point_before_scroll
= Qnil
;
715 b
->file_format
= Qnil
;
716 b
->auto_save_file_format
= Qt
;
717 b
->last_selected_window
= Qnil
;
718 XSETINT (b
->display_count
, 0);
719 b
->display_time
= Qnil
;
720 b
->enable_multibyte_characters
= buffer_defaults
.enable_multibyte_characters
;
721 b
->cursor_type
= buffer_defaults
.cursor_type
;
722 b
->extra_line_spacing
= buffer_defaults
.extra_line_spacing
;
724 b
->display_error_modiff
= 0;
727 /* Reset buffer B's local variables info.
728 Don't use this on a buffer that has already been in use;
729 it does not treat permanent locals consistently.
730 Instead, use Fkill_all_local_variables.
732 If PERMANENT_TOO is 1, then we reset permanent
733 buffer-local variables. If PERMANENT_TOO is 0,
734 we preserve those. */
737 reset_buffer_local_variables (b
, permanent_too
)
738 register struct buffer
*b
;
744 /* Reset the major mode to Fundamental, together with all the
745 things that depend on the major mode.
746 default-major-mode is handled at a higher level.
747 We ignore it here. */
748 b
->major_mode
= Qfundamental_mode
;
750 b
->mode_name
= QSFundamental
;
751 b
->minor_modes
= Qnil
;
753 /* If the standard case table has been altered and invalidated,
754 fix up its insides first. */
755 if (! (CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[0])
756 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[1])
757 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[2])))
758 Fset_standard_case_table (Vascii_downcase_table
);
760 b
->downcase_table
= Vascii_downcase_table
;
761 b
->upcase_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[0];
762 b
->case_canon_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[1];
763 b
->case_eqv_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[2];
764 b
->invisibility_spec
= Qt
;
766 b
->buffer_file_type
= Qnil
;
769 /* Reset all (or most) per-buffer variables to their defaults. */
771 b
->local_var_alist
= Qnil
;
774 Lisp_Object tmp
, prop
, last
= Qnil
;
775 for (tmp
= b
->local_var_alist
; CONSP (tmp
); tmp
= XCDR (tmp
))
776 if (CONSP (XCAR (tmp
))
777 && SYMBOLP (XCAR (XCAR (tmp
)))
778 && !NILP (prop
= Fget (XCAR (XCAR (tmp
)), Qpermanent_local
)))
780 /* If permanent-local, keep it. */
782 if (EQ (prop
, Qpermanent_local_hook
))
784 /* This is a partially permanent hook variable.
785 Preserve only the elements that want to be preserved. */
786 Lisp_Object list
, newlist
;
787 list
= XCDR (XCAR (tmp
));
791 for (newlist
= Qnil
; CONSP (list
); list
= XCDR (list
))
793 Lisp_Object elt
= XCAR (list
);
794 /* Preserve element ELT if it's t,
795 if it is a function with a `permanent-local-hook' property,
796 or if it's not a symbol. */
799 || !NILP (Fget (elt
, Qpermanent_local_hook
)))
800 newlist
= Fcons (elt
, newlist
);
802 XSETCDR (XCAR (tmp
), Fnreverse (newlist
));
805 /* Delete this local variable. */
806 else if (NILP (last
))
807 b
->local_var_alist
= XCDR (tmp
);
809 XSETCDR (last
, XCDR (tmp
));
812 for (i
= 0; i
< last_per_buffer_idx
; ++i
)
813 if (permanent_too
|| buffer_permanent_local_flags
[i
] == 0)
814 SET_PER_BUFFER_VALUE_P (b
, i
, 0);
816 /* For each slot that has a default value,
817 copy that into the slot. */
819 /* buffer-local Lisp variables start at `undo_list',
820 tho only the ones from `name' on are GC'd normally. */
821 for (offset
= PER_BUFFER_VAR_OFFSET (undo_list
);
823 offset
+= sizeof (Lisp_Object
))
825 int idx
= PER_BUFFER_IDX (offset
);
828 || buffer_permanent_local_flags
[idx
] == 0))
829 /* Is -2 used anywhere? */
831 PER_BUFFER_VALUE (b
, offset
) = PER_BUFFER_DEFAULT (offset
);
835 /* We split this away from generate-new-buffer, because rename-buffer
836 and set-visited-file-name ought to be able to use this to really
837 rename the buffer properly. */
839 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name
, Sgenerate_new_buffer_name
,
841 doc
: /* Return a string that is the name of no existing buffer based on NAME.
842 If there is no live buffer named NAME, then return NAME.
843 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
844 \(starting at 2) until an unused name is found, and then return that name.
845 Optional second argument IGNORE specifies a name that is okay to use (if
846 it is in the sequence to be tried) even if a buffer with that name exists. */)
848 register Lisp_Object name
, ignore
;
850 register Lisp_Object gentemp
, tem
;
856 tem
= Fstring_equal (name
, ignore
);
859 tem
= Fget_buffer (name
);
866 sprintf (number
, "<%d>", ++count
);
867 gentemp
= concat2 (name
, build_string (number
));
868 tem
= Fstring_equal (gentemp
, ignore
);
871 tem
= Fget_buffer (gentemp
);
878 DEFUN ("buffer-name", Fbuffer_name
, Sbuffer_name
, 0, 1, 0,
879 doc
: /* Return the name of BUFFER, as a string.
880 With no argument or nil as argument, return the name of the current buffer. */)
882 register Lisp_Object buffer
;
885 return current_buffer
->name
;
886 CHECK_BUFFER (buffer
);
887 return XBUFFER (buffer
)->name
;
890 DEFUN ("buffer-file-name", Fbuffer_file_name
, Sbuffer_file_name
, 0, 1, 0,
891 doc
: /* Return name of file BUFFER is visiting, or nil if none.
892 No argument or nil as argument means use the current buffer. */)
894 register Lisp_Object buffer
;
897 return current_buffer
->filename
;
898 CHECK_BUFFER (buffer
);
899 return XBUFFER (buffer
)->filename
;
902 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer
, Sbuffer_base_buffer
,
904 doc
: /* Return the base buffer of indirect buffer BUFFER.
905 If BUFFER is not indirect, return nil.
906 BUFFER defaults to the current buffer. */)
908 register Lisp_Object buffer
;
911 Lisp_Object base_buffer
;
914 base
= current_buffer
->base_buffer
;
917 CHECK_BUFFER (buffer
);
918 base
= XBUFFER (buffer
)->base_buffer
;
923 XSETBUFFER (base_buffer
, base
);
927 DEFUN ("buffer-local-value", Fbuffer_local_value
,
928 Sbuffer_local_value
, 2, 2, 0,
929 doc
: /* Return the value of VARIABLE in BUFFER.
930 If VARIABLE does not have a buffer-local binding in BUFFER, the value
931 is the default binding of the variable. */)
933 register Lisp_Object variable
;
934 register Lisp_Object buffer
;
936 register struct buffer
*buf
;
937 register Lisp_Object result
;
938 struct Lisp_Symbol
*sym
;
940 CHECK_SYMBOL (variable
);
941 CHECK_BUFFER (buffer
);
942 buf
= XBUFFER (buffer
);
944 sym
= indirect_variable (XSYMBOL (variable
));
945 XSETSYMBOL (variable
, sym
);
947 /* Look in local_var_list */
948 result
= Fassoc (variable
, buf
->local_var_alist
);
954 /* Look in special slots */
955 /* buffer-local Lisp variables start at `undo_list',
956 tho only the ones from `name' on are GC'd normally. */
957 for (offset
= PER_BUFFER_VAR_OFFSET (undo_list
);
958 offset
< sizeof (struct buffer
);
959 /* sizeof EMACS_INT == sizeof Lisp_Object */
960 offset
+= (sizeof (EMACS_INT
)))
962 idx
= PER_BUFFER_IDX (offset
);
963 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
964 && SYMBOLP (PER_BUFFER_SYMBOL (offset
))
965 && EQ (PER_BUFFER_SYMBOL (offset
), variable
))
967 result
= PER_BUFFER_VALUE (buf
, offset
);
974 result
= Fdefault_value (variable
);
978 Lisp_Object valcontents
;
979 Lisp_Object current_alist_element
;
981 /* What binding is loaded right now? */
982 valcontents
= sym
->value
;
983 current_alist_element
984 = XCAR (XBUFFER_LOCAL_VALUE (valcontents
)->cdr
);
986 /* The value of the currently loaded binding is not
987 stored in it, but rather in the realvalue slot.
988 Store that value into the binding it belongs to
989 in case that is the one we are about to use. */
991 Fsetcdr (current_alist_element
,
992 do_symval_forwarding (XBUFFER_LOCAL_VALUE (valcontents
)->realvalue
));
994 /* Now get the (perhaps updated) value out of the binding. */
995 result
= XCDR (result
);
998 if (!EQ (result
, Qunbound
))
1001 xsignal1 (Qvoid_variable
, variable
);
1004 /* Return an alist of the Lisp-level buffer-local bindings of
1005 buffer BUF. That is, don't include the variables maintained
1006 in special slots in the buffer object. */
1009 buffer_lisp_local_variables (buf
)
1012 Lisp_Object result
= Qnil
;
1013 register Lisp_Object tail
;
1014 for (tail
= buf
->local_var_alist
; CONSP (tail
); tail
= XCDR (tail
))
1016 Lisp_Object val
, elt
;
1020 /* Reference each variable in the alist in buf.
1021 If inquiring about the current buffer, this gets the current values,
1022 so store them into the alist so the alist is up to date.
1023 If inquiring about some other buffer, this swaps out any values
1024 for that buffer, making the alist up to date automatically. */
1025 val
= find_symbol_value (XCAR (elt
));
1026 /* Use the current buffer value only if buf is the current buffer. */
1027 if (buf
!= current_buffer
)
1030 /* If symbol is unbound, put just the symbol in the list. */
1031 if (EQ (val
, Qunbound
))
1032 result
= Fcons (XCAR (elt
), result
);
1033 /* Otherwise, put (symbol . value) in the list. */
1035 result
= Fcons (Fcons (XCAR (elt
), val
), result
);
1041 DEFUN ("buffer-local-variables", Fbuffer_local_variables
,
1042 Sbuffer_local_variables
, 0, 1, 0,
1043 doc
: /* Return an alist of variables that are buffer-local in BUFFER.
1044 Most elements look like (SYMBOL . VALUE), describing one variable.
1045 For a symbol that is locally unbound, just the symbol appears in the value.
1046 Note that storing new VALUEs in these elements doesn't change the variables.
1047 No argument or nil as argument means use current buffer as BUFFER. */)
1049 register Lisp_Object buffer
;
1051 register struct buffer
*buf
;
1052 register Lisp_Object result
;
1055 buf
= current_buffer
;
1058 CHECK_BUFFER (buffer
);
1059 buf
= XBUFFER (buffer
);
1062 result
= buffer_lisp_local_variables (buf
);
1064 /* Add on all the variables stored in special slots. */
1068 /* buffer-local Lisp variables start at `undo_list',
1069 tho only the ones from `name' on are GC'd normally. */
1070 for (offset
= PER_BUFFER_VAR_OFFSET (undo_list
);
1071 offset
< sizeof (struct buffer
);
1072 /* sizeof EMACS_INT == sizeof Lisp_Object */
1073 offset
+= (sizeof (EMACS_INT
)))
1075 idx
= PER_BUFFER_IDX (offset
);
1076 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
1077 && SYMBOLP (PER_BUFFER_SYMBOL (offset
)))
1078 result
= Fcons (Fcons (PER_BUFFER_SYMBOL (offset
),
1079 PER_BUFFER_VALUE (buf
, offset
)),
1087 DEFUN ("buffer-modified-p", Fbuffer_modified_p
, Sbuffer_modified_p
,
1089 doc
: /* Return t if BUFFER was modified since its file was last read or saved.
1090 No argument or nil as argument means use current buffer as BUFFER. */)
1092 register Lisp_Object buffer
;
1094 register struct buffer
*buf
;
1096 buf
= current_buffer
;
1099 CHECK_BUFFER (buffer
);
1100 buf
= XBUFFER (buffer
);
1103 return BUF_SAVE_MODIFF (buf
) < BUF_MODIFF (buf
) ? Qt
: Qnil
;
1106 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p
, Sset_buffer_modified_p
,
1108 doc
: /* Mark current buffer as modified or unmodified according to FLAG.
1109 A non-nil FLAG means mark the buffer modified. */)
1111 register Lisp_Object flag
;
1113 register int already
;
1114 register Lisp_Object fn
;
1115 Lisp_Object buffer
, window
;
1117 #ifdef CLASH_DETECTION
1118 /* If buffer becoming modified, lock the file.
1119 If buffer becoming unmodified, unlock the file. */
1121 fn
= current_buffer
->file_truename
;
1122 /* Test buffer-file-name so that binding it to nil is effective. */
1123 if (!NILP (fn
) && ! NILP (current_buffer
->filename
))
1125 already
= SAVE_MODIFF
< MODIFF
;
1126 if (!already
&& !NILP (flag
))
1128 else if (already
&& NILP (flag
))
1131 #endif /* CLASH_DETECTION */
1133 SAVE_MODIFF
= NILP (flag
) ? MODIFF
: 0;
1135 /* Set update_mode_lines only if buffer is displayed in some window.
1136 Packages like jit-lock or lazy-lock preserve a buffer's modified
1137 state by recording/restoring the state around blocks of code.
1138 Setting update_mode_lines makes redisplay consider all windows
1139 (on all frames). Stealth fontification of buffers not displayed
1140 would incur additional redisplay costs if we'd set
1141 update_modes_lines unconditionally.
1143 Ideally, I think there should be another mechanism for fontifying
1144 buffers without "modifying" buffers, or redisplay should be
1145 smarter about updating the `*' in mode lines. --gerd */
1146 XSETBUFFER (buffer
, current_buffer
);
1147 window
= Fget_buffer_window (buffer
, Qt
);
1148 if (WINDOWP (window
))
1150 ++update_mode_lines
;
1151 current_buffer
->prevent_redisplay_optimizations_p
= 1;
1157 DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p
,
1158 Srestore_buffer_modified_p
, 1, 1, 0,
1159 doc
: /* Like `set-buffer-modified-p', with a difference concerning redisplay.
1160 It is not ensured that mode lines will be updated to show the modified
1161 state of the current buffer. Use with care. */)
1165 #ifdef CLASH_DETECTION
1168 /* If buffer becoming modified, lock the file.
1169 If buffer becoming unmodified, unlock the file. */
1171 fn
= current_buffer
->file_truename
;
1172 /* Test buffer-file-name so that binding it to nil is effective. */
1173 if (!NILP (fn
) && ! NILP (current_buffer
->filename
))
1175 int already
= SAVE_MODIFF
< MODIFF
;
1176 if (!already
&& !NILP (flag
))
1178 else if (already
&& NILP (flag
))
1181 #endif /* CLASH_DETECTION */
1183 SAVE_MODIFF
= NILP (flag
) ? MODIFF
: 0;
1187 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick
, Sbuffer_modified_tick
,
1189 doc
: /* Return BUFFER's tick counter, incremented for each change in text.
1190 Each buffer has a tick counter which is incremented each time the
1191 text in that buffer is changed. It wraps around occasionally.
1192 No argument or nil as argument means use current buffer as BUFFER. */)
1194 register Lisp_Object buffer
;
1196 register struct buffer
*buf
;
1198 buf
= current_buffer
;
1201 CHECK_BUFFER (buffer
);
1202 buf
= XBUFFER (buffer
);
1205 return make_number (BUF_MODIFF (buf
));
1208 DEFUN ("buffer-chars-modified-tick", Fbuffer_chars_modified_tick
,
1209 Sbuffer_chars_modified_tick
, 0, 1, 0,
1210 doc
: /* Return BUFFER's character-change tick counter.
1211 Each buffer has a character-change tick counter, which is set to the
1212 value of the buffer's tick counter \(see `buffer-modified-tick'), each
1213 time text in that buffer is inserted or deleted. By comparing the
1214 values returned by two individual calls of `buffer-chars-modified-tick',
1215 you can tell whether a character change occurred in that buffer in
1216 between these calls. No argument or nil as argument means use current
1217 buffer as BUFFER. */)
1219 register Lisp_Object buffer
;
1221 register struct buffer
*buf
;
1223 buf
= current_buffer
;
1226 CHECK_BUFFER (buffer
);
1227 buf
= XBUFFER (buffer
);
1230 return make_number (BUF_CHARS_MODIFF (buf
));
1233 DEFUN ("rename-buffer", Frename_buffer
, Srename_buffer
, 1, 2,
1234 "(list (read-string \"Rename buffer (to new name): \" \
1235 nil 'buffer-name-history (buffer-name (current-buffer))) \
1236 current-prefix-arg)",
1237 doc
: /* Change current buffer's name to NEWNAME (a string).
1238 If second arg UNIQUE is nil or omitted, it is an error if a
1239 buffer named NEWNAME already exists.
1240 If UNIQUE is non-nil, come up with a new name using
1241 `generate-new-buffer-name'.
1242 Interactively, you can set UNIQUE with a prefix argument.
1243 We return the name we actually gave the buffer.
1244 This does not change the name of the visited file (if any). */)
1246 register Lisp_Object newname
, unique
;
1248 register Lisp_Object tem
, buf
;
1250 CHECK_STRING (newname
);
1252 if (SCHARS (newname
) == 0)
1253 error ("Empty string is invalid as a buffer name");
1255 tem
= Fget_buffer (newname
);
1258 /* Don't short-circuit if UNIQUE is t. That is a useful way to
1259 rename the buffer automatically so you can create another
1260 with the original name. It makes UNIQUE equivalent to
1261 (rename-buffer (generate-new-buffer-name NEWNAME)). */
1262 if (NILP (unique
) && XBUFFER (tem
) == current_buffer
)
1263 return current_buffer
->name
;
1265 newname
= Fgenerate_new_buffer_name (newname
, current_buffer
->name
);
1267 error ("Buffer name `%s' is in use", SDATA (newname
));
1270 current_buffer
->name
= newname
;
1272 /* Catch redisplay's attention. Unless we do this, the mode lines for
1273 any windows displaying current_buffer will stay unchanged. */
1274 update_mode_lines
++;
1276 XSETBUFFER (buf
, current_buffer
);
1277 Fsetcar (Frassq (buf
, Vbuffer_alist
), newname
);
1278 if (NILP (current_buffer
->filename
)
1279 && !NILP (current_buffer
->auto_save_file_name
))
1280 call0 (intern ("rename-auto-save-file"));
1281 /* Refetch since that last call may have done GC. */
1282 return current_buffer
->name
;
1285 DEFUN ("other-buffer", Fother_buffer
, Sother_buffer
, 0, 3, 0,
1286 doc
: /* Return most recently selected buffer other than BUFFER.
1287 Buffers not visible in windows are preferred to visible buffers,
1288 unless optional second argument VISIBLE-OK is non-nil.
1289 If the optional third argument FRAME is non-nil, use that frame's
1290 buffer list instead of the selected frame's buffer list.
1291 If no other buffer exists, the buffer `*scratch*' is returned.
1292 If BUFFER is omitted or nil, some interesting buffer is returned. */)
1293 (buffer
, visible_ok
, frame
)
1294 register Lisp_Object buffer
, visible_ok
, frame
;
1296 Lisp_Object
Fset_buffer_major_mode ();
1297 register Lisp_Object tail
, buf
, notsogood
, tem
, pred
, add_ons
;
1301 frame
= selected_frame
;
1303 tail
= Vbuffer_alist
;
1304 pred
= frame_buffer_predicate (frame
);
1306 /* Consider buffers that have been seen in the selected frame
1307 before other buffers. */
1309 tem
= frame_buffer_list (frame
);
1313 if (BUFFERP (XCAR (tem
)))
1314 add_ons
= Fcons (Fcons (Qnil
, XCAR (tem
)), add_ons
);
1317 tail
= nconc2 (Fnreverse (add_ons
), tail
);
1319 for (; CONSP (tail
); tail
= XCDR (tail
))
1321 buf
= Fcdr (XCAR (tail
));
1322 if (EQ (buf
, buffer
))
1326 if (NILP (XBUFFER (buf
)->name
))
1328 if (SREF (XBUFFER (buf
)->name
, 0) == ' ')
1330 /* If the selected frame has a buffer_predicate,
1331 disregard buffers that don't fit the predicate. */
1334 tem
= call1 (pred
, buf
);
1339 if (NILP (visible_ok
))
1340 tem
= Fget_buffer_window (buf
, Qvisible
);
1345 if (NILP (notsogood
))
1348 if (!NILP (notsogood
))
1350 buf
= Fget_buffer (build_string ("*scratch*"));
1353 buf
= Fget_buffer_create (build_string ("*scratch*"));
1354 Fset_buffer_major_mode (buf
);
1359 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo
, Sbuffer_enable_undo
,
1361 doc
: /* Start keeping undo information for buffer BUFFER.
1362 No argument or nil as argument means do this for the current buffer. */)
1364 register Lisp_Object buffer
;
1366 Lisp_Object real_buffer
;
1369 XSETBUFFER (real_buffer
, current_buffer
);
1372 real_buffer
= Fget_buffer (buffer
);
1373 if (NILP (real_buffer
))
1377 if (EQ (XBUFFER (real_buffer
)->undo_list
, Qt
))
1378 XBUFFER (real_buffer
)->undo_list
= Qnil
;
1384 DEFVAR_LISP ("kill-buffer-hook", no_cell, "\
1385 Hook to be run (by `run-hooks', which see) when a buffer is killed.\n\
1386 The buffer being killed will be current while the hook is running.\n\
1389 DEFUN ("kill-buffer", Fkill_buffer
, Skill_buffer
, 0, 1, "bKill buffer: ",
1390 doc
: /* Kill buffer BUFFER-OR-NAME.
1391 The argument may be a buffer or the name of an existing buffer.
1392 Argument nil or omitted means kill the current buffer. Return t if the
1393 buffer is actually killed, nil otherwise.
1395 This function calls `replace-buffer-in-windows' for cleaning up all
1396 windows currently displaying the buffer to be killed. The functions in
1397 `kill-buffer-query-functions' are called with the buffer to be killed as
1398 the current buffer. If any of them returns nil, the buffer is not
1399 killed. The hook `kill-buffer-hook' is run before the buffer is
1400 actually killed. The buffer being killed will be current while the hook
1403 Any processes that have this buffer as the `process-buffer' are killed
1406 Lisp_Object buffer_or_name
;
1409 register struct buffer
*b
;
1410 register Lisp_Object tem
;
1411 register struct Lisp_Marker
*m
;
1412 struct gcpro gcpro1
;
1414 if (NILP (buffer_or_name
))
1415 buffer
= Fcurrent_buffer ();
1417 buffer
= Fget_buffer (buffer_or_name
);
1419 nsberror (buffer_or_name
);
1421 b
= XBUFFER (buffer
);
1423 /* Avoid trouble for buffer already dead. */
1427 /* Query if the buffer is still modified. */
1428 if (INTERACTIVE
&& !NILP (b
->filename
)
1429 && BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
1432 tem
= do_yes_or_no_p (format2 ("Buffer %s modified; kill anyway? ",
1433 b
->name
, make_number (0)));
1439 /* Run hooks with the buffer to be killed the current buffer. */
1441 int count
= SPECPDL_INDEX ();
1442 Lisp_Object arglist
[1];
1444 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1445 set_buffer_internal (b
);
1447 /* First run the query functions; if any query is answered no,
1448 don't kill the buffer. */
1449 arglist
[0] = Qkill_buffer_query_functions
;
1450 tem
= Frun_hook_with_args_until_failure (1, arglist
);
1452 return unbind_to (count
, Qnil
);
1454 /* Then run the hooks. */
1455 Frun_hooks (1, &Qkill_buffer_hook
);
1456 unbind_to (count
, Qnil
);
1459 /* We have no more questions to ask. Verify that it is valid
1460 to kill the buffer. This must be done after the questions
1461 since anything can happen within do_yes_or_no_p. */
1463 /* Don't kill the minibuffer now current. */
1464 if (EQ (buffer
, XWINDOW (minibuf_window
)->buffer
))
1470 /* When we kill a base buffer, kill all its indirect buffers.
1471 We do it at this stage so nothing terrible happens if they
1472 ask questions or their hooks get errors. */
1473 if (! b
->base_buffer
)
1475 struct buffer
*other
;
1479 for (other
= all_buffers
; other
; other
= other
->next
)
1480 /* all_buffers contains dead buffers too;
1481 don't re-kill them. */
1482 if (other
->base_buffer
== b
&& !NILP (other
->name
))
1485 XSETBUFFER (buffer
, other
);
1486 Fkill_buffer (buffer
);
1492 /* Make this buffer not be current.
1493 In the process, notice if this is the sole visible buffer
1494 and give up if so. */
1495 if (b
== current_buffer
)
1497 tem
= Fother_buffer (buffer
, Qnil
, Qnil
);
1499 if (b
== current_buffer
)
1503 /* Notice if the buffer to kill is the sole visible buffer
1504 when we're currently in the mini-buffer, and give up if so. */
1505 XSETBUFFER (tem
, current_buffer
);
1506 if (EQ (tem
, XWINDOW (minibuf_window
)->buffer
))
1508 tem
= Fother_buffer (buffer
, Qnil
, Qnil
);
1509 if (EQ (buffer
, tem
))
1513 /* Now there is no question: we can kill the buffer. */
1515 #ifdef CLASH_DETECTION
1516 /* Unlock this buffer's file, if it is locked. */
1518 #endif /* CLASH_DETECTION */
1521 kill_buffer_processes (buffer
);
1524 /* Killing buffer processes may run sentinels which may
1525 have called kill-buffer. */
1530 clear_charpos_cache (b
);
1532 tem
= Vinhibit_quit
;
1534 replace_buffer_in_all_windows (buffer
);
1535 Vbuffer_alist
= Fdelq (Frassq (buffer
, Vbuffer_alist
), Vbuffer_alist
);
1536 frames_discard_buffer (buffer
);
1537 Vinhibit_quit
= tem
;
1539 /* Delete any auto-save file, if we saved it in this session.
1540 But not if the buffer is modified. */
1541 if (STRINGP (b
->auto_save_file_name
)
1542 && b
->auto_save_modified
!= 0
1543 && BUF_SAVE_MODIFF (b
) < b
->auto_save_modified
1544 && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
)
1545 && NILP (Fsymbol_value (intern ("auto-save-visited-file-name"))))
1548 tem
= Fsymbol_value (intern ("delete-auto-save-files"));
1550 internal_delete_file (b
->auto_save_file_name
);
1555 /* Unchain all markers that belong to this indirect buffer.
1556 Don't unchain the markers that belong to the base buffer
1557 or its other indirect buffers. */
1558 for (m
= BUF_MARKERS (b
); m
; )
1560 struct Lisp_Marker
*next
= m
->next
;
1568 /* Unchain all markers of this buffer and its indirect buffers.
1569 and leave them pointing nowhere. */
1570 for (m
= BUF_MARKERS (b
); m
; )
1572 struct Lisp_Marker
*next
= m
->next
;
1577 BUF_MARKERS (b
) = NULL
;
1578 BUF_INTERVALS (b
) = NULL_INTERVAL
;
1580 /* Perhaps we should explicitly free the interval tree here... */
1583 /* Reset the local variables, so that this buffer's local values
1584 won't be protected from GC. They would be protected
1585 if they happened to remain encached in their symbols.
1586 This gets rid of them for certain. */
1587 swap_out_buffer_local_variables (b
);
1588 reset_buffer_local_variables (b
, 1);
1593 if (! b
->base_buffer
)
1594 free_buffer_text (b
);
1596 if (b
->newline_cache
)
1598 free_region_cache (b
->newline_cache
);
1599 b
->newline_cache
= 0;
1601 if (b
->width_run_cache
)
1603 free_region_cache (b
->width_run_cache
);
1604 b
->width_run_cache
= 0;
1606 b
->width_table
= Qnil
;
1608 b
->undo_list
= Qnil
;
1613 /* Move the assoc for buffer BUF to the front of buffer-alist. Since
1614 we do this each time BUF is selected visibly, the more recently
1615 selected buffers are always closer to the front of the list. This
1616 means that other_buffer is more likely to choose a relevant buffer. */
1622 register Lisp_Object link
, prev
;
1624 frame
= selected_frame
;
1627 for (link
= Vbuffer_alist
; CONSP (link
); link
= XCDR (link
))
1629 if (EQ (XCDR (XCAR (link
)), buf
))
1634 /* Effectively do Vbuffer_alist = Fdelq (link, Vbuffer_alist);
1635 we cannot use Fdelq itself here because it allows quitting. */
1638 Vbuffer_alist
= XCDR (Vbuffer_alist
);
1640 XSETCDR (prev
, XCDR (XCDR (prev
)));
1642 XSETCDR (link
, Vbuffer_alist
);
1643 Vbuffer_alist
= link
;
1645 /* Effectively do a delq on buried_buffer_list. */
1648 for (link
= XFRAME (frame
)->buried_buffer_list
; CONSP (link
);
1651 if (EQ (XCAR (link
), buf
))
1654 XFRAME (frame
)->buried_buffer_list
= XCDR (link
);
1656 XSETCDR (prev
, XCDR (XCDR (prev
)));
1662 /* Now move this buffer to the front of frame_buffer_list also. */
1665 for (link
= frame_buffer_list (frame
); CONSP (link
);
1668 if (EQ (XCAR (link
), buf
))
1673 /* Effectively do delq. */
1678 set_frame_buffer_list (frame
,
1679 XCDR (frame_buffer_list (frame
)));
1681 XSETCDR (prev
, XCDR (XCDR (prev
)));
1683 XSETCDR (link
, frame_buffer_list (frame
));
1684 set_frame_buffer_list (frame
, link
);
1687 set_frame_buffer_list (frame
, Fcons (buf
, frame_buffer_list (frame
)));
1690 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode
, Sset_buffer_major_mode
, 1, 1, 0,
1691 doc
: /* Set an appropriate major mode for BUFFER.
1692 For the *scratch* buffer, use `initial-major-mode', otherwise choose a mode
1693 according to `default-major-mode'.
1694 Use this function before selecting the buffer, since it may need to inspect
1695 the current buffer's major mode. */)
1700 Lisp_Object function
;
1702 CHECK_BUFFER (buffer
);
1704 if (STRINGP (XBUFFER (buffer
)->name
)
1705 && strcmp (SDATA (XBUFFER (buffer
)->name
), "*scratch*") == 0)
1706 function
= find_symbol_value (intern ("initial-major-mode"));
1709 function
= buffer_defaults
.major_mode
;
1711 && NILP (Fget (current_buffer
->major_mode
, Qmode_class
)))
1712 function
= current_buffer
->major_mode
;
1715 if (NILP (function
) || EQ (function
, Qfundamental_mode
))
1718 count
= SPECPDL_INDEX ();
1720 /* To select a nonfundamental mode,
1721 select the buffer temporarily and then call the mode function. */
1723 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1725 Fset_buffer (buffer
);
1728 return unbind_to (count
, Qnil
);
1731 /* Switch to buffer BUFFER in the selected window.
1732 If NORECORD is non-nil, don't call record_buffer. */
1735 switch_to_buffer_1 (buffer_or_name
, norecord
)
1736 Lisp_Object buffer_or_name
, norecord
;
1738 register Lisp_Object buffer
;
1740 if (NILP (buffer_or_name
))
1741 buffer
= Fother_buffer (Fcurrent_buffer (), Qnil
, Qnil
);
1744 buffer
= Fget_buffer (buffer_or_name
);
1747 buffer
= Fget_buffer_create (buffer_or_name
);
1748 Fset_buffer_major_mode (buffer
);
1751 Fset_buffer (buffer
);
1752 if (NILP (norecord
))
1753 record_buffer (buffer
);
1755 Fset_window_buffer (EQ (selected_window
, minibuf_window
)
1756 ? Fnext_window (minibuf_window
, Qnil
, Qnil
)
1763 DEFUN ("switch-to-buffer", Fswitch_to_buffer
, Sswitch_to_buffer
, 1, 2,
1764 "(list (read-buffer-to-switch \"Switch to buffer: \"))",
1765 doc
: /* Make BUFFER-OR-NAME current and display it in selected window.
1766 BUFFER-OR-NAME may be a buffer, a string \(a buffer name), or
1767 nil. Return the buffer switched to.
1769 If BUFFER-OR-NAME is a string and does not identify an existing
1770 buffer, create a new buffer with that name. Interactively, if
1771 `confirm-nonexistent-file-or-buffer' is non-nil, request
1772 confirmation before creating a new buffer. If BUFFER-OR-NAME is
1773 nil, switch to buffer returned by `other-buffer'.
1775 Optional second arg NORECORD non-nil means do not put this buffer
1776 at the front of the list of recently selected ones. This
1777 function returns the buffer it switched to as a Lisp object.
1779 If the selected window is the minibuffer window or dedicated to
1780 its buffer, use `pop-to-buffer' for displaying the buffer.
1782 WARNING: This is NOT the way to work on another buffer temporarily
1783 within a Lisp program! Use `set-buffer' instead. That avoids
1784 messing with the window-buffer correspondences. */)
1785 (buffer_or_name
, norecord
)
1786 Lisp_Object buffer_or_name
, norecord
;
1790 if (EQ (buffer_or_name
, Fwindow_buffer (selected_window
)))
1792 /* Basically a NOP. Avoid signalling an error in the case where
1793 the selected window is dedicated, or a minibuffer. */
1795 /* But do put this buffer at the front of the buffer list, unless
1796 that has been inhibited. Note that even if BUFFER-OR-NAME is
1797 at the front of the main buffer-list already, we still want to
1798 move it to the front of the frame's buffer list. */
1799 if (NILP (norecord
))
1800 record_buffer (buffer_or_name
);
1801 return Fset_buffer (buffer_or_name
);
1804 if (EQ (minibuf_window
, selected_window
)
1805 || !NILP (Fwindow_dedicated_p (selected_window
)))
1806 /* We can't use the selected window so let `pop-to-buffer' try some
1808 return call3 (intern ("pop-to-buffer"), buffer_or_name
, Qnil
, norecord
);
1810 return switch_to_buffer_1 (buffer_or_name
, norecord
);
1813 DEFUN ("current-buffer", Fcurrent_buffer
, Scurrent_buffer
, 0, 0, 0,
1814 doc
: /* Return the current buffer as a Lisp object. */)
1817 register Lisp_Object buf
;
1818 XSETBUFFER (buf
, current_buffer
);
1822 /* Set the current buffer to B.
1824 We previously set windows_or_buffers_changed here to invalidate
1825 global unchanged information in beg_unchanged and end_unchanged.
1826 This is no longer necessary because we now compute unchanged
1827 information on a buffer-basis. Every action affecting other
1828 windows than the selected one requires a select_window at some
1829 time, and that increments windows_or_buffers_changed. */
1832 set_buffer_internal (b
)
1833 register struct buffer
*b
;
1835 if (current_buffer
!= b
)
1836 set_buffer_internal_1 (b
);
1839 /* Set the current buffer to B, and do not set windows_or_buffers_changed.
1840 This is used by redisplay. */
1843 set_buffer_internal_1 (b
)
1844 register struct buffer
*b
;
1846 register struct buffer
*old_buf
;
1847 register Lisp_Object tail
, valcontents
;
1850 #ifdef USE_MMAP_FOR_BUFFERS
1851 if (b
->text
->beg
== NULL
)
1852 enlarge_buffer_text (b
, 0);
1853 #endif /* USE_MMAP_FOR_BUFFERS */
1855 if (current_buffer
== b
)
1858 old_buf
= current_buffer
;
1860 last_known_column_point
= -1; /* invalidate indentation cache */
1864 /* Put the undo list back in the base buffer, so that it appears
1865 that an indirect buffer shares the undo list of its base. */
1866 if (old_buf
->base_buffer
)
1867 old_buf
->base_buffer
->undo_list
= old_buf
->undo_list
;
1869 /* If the old current buffer has markers to record PT, BEGV and ZV
1870 when it is not current, update them now. */
1871 if (! NILP (old_buf
->pt_marker
))
1874 XSETBUFFER (obuf
, old_buf
);
1875 set_marker_both (old_buf
->pt_marker
, obuf
,
1876 BUF_PT (old_buf
), BUF_PT_BYTE (old_buf
));
1878 if (! NILP (old_buf
->begv_marker
))
1881 XSETBUFFER (obuf
, old_buf
);
1882 set_marker_both (old_buf
->begv_marker
, obuf
,
1883 BUF_BEGV (old_buf
), BUF_BEGV_BYTE (old_buf
));
1885 if (! NILP (old_buf
->zv_marker
))
1888 XSETBUFFER (obuf
, old_buf
);
1889 set_marker_both (old_buf
->zv_marker
, obuf
,
1890 BUF_ZV (old_buf
), BUF_ZV_BYTE (old_buf
));
1894 /* Get the undo list from the base buffer, so that it appears
1895 that an indirect buffer shares the undo list of its base. */
1897 b
->undo_list
= b
->base_buffer
->undo_list
;
1899 /* If the new current buffer has markers to record PT, BEGV and ZV
1900 when it is not current, fetch them now. */
1901 if (! NILP (b
->pt_marker
))
1903 BUF_PT (b
) = marker_position (b
->pt_marker
);
1904 BUF_PT_BYTE (b
) = marker_byte_position (b
->pt_marker
);
1906 if (! NILP (b
->begv_marker
))
1908 BUF_BEGV (b
) = marker_position (b
->begv_marker
);
1909 BUF_BEGV_BYTE (b
) = marker_byte_position (b
->begv_marker
);
1911 if (! NILP (b
->zv_marker
))
1913 BUF_ZV (b
) = marker_position (b
->zv_marker
);
1914 BUF_ZV_BYTE (b
) = marker_byte_position (b
->zv_marker
);
1917 /* Look down buffer's list of local Lisp variables
1918 to find and update any that forward into C variables. */
1920 for (tail
= b
->local_var_alist
; CONSP (tail
); tail
= XCDR (tail
))
1922 valcontents
= SYMBOL_VALUE (XCAR (XCAR (tail
)));
1923 if ((BUFFER_LOCAL_VALUEP (valcontents
))
1924 && (tem
= XBUFFER_LOCAL_VALUE (valcontents
)->realvalue
,
1925 (BOOLFWDP (tem
) || INTFWDP (tem
) || OBJFWDP (tem
))))
1926 /* Just reference the variable
1927 to cause it to become set for this buffer. */
1928 Fsymbol_value (XCAR (XCAR (tail
)));
1931 /* Do the same with any others that were local to the previous buffer */
1934 for (tail
= old_buf
->local_var_alist
; CONSP (tail
); tail
= XCDR (tail
))
1936 valcontents
= SYMBOL_VALUE (XCAR (XCAR (tail
)));
1937 if ((BUFFER_LOCAL_VALUEP (valcontents
))
1938 && (tem
= XBUFFER_LOCAL_VALUE (valcontents
)->realvalue
,
1939 (BOOLFWDP (tem
) || INTFWDP (tem
) || OBJFWDP (tem
))))
1940 /* Just reference the variable
1941 to cause it to become set for this buffer. */
1942 Fsymbol_value (XCAR (XCAR (tail
)));
1946 /* Switch to buffer B temporarily for redisplay purposes.
1947 This avoids certain things that don't need to be done within redisplay. */
1953 register struct buffer
*old_buf
;
1955 if (current_buffer
== b
)
1958 old_buf
= current_buffer
;
1963 /* If the old current buffer has markers to record PT, BEGV and ZV
1964 when it is not current, update them now. */
1965 if (! NILP (old_buf
->pt_marker
))
1968 XSETBUFFER (obuf
, old_buf
);
1969 set_marker_both (old_buf
->pt_marker
, obuf
,
1970 BUF_PT (old_buf
), BUF_PT_BYTE (old_buf
));
1972 if (! NILP (old_buf
->begv_marker
))
1975 XSETBUFFER (obuf
, old_buf
);
1976 set_marker_both (old_buf
->begv_marker
, obuf
,
1977 BUF_BEGV (old_buf
), BUF_BEGV_BYTE (old_buf
));
1979 if (! NILP (old_buf
->zv_marker
))
1982 XSETBUFFER (obuf
, old_buf
);
1983 set_marker_both (old_buf
->zv_marker
, obuf
,
1984 BUF_ZV (old_buf
), BUF_ZV_BYTE (old_buf
));
1988 /* If the new current buffer has markers to record PT, BEGV and ZV
1989 when it is not current, fetch them now. */
1990 if (! NILP (b
->pt_marker
))
1992 BUF_PT (b
) = marker_position (b
->pt_marker
);
1993 BUF_PT_BYTE (b
) = marker_byte_position (b
->pt_marker
);
1995 if (! NILP (b
->begv_marker
))
1997 BUF_BEGV (b
) = marker_position (b
->begv_marker
);
1998 BUF_BEGV_BYTE (b
) = marker_byte_position (b
->begv_marker
);
2000 if (! NILP (b
->zv_marker
))
2002 BUF_ZV (b
) = marker_position (b
->zv_marker
);
2003 BUF_ZV_BYTE (b
) = marker_byte_position (b
->zv_marker
);
2007 DEFUN ("set-buffer", Fset_buffer
, Sset_buffer
, 1, 1, 0,
2008 doc
: /* Make buffer BUFFER-OR-NAME current for editing operations.
2009 BUFFER-OR-NAME may be a buffer or the name of an existing buffer. See
2010 also `save-excursion' when you want to make a buffer current
2011 temporarily. This function does not display the buffer, so its effect
2012 ends when the current command terminates. Use `switch-to-buffer' or
2013 `pop-to-buffer' to switch buffers permanently. */)
2015 register Lisp_Object buffer_or_name
;
2017 register Lisp_Object buffer
;
2018 buffer
= Fget_buffer (buffer_or_name
);
2020 nsberror (buffer_or_name
);
2021 if (NILP (XBUFFER (buffer
)->name
))
2022 error ("Selecting deleted buffer");
2023 set_buffer_internal (XBUFFER (buffer
));
2027 /* Set the current buffer to BUFFER provided it is alive. */
2030 set_buffer_if_live (buffer
)
2033 if (! NILP (XBUFFER (buffer
)->name
))
2034 Fset_buffer (buffer
);
2038 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only
,
2039 Sbarf_if_buffer_read_only
, 0, 0, 0,
2040 doc
: /* Signal a `buffer-read-only' error if the current buffer is read-only. */)
2043 if (!NILP (current_buffer
->read_only
)
2044 && NILP (Vinhibit_read_only
))
2045 xsignal1 (Qbuffer_read_only
, Fcurrent_buffer ());
2049 DEFUN ("bury-buffer", Fbury_buffer
, Sbury_buffer
, 0, 1, "",
2050 doc
: /* Put BUFFER-OR-NAME at the end of the list of all buffers.
2051 There it is the least likely candidate for `other-buffer' to return;
2052 thus, the least likely buffer for \\[switch-to-buffer] to select by
2055 The argument may be a buffer name or an actual buffer object. If
2056 BUFFER-OR-NAME is nil or omitted, bury the current buffer and remove it
2057 from the selected window if it is displayed there. If the selected
2058 window is dedicated to its buffer, delete that window if there are other
2059 windows on the same frame. If the selected window is the only window on
2060 its frame, iconify that frame. */)
2062 register Lisp_Object buffer_or_name
;
2066 /* Figure out what buffer we're going to bury. */
2067 if (NILP (buffer_or_name
))
2070 XSETBUFFER (buffer
, current_buffer
);
2072 tem
= Fwindow_buffer (selected_window
);
2073 /* If we're burying the current buffer, unshow it. */
2074 if (EQ (buffer
, tem
))
2076 if (NILP (Fwindow_dedicated_p (selected_window
)))
2077 Fswitch_to_buffer (Fother_buffer (buffer
, Qnil
, Qnil
), Qnil
);
2078 else if (NILP (XWINDOW (selected_window
)->parent
))
2079 Ficonify_frame (Fwindow_frame (selected_window
));
2081 Fdelete_window (selected_window
);
2086 buffer
= Fget_buffer (buffer_or_name
);
2088 nsberror (buffer_or_name
);
2091 /* Move buffer to the end of the buffer list. Do nothing if the
2092 buffer is killed. */
2093 if (!NILP (XBUFFER (buffer
)->name
))
2095 Lisp_Object aelt
, link
;
2097 aelt
= Frassq (buffer
, Vbuffer_alist
);
2098 link
= Fmemq (aelt
, Vbuffer_alist
);
2099 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
2100 XSETCDR (link
, Qnil
);
2101 Vbuffer_alist
= nconc2 (Vbuffer_alist
, link
);
2103 XFRAME (selected_frame
)->buffer_list
2104 = Fdelq (buffer
, XFRAME (selected_frame
)->buffer_list
);
2105 XFRAME (selected_frame
)->buried_buffer_list
2106 = Fcons (buffer
, Fdelq (buffer
, XFRAME (selected_frame
)->buried_buffer_list
));
2112 DEFUN ("erase-buffer", Ferase_buffer
, Serase_buffer
, 0, 0, "*",
2113 doc
: /* Delete the entire contents of the current buffer.
2114 Any narrowing restriction in effect (see `narrow-to-region') is removed,
2115 so the buffer is truly empty after this. */)
2122 current_buffer
->last_window_start
= 1;
2123 /* Prevent warnings, or suspension of auto saving, that would happen
2124 if future size is less than past size. Use of erase-buffer
2125 implies that the future text is not really related to the past text. */
2126 XSETFASTINT (current_buffer
->save_length
, 0);
2131 validate_region (b
, e
)
2132 register Lisp_Object
*b
, *e
;
2134 CHECK_NUMBER_COERCE_MARKER (*b
);
2135 CHECK_NUMBER_COERCE_MARKER (*e
);
2137 if (XINT (*b
) > XINT (*e
))
2140 tem
= *b
; *b
= *e
; *e
= tem
;
2143 if (!(BEGV
<= XINT (*b
) && XINT (*b
) <= XINT (*e
)
2144 && XINT (*e
) <= ZV
))
2145 args_out_of_range (*b
, *e
);
2148 /* Advance BYTE_POS up to a character boundary
2149 and return the adjusted position. */
2152 advance_to_char_boundary (byte_pos
)
2157 if (byte_pos
== BEG
)
2158 /* Beginning of buffer is always a character boundary. */
2161 c
= FETCH_BYTE (byte_pos
);
2162 if (! CHAR_HEAD_P (c
))
2164 /* We should advance BYTE_POS only when C is a constituent of a
2165 multibyte sequence. */
2166 int orig_byte_pos
= byte_pos
;
2171 c
= FETCH_BYTE (byte_pos
);
2173 while (! CHAR_HEAD_P (c
) && byte_pos
> BEG
);
2175 if (byte_pos
< orig_byte_pos
)
2176 byte_pos
= orig_byte_pos
;
2177 /* If C is a constituent of a multibyte sequence, BYTE_POS was
2178 surely advance to the correct character boundary. If C is
2179 not, BYTE_POS was unchanged. */
2185 DEFUN ("buffer-swap-text", Fbuffer_swap_text
, Sbuffer_swap_text
,
2187 doc
: /* Swap the text between current buffer and BUFFER. */)
2191 struct buffer
*other_buffer
;
2192 CHECK_BUFFER (buffer
);
2193 other_buffer
= XBUFFER (buffer
);
2195 if (NILP (other_buffer
->name
))
2196 error ("Cannot swap a dead buffer's text");
2198 /* Actually, it probably works just fine.
2199 * if (other_buffer == current_buffer)
2200 * error ("Cannot swap a buffer's text with itself"); */
2202 /* Actually, this may be workable as well, tho probably only if they're
2204 if (other_buffer
->base_buffer
2205 || current_buffer
->base_buffer
)
2206 error ("Cannot swap indirect buffers's text");
2208 { /* This is probably harder to make work. */
2209 struct buffer
*other
;
2210 for (other
= all_buffers
; other
; other
= other
->next
)
2211 if (other
->base_buffer
== other_buffer
2212 || other
->base_buffer
== current_buffer
)
2213 error ("One of the buffers to swap has indirect buffers");
2216 #define swapfield(field, type) \
2218 type tmp##field = other_buffer->field; \
2219 other_buffer->field = current_buffer->field; \
2220 current_buffer->field = tmp##field; \
2223 swapfield (own_text
, struct buffer_text
);
2224 eassert (current_buffer
->text
== ¤t_buffer
->own_text
);
2225 eassert (other_buffer
->text
== &other_buffer
->own_text
);
2226 swapfield (pt
, EMACS_INT
);
2227 swapfield (pt_byte
, EMACS_INT
);
2228 swapfield (begv
, EMACS_INT
);
2229 swapfield (begv_byte
, EMACS_INT
);
2230 swapfield (zv
, EMACS_INT
);
2231 swapfield (zv_byte
, EMACS_INT
);
2232 eassert (!current_buffer
->base_buffer
);
2233 eassert (!other_buffer
->base_buffer
);
2234 current_buffer
->clip_changed
= 1; other_buffer
->clip_changed
= 1;
2235 swapfield (newline_cache
, struct region_cache
*);
2236 swapfield (width_run_cache
, struct region_cache
*);
2237 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2238 other_buffer
->prevent_redisplay_optimizations_p
= 1;
2239 swapfield (overlays_before
, struct Lisp_Overlay
*);
2240 swapfield (overlays_after
, struct Lisp_Overlay
*);
2241 swapfield (overlay_center
, EMACS_INT
);
2242 swapfield (undo_list
, Lisp_Object
);
2243 swapfield (mark
, Lisp_Object
);
2244 swapfield (enable_multibyte_characters
, Lisp_Object
);
2245 /* FIXME: Not sure what we should do with these *_marker fields.
2246 Hopefully they're just nil anyway. */
2247 swapfield (pt_marker
, Lisp_Object
);
2248 swapfield (begv_marker
, Lisp_Object
);
2249 swapfield (zv_marker
, Lisp_Object
);
2250 current_buffer
->point_before_scroll
= Qnil
;
2251 other_buffer
->point_before_scroll
= Qnil
;
2253 current_buffer
->text
->modiff
++; other_buffer
->text
->modiff
++;
2254 current_buffer
->text
->chars_modiff
++; other_buffer
->text
->chars_modiff
++;
2255 current_buffer
->text
->overlay_modiff
++; other_buffer
->text
->overlay_modiff
++;
2256 current_buffer
->text
->beg_unchanged
= current_buffer
->text
->gpt
;
2257 current_buffer
->text
->end_unchanged
= current_buffer
->text
->gpt
;
2258 other_buffer
->text
->beg_unchanged
= other_buffer
->text
->gpt
;
2259 other_buffer
->text
->end_unchanged
= other_buffer
->text
->gpt
;
2261 struct Lisp_Marker
*m
;
2262 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
2263 if (m
->buffer
== other_buffer
)
2264 m
->buffer
= current_buffer
;
2266 /* Since there's no indirect buffer in sight, markers on
2267 BUF_MARKERS(buf) should either be for `buf' or dead. */
2268 eassert (!m
->buffer
);
2269 for (m
= BUF_MARKERS (other_buffer
); m
; m
= m
->next
)
2270 if (m
->buffer
== current_buffer
)
2271 m
->buffer
= other_buffer
;
2273 /* Since there's no indirect buffer in sight, markers on
2274 BUF_MARKERS(buf) should either be for `buf' or dead. */
2275 eassert (!m
->buffer
);
2277 { /* Some of the C code expects that w->buffer == w->pointm->buffer.
2278 So since we just swapped the markers between the two buffers, we need
2279 to undo the effect of this swap for window markers. */
2280 Lisp_Object w
= Fselected_window (), ws
= Qnil
;
2281 Lisp_Object buf1
, buf2
;
2282 XSETBUFFER (buf1
, current_buffer
); XSETBUFFER (buf2
, other_buffer
);
2284 while (NILP (Fmemq (w
, ws
)))
2287 if (MARKERP (XWINDOW (w
)->pointm
)
2288 && (EQ (XWINDOW (w
)->buffer
, buf1
)
2289 || EQ (XWINDOW (w
)->buffer
, buf2
)))
2290 Fset_marker (XWINDOW (w
)->pointm
,
2291 make_number (BUF_BEGV (XBUFFER (XWINDOW (w
)->buffer
))),
2292 XWINDOW (w
)->buffer
);
2293 w
= Fnext_window (w
, Qt
, Qt
);
2297 if (current_buffer
->text
->intervals
)
2298 (eassert (EQ (current_buffer
->text
->intervals
->up
.obj
, buffer
)),
2299 XSETBUFFER (current_buffer
->text
->intervals
->up
.obj
, current_buffer
));
2300 if (other_buffer
->text
->intervals
)
2301 (eassert (EQ (other_buffer
->text
->intervals
->up
.obj
, Fcurrent_buffer ())),
2302 XSETBUFFER (other_buffer
->text
->intervals
->up
.obj
, other_buffer
));
2307 DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte
, Sset_buffer_multibyte
,
2309 doc
: /* Set the multibyte flag of the current buffer to FLAG.
2310 If FLAG is t, this makes the buffer a multibyte buffer.
2311 If FLAG is nil, this makes the buffer a single-byte buffer.
2312 In these cases, the buffer contents remain unchanged as a sequence of
2313 bytes but the contents viewed as characters do change.
2314 If FLAG is `to', this makes the buffer a multibyte buffer by changing
2315 all eight-bit bytes to eight-bit characters.
2316 If the multibyte flag was really changed, undo information of the
2317 current buffer is cleared. */)
2321 struct Lisp_Marker
*tail
, *markers
;
2322 struct buffer
*other
;
2324 int narrowed
= (BEG
!= BEGV
|| Z
!= ZV
);
2325 int modified_p
= !NILP (Fbuffer_modified_p (Qnil
));
2326 Lisp_Object old_undo
= current_buffer
->undo_list
;
2327 struct gcpro gcpro1
;
2329 if (current_buffer
->base_buffer
)
2330 error ("Cannot do `set-buffer-multibyte' on an indirect buffer");
2332 /* Do nothing if nothing actually changes. */
2333 if (NILP (flag
) == NILP (current_buffer
->enable_multibyte_characters
))
2338 /* Don't record these buffer changes. We will put a special undo entry
2340 current_buffer
->undo_list
= Qt
;
2342 /* If the cached position is for this buffer, clear it out. */
2343 clear_charpos_cache (current_buffer
);
2346 begv
= BEGV_BYTE
, zv
= ZV_BYTE
;
2348 begv
= BEGV
, zv
= ZV
;
2358 /* Do this first, so it can use CHAR_TO_BYTE
2359 to calculate the old correspondences. */
2360 set_intervals_multibyte (0);
2362 current_buffer
->enable_multibyte_characters
= Qnil
;
2368 TEMP_SET_PT_BOTH (PT_BYTE
, PT_BYTE
);
2371 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
2372 tail
->charpos
= tail
->bytepos
;
2374 /* Convert multibyte form of 8-bit characters to unibyte. */
2389 if (ASCII_BYTE_P (*p
))
2391 else if (CHAR_BYTE8_HEAD_P (*p
))
2393 c
= STRING_CHAR_AND_LENGTH (p
, stop
- pos
, bytes
);
2394 /* Delete all bytes for this 8-bit character but the
2395 last one, and change the last one to the charcter
2398 del_range_2 (pos
, pos
, pos
+ bytes
, pos
+ bytes
, 0);
2410 bytes
= BYTES_BY_CHAR_HEAD (*p
);
2411 p
+= bytes
, pos
+= bytes
;
2415 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2421 unsigned char *p
, *pend
;
2423 /* Be sure not to have a multibyte sequence striding over the GAP.
2424 Ex: We change this: "...abc\302 _GAP_ \241def..."
2425 to: "...abc _GAP_ \302\241def..." */
2428 && GPT_BYTE
> 1 && GPT_BYTE
< Z_BYTE
2429 && ! CHAR_HEAD_P (*(GAP_END_ADDR
)))
2431 unsigned char *p
= GPT_ADDR
- 1;
2433 while (! CHAR_HEAD_P (*p
) && p
> BEG_ADDR
) p
--;
2434 if (BASE_LEADING_CODE_P (*p
))
2436 int new_gpt
= GPT_BYTE
- (GPT_ADDR
- p
);
2438 move_gap_both (new_gpt
, new_gpt
);
2442 /* Make the buffer contents valid as multibyte by converting
2443 8-bit characters to multibyte form. */
2461 if (ASCII_BYTE_P (*p
))
2463 else if (EQ (flag
, Qt
) && (bytes
= MULTIBYTE_LENGTH (p
, pend
)) > 0)
2464 p
+= bytes
, pos
+= bytes
;
2467 unsigned char tmp
[MAX_MULTIBYTE_LENGTH
];
2470 c
= BYTE8_TO_CHAR (*p
);
2471 bytes
= CHAR_STRING (c
, tmp
);
2473 TEMP_SET_PT_BOTH (pos
+ 1, pos
+ 1);
2475 insert_1_both (tmp
+ 1, bytes
, bytes
, 1, 0, 0);
2476 /* Now the gap is after the just inserted data. */
2494 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2496 /* Do this first, so that chars_in_text asks the right question.
2497 set_intervals_multibyte needs it too. */
2498 current_buffer
->enable_multibyte_characters
= Qt
;
2500 GPT_BYTE
= advance_to_char_boundary (GPT_BYTE
);
2501 GPT
= chars_in_text (BEG_ADDR
, GPT_BYTE
- BEG_BYTE
) + BEG
;
2503 Z
= chars_in_text (GAP_END_ADDR
, Z_BYTE
- GPT_BYTE
) + GPT
;
2505 BEGV_BYTE
= advance_to_char_boundary (BEGV_BYTE
);
2506 if (BEGV_BYTE
> GPT_BYTE
)
2507 BEGV
= chars_in_text (GAP_END_ADDR
, BEGV_BYTE
- GPT_BYTE
) + GPT
;
2509 BEGV
= chars_in_text (BEG_ADDR
, BEGV_BYTE
- BEG_BYTE
) + BEG
;
2511 ZV_BYTE
= advance_to_char_boundary (ZV_BYTE
);
2512 if (ZV_BYTE
> GPT_BYTE
)
2513 ZV
= chars_in_text (GAP_END_ADDR
, ZV_BYTE
- GPT_BYTE
) + GPT
;
2515 ZV
= chars_in_text (BEG_ADDR
, ZV_BYTE
- BEG_BYTE
) + BEG
;
2518 int pt_byte
= advance_to_char_boundary (PT_BYTE
);
2521 if (pt_byte
> GPT_BYTE
)
2522 pt
= chars_in_text (GAP_END_ADDR
, pt_byte
- GPT_BYTE
) + GPT
;
2524 pt
= chars_in_text (BEG_ADDR
, pt_byte
- BEG_BYTE
) + BEG
;
2525 TEMP_SET_PT_BOTH (pt
, pt_byte
);
2528 tail
= markers
= BUF_MARKERS (current_buffer
);
2530 /* This prevents BYTE_TO_CHAR (that is, buf_bytepos_to_charpos) from
2531 getting confused by the markers that have not yet been updated.
2532 It is also a signal that it should never create a marker. */
2533 BUF_MARKERS (current_buffer
) = NULL
;
2535 for (; tail
; tail
= tail
->next
)
2537 tail
->bytepos
= advance_to_char_boundary (tail
->bytepos
);
2538 tail
->charpos
= BYTE_TO_CHAR (tail
->bytepos
);
2541 /* Make sure no markers were put on the chain
2542 while the chain value was incorrect. */
2543 if (BUF_MARKERS (current_buffer
))
2546 BUF_MARKERS (current_buffer
) = markers
;
2548 /* Do this last, so it can calculate the new correspondences
2549 between chars and bytes. */
2550 set_intervals_multibyte (1);
2553 if (!EQ (old_undo
, Qt
))
2555 /* Represent all the above changes by a special undo entry. */
2556 extern Lisp_Object Qapply
;
2557 current_buffer
->undo_list
= Fcons (list3 (Qapply
,
2558 intern ("set-buffer-multibyte"),
2559 NILP (flag
) ? Qt
: Qnil
),
2565 /* Changing the multibyteness of a buffer means that all windows
2566 showing that buffer must be updated thoroughly. */
2567 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2568 ++windows_or_buffers_changed
;
2570 /* Copy this buffer's new multibyte status
2571 into all of its indirect buffers. */
2572 for (other
= all_buffers
; other
; other
= other
->next
)
2573 if (other
->base_buffer
== current_buffer
&& !NILP (other
->name
))
2575 other
->enable_multibyte_characters
2576 = current_buffer
->enable_multibyte_characters
;
2577 other
->prevent_redisplay_optimizations_p
= 1;
2580 /* Restore the modifiedness of the buffer. */
2581 if (!modified_p
&& !NILP (Fbuffer_modified_p (Qnil
)))
2582 Fset_buffer_modified_p (Qnil
);
2585 /* Update coding systems of this buffer's process (if any). */
2587 Lisp_Object process
;
2589 process
= Fget_buffer_process (Fcurrent_buffer ());
2590 if (PROCESSP (process
))
2591 setup_process_coding_systems (process
);
2593 #endif /* subprocesses */
2598 DEFUN ("kill-all-local-variables", Fkill_all_local_variables
, Skill_all_local_variables
,
2600 doc
: /* Switch to Fundamental mode by killing current buffer's local variables.
2601 Most local variable bindings are eliminated so that the default values
2602 become effective once more. Also, the syntax table is set from
2603 `standard-syntax-table', the local keymap is set to nil,
2604 and the abbrev table from `fundamental-mode-abbrev-table'.
2605 This function also forces redisplay of the mode line.
2607 Every function to select a new major mode starts by
2608 calling this function.
2610 As a special exception, local variables whose names have
2611 a non-nil `permanent-local' property are not eliminated by this function.
2613 The first thing this function does is run
2614 the normal hook `change-major-mode-hook'. */)
2617 if (!NILP (Vrun_hooks
))
2618 call1 (Vrun_hooks
, Qchange_major_mode_hook
);
2620 /* Make sure none of the bindings in local_var_alist
2621 remain swapped in, in their symbols. */
2623 swap_out_buffer_local_variables (current_buffer
);
2625 /* Actually eliminate all local bindings of this buffer. */
2627 reset_buffer_local_variables (current_buffer
, 0);
2629 /* Force mode-line redisplay. Useful here because all major mode
2630 commands call this function. */
2631 update_mode_lines
++;
2636 /* Make sure no local variables remain set up with buffer B
2637 for their current values. */
2640 swap_out_buffer_local_variables (b
)
2643 Lisp_Object oalist
, alist
, sym
, tem
, buffer
;
2645 XSETBUFFER (buffer
, b
);
2646 oalist
= b
->local_var_alist
;
2648 for (alist
= oalist
; CONSP (alist
); alist
= XCDR (alist
))
2650 sym
= XCAR (XCAR (alist
));
2652 /* Need not do anything if some other buffer's binding is now encached. */
2653 tem
= XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->buffer
;
2654 if (EQ (tem
, buffer
))
2656 /* Symbol is set up for this buffer's old local value:
2658 swap_in_global_binding (sym
);
2663 /* Find all the overlays in the current buffer that contain position POS.
2664 Return the number found, and store them in a vector in *VEC_PTR.
2665 Store in *LEN_PTR the size allocated for the vector.
2666 Store in *NEXT_PTR the next position after POS where an overlay starts,
2667 or ZV if there are no more overlays between POS and ZV.
2668 Store in *PREV_PTR the previous position before POS where an overlay ends,
2669 or where an overlay starts which ends at or after POS;
2670 or BEGV if there are no such overlays from BEGV to POS.
2671 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2673 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2674 when this function is called.
2676 If EXTEND is non-zero, we make the vector bigger if necessary.
2677 If EXTEND is zero, we never extend the vector,
2678 and we store only as many overlays as will fit.
2679 But we still return the total number of overlays.
2681 If CHANGE_REQ is true, then any position written into *PREV_PTR or
2682 *NEXT_PTR is guaranteed to be not equal to POS, unless it is the
2683 default (BEGV or ZV). */
2686 overlays_at (pos
, extend
, vec_ptr
, len_ptr
, next_ptr
, prev_ptr
, change_req
)
2689 Lisp_Object
**vec_ptr
;
2691 EMACS_INT
*next_ptr
;
2692 EMACS_INT
*prev_ptr
;
2695 Lisp_Object overlay
, start
, end
;
2696 struct Lisp_Overlay
*tail
;
2699 Lisp_Object
*vec
= *vec_ptr
;
2702 int inhibit_storing
= 0;
2704 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2706 int startpos
, endpos
;
2708 XSETMISC (overlay
, tail
);
2710 start
= OVERLAY_START (overlay
);
2711 end
= OVERLAY_END (overlay
);
2712 endpos
= OVERLAY_POSITION (end
);
2719 startpos
= OVERLAY_POSITION (start
);
2720 /* This one ends at or after POS
2721 so its start counts for PREV_PTR if it's before POS. */
2722 if (prev
< startpos
&& startpos
< pos
)
2726 if (startpos
<= pos
)
2730 /* The supplied vector is full.
2731 Either make it bigger, or don't store any more in it. */
2734 /* Make it work with an initial len == 0. */
2739 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2743 inhibit_storing
= 1;
2746 if (!inhibit_storing
)
2748 /* Keep counting overlays even if we can't return them all. */
2751 else if (startpos
< next
)
2755 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2757 int startpos
, endpos
;
2759 XSETMISC (overlay
, tail
);
2761 start
= OVERLAY_START (overlay
);
2762 end
= OVERLAY_END (overlay
);
2763 startpos
= OVERLAY_POSITION (start
);
2766 if (startpos
< next
)
2770 endpos
= OVERLAY_POSITION (end
);
2777 /* Make it work with an initial len == 0. */
2782 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2786 inhibit_storing
= 1;
2789 if (!inhibit_storing
)
2793 if (startpos
< pos
&& startpos
> prev
)
2796 else if (endpos
< pos
&& endpos
> prev
)
2798 else if (endpos
== pos
&& startpos
> prev
2799 && (!change_req
|| startpos
< pos
))
2810 /* Find all the overlays in the current buffer that overlap the range
2811 BEG-END, or are empty at BEG, or are empty at END provided END
2812 denotes the position at the end of the current buffer.
2814 Return the number found, and store them in a vector in *VEC_PTR.
2815 Store in *LEN_PTR the size allocated for the vector.
2816 Store in *NEXT_PTR the next position after POS where an overlay starts,
2817 or ZV if there are no more overlays.
2818 Store in *PREV_PTR the previous position before POS where an overlay ends,
2819 or BEGV if there are no previous overlays.
2820 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2822 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2823 when this function is called.
2825 If EXTEND is non-zero, we make the vector bigger if necessary.
2826 If EXTEND is zero, we never extend the vector,
2827 and we store only as many overlays as will fit.
2828 But we still return the total number of overlays. */
2831 overlays_in (beg
, end
, extend
, vec_ptr
, len_ptr
, next_ptr
, prev_ptr
)
2834 Lisp_Object
**vec_ptr
;
2839 Lisp_Object overlay
, ostart
, oend
;
2840 struct Lisp_Overlay
*tail
;
2843 Lisp_Object
*vec
= *vec_ptr
;
2846 int inhibit_storing
= 0;
2847 int end_is_Z
= end
== Z
;
2849 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2851 int startpos
, endpos
;
2853 XSETMISC (overlay
, tail
);
2855 ostart
= OVERLAY_START (overlay
);
2856 oend
= OVERLAY_END (overlay
);
2857 endpos
= OVERLAY_POSITION (oend
);
2864 startpos
= OVERLAY_POSITION (ostart
);
2865 /* Count an interval if it overlaps the range, is empty at the
2866 start of the range, or is empty at END provided END denotes the
2867 end of the buffer. */
2868 if ((beg
< endpos
&& startpos
< end
)
2869 || (startpos
== endpos
2870 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
2874 /* The supplied vector is full.
2875 Either make it bigger, or don't store any more in it. */
2878 /* Make it work with an initial len == 0. */
2883 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2887 inhibit_storing
= 1;
2890 if (!inhibit_storing
)
2892 /* Keep counting overlays even if we can't return them all. */
2895 else if (startpos
< next
)
2899 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2901 int startpos
, endpos
;
2903 XSETMISC (overlay
, tail
);
2905 ostart
= OVERLAY_START (overlay
);
2906 oend
= OVERLAY_END (overlay
);
2907 startpos
= OVERLAY_POSITION (ostart
);
2910 if (startpos
< next
)
2914 endpos
= OVERLAY_POSITION (oend
);
2915 /* Count an interval if it overlaps the range, is empty at the
2916 start of the range, or is empty at END provided END denotes the
2917 end of the buffer. */
2918 if ((beg
< endpos
&& startpos
< end
)
2919 || (startpos
== endpos
2920 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
2926 /* Make it work with an initial len == 0. */
2931 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2935 inhibit_storing
= 1;
2938 if (!inhibit_storing
)
2942 else if (endpos
< beg
&& endpos
> prev
)
2954 /* Return non-zero if there exists an overlay with a non-nil
2955 `mouse-face' property overlapping OVERLAY. */
2958 mouse_face_overlay_overlaps (overlay
)
2959 Lisp_Object overlay
;
2961 int start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2962 int end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2964 Lisp_Object
*v
, tem
;
2967 v
= (Lisp_Object
*) alloca (size
* sizeof *v
);
2968 n
= overlays_in (start
, end
, 0, &v
, &size
, NULL
, NULL
);
2971 v
= (Lisp_Object
*) alloca (n
* sizeof *v
);
2972 overlays_in (start
, end
, 0, &v
, &n
, NULL
, NULL
);
2975 for (i
= 0; i
< n
; ++i
)
2976 if (!EQ (v
[i
], overlay
)
2977 && (tem
= Foverlay_get (overlay
, Qmouse_face
),
2986 /* Fast function to just test if we're at an overlay boundary. */
2988 overlay_touches_p (pos
)
2991 Lisp_Object overlay
;
2992 struct Lisp_Overlay
*tail
;
2994 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2998 XSETMISC (overlay
,tail
);
2999 if (!OVERLAYP (overlay
))
3002 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3005 if (endpos
== pos
|| OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
)
3009 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
3013 XSETMISC (overlay
, tail
);
3014 if (!OVERLAYP (overlay
))
3017 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3020 if (startpos
== pos
|| OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
)
3028 Lisp_Object overlay
;
3034 compare_overlays (v1
, v2
)
3035 const void *v1
, *v2
;
3037 const struct sortvec
*s1
= (const struct sortvec
*) v1
;
3038 const struct sortvec
*s2
= (const struct sortvec
*) v2
;
3039 if (s1
->priority
!= s2
->priority
)
3040 return s1
->priority
- s2
->priority
;
3041 if (s1
->beg
!= s2
->beg
)
3042 return s1
->beg
- s2
->beg
;
3043 if (s1
->end
!= s2
->end
)
3044 return s2
->end
- s1
->end
;
3048 /* Sort an array of overlays by priority. The array is modified in place.
3049 The return value is the new size; this may be smaller than the original
3050 size if some of the overlays were invalid or were window-specific. */
3052 sort_overlays (overlay_vec
, noverlays
, w
)
3053 Lisp_Object
*overlay_vec
;
3058 struct sortvec
*sortvec
;
3059 sortvec
= (struct sortvec
*) alloca (noverlays
* sizeof (struct sortvec
));
3061 /* Put the valid and relevant overlays into sortvec. */
3063 for (i
= 0, j
= 0; i
< noverlays
; i
++)
3066 Lisp_Object overlay
;
3068 overlay
= overlay_vec
[i
];
3069 if (OVERLAY_VALID (overlay
)
3070 && OVERLAY_POSITION (OVERLAY_START (overlay
)) > 0
3071 && OVERLAY_POSITION (OVERLAY_END (overlay
)) > 0)
3073 /* If we're interested in a specific window, then ignore
3074 overlays that are limited to some other window. */
3079 window
= Foverlay_get (overlay
, Qwindow
);
3080 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3084 /* This overlay is good and counts: put it into sortvec. */
3085 sortvec
[j
].overlay
= overlay
;
3086 sortvec
[j
].beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3087 sortvec
[j
].end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3088 tem
= Foverlay_get (overlay
, Qpriority
);
3090 sortvec
[j
].priority
= XINT (tem
);
3092 sortvec
[j
].priority
= 0;
3098 /* Sort the overlays into the proper order: increasing priority. */
3101 qsort (sortvec
, noverlays
, sizeof (struct sortvec
), compare_overlays
);
3103 for (i
= 0; i
< noverlays
; i
++)
3104 overlay_vec
[i
] = sortvec
[i
].overlay
;
3110 Lisp_Object string
, string2
;
3117 struct sortstr
*buf
; /* An array that expands as needed; never freed. */
3118 int size
; /* Allocated length of that array. */
3119 int used
; /* How much of the array is currently in use. */
3120 int bytes
; /* Total length of the strings in buf. */
3123 /* Buffers for storing information about the overlays touching a given
3124 position. These could be automatic variables in overlay_strings, but
3125 it's more efficient to hold onto the memory instead of repeatedly
3126 allocating and freeing it. */
3127 static struct sortstrlist overlay_heads
, overlay_tails
;
3128 static unsigned char *overlay_str_buf
;
3130 /* Allocated length of overlay_str_buf. */
3131 static int overlay_str_len
;
3133 /* A comparison function suitable for passing to qsort. */
3135 cmp_for_strings (as1
, as2
)
3138 struct sortstr
*s1
= (struct sortstr
*)as1
;
3139 struct sortstr
*s2
= (struct sortstr
*)as2
;
3140 if (s1
->size
!= s2
->size
)
3141 return s2
->size
- s1
->size
;
3142 if (s1
->priority
!= s2
->priority
)
3143 return s1
->priority
- s2
->priority
;
3148 record_overlay_string (ssl
, str
, str2
, pri
, size
)
3149 struct sortstrlist
*ssl
;
3150 Lisp_Object str
, str2
, pri
;
3155 if (ssl
->used
== ssl
->size
)
3161 ssl
->buf
= ((struct sortstr
*)
3162 xrealloc (ssl
->buf
, ssl
->size
* sizeof (struct sortstr
)));
3164 ssl
->buf
[ssl
->used
].string
= str
;
3165 ssl
->buf
[ssl
->used
].string2
= str2
;
3166 ssl
->buf
[ssl
->used
].size
= size
;
3167 ssl
->buf
[ssl
->used
].priority
= (INTEGERP (pri
) ? XINT (pri
) : 0);
3170 if (NILP (current_buffer
->enable_multibyte_characters
))
3171 nbytes
= SCHARS (str
);
3172 else if (! STRING_MULTIBYTE (str
))
3173 nbytes
= count_size_as_multibyte (SDATA (str
),
3176 nbytes
= SBYTES (str
);
3178 ssl
->bytes
+= nbytes
;
3182 if (NILP (current_buffer
->enable_multibyte_characters
))
3183 nbytes
= SCHARS (str2
);
3184 else if (! STRING_MULTIBYTE (str2
))
3185 nbytes
= count_size_as_multibyte (SDATA (str2
),
3188 nbytes
= SBYTES (str2
);
3190 ssl
->bytes
+= nbytes
;
3194 /* Return the concatenation of the strings associated with overlays that
3195 begin or end at POS, ignoring overlays that are specific to a window
3196 other than W. The strings are concatenated in the appropriate order:
3197 shorter overlays nest inside longer ones, and higher priority inside
3198 lower. Normally all of the after-strings come first, but zero-sized
3199 overlays have their after-strings ride along with the before-strings
3200 because it would look strange to print them inside-out.
3202 Returns the string length, and stores the contents indirectly through
3203 PSTR, if that variable is non-null. The string may be overwritten by
3204 subsequent calls. */
3207 overlay_strings (pos
, w
, pstr
)
3210 unsigned char **pstr
;
3212 Lisp_Object overlay
, window
, str
;
3213 struct Lisp_Overlay
*ov
;
3214 int startpos
, endpos
;
3215 int multibyte
= ! NILP (current_buffer
->enable_multibyte_characters
);
3217 overlay_heads
.used
= overlay_heads
.bytes
= 0;
3218 overlay_tails
.used
= overlay_tails
.bytes
= 0;
3219 for (ov
= current_buffer
->overlays_before
; ov
; ov
= ov
->next
)
3221 XSETMISC (overlay
, ov
);
3222 eassert (OVERLAYP (overlay
));
3224 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3225 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3228 if (endpos
!= pos
&& startpos
!= pos
)
3230 window
= Foverlay_get (overlay
, Qwindow
);
3231 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3234 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3235 record_overlay_string (&overlay_heads
, str
,
3237 ? Foverlay_get (overlay
, Qafter_string
)
3239 Foverlay_get (overlay
, Qpriority
),
3241 else if (endpos
== pos
3242 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3243 record_overlay_string (&overlay_tails
, str
, Qnil
,
3244 Foverlay_get (overlay
, Qpriority
),
3247 for (ov
= current_buffer
->overlays_after
; ov
; ov
= ov
->next
)
3249 XSETMISC (overlay
, ov
);
3250 eassert (OVERLAYP (overlay
));
3252 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3253 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3256 if (endpos
!= pos
&& startpos
!= pos
)
3258 window
= Foverlay_get (overlay
, Qwindow
);
3259 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3262 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3263 record_overlay_string (&overlay_heads
, str
,
3265 ? Foverlay_get (overlay
, Qafter_string
)
3267 Foverlay_get (overlay
, Qpriority
),
3269 else if (endpos
== pos
3270 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3271 record_overlay_string (&overlay_tails
, str
, Qnil
,
3272 Foverlay_get (overlay
, Qpriority
),
3275 if (overlay_tails
.used
> 1)
3276 qsort (overlay_tails
.buf
, overlay_tails
.used
, sizeof (struct sortstr
),
3278 if (overlay_heads
.used
> 1)
3279 qsort (overlay_heads
.buf
, overlay_heads
.used
, sizeof (struct sortstr
),
3281 if (overlay_heads
.bytes
|| overlay_tails
.bytes
)
3286 int total
= overlay_heads
.bytes
+ overlay_tails
.bytes
;
3288 if (total
> overlay_str_len
)
3290 overlay_str_len
= total
;
3291 overlay_str_buf
= (unsigned char *)xrealloc (overlay_str_buf
,
3294 p
= overlay_str_buf
;
3295 for (i
= overlay_tails
.used
; --i
>= 0;)
3298 tem
= overlay_tails
.buf
[i
].string
;
3299 nbytes
= copy_text (SDATA (tem
), p
,
3301 STRING_MULTIBYTE (tem
), multibyte
);
3304 for (i
= 0; i
< overlay_heads
.used
; ++i
)
3307 tem
= overlay_heads
.buf
[i
].string
;
3308 nbytes
= copy_text (SDATA (tem
), p
,
3310 STRING_MULTIBYTE (tem
), multibyte
);
3312 tem
= overlay_heads
.buf
[i
].string2
;
3315 nbytes
= copy_text (SDATA (tem
), p
,
3317 STRING_MULTIBYTE (tem
), multibyte
);
3321 if (p
!= overlay_str_buf
+ total
)
3324 *pstr
= overlay_str_buf
;
3330 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
3333 recenter_overlay_lists (buf
, pos
)
3337 Lisp_Object overlay
, beg
, end
;
3338 struct Lisp_Overlay
*prev
, *tail
, *next
;
3340 /* See if anything in overlays_before should move to overlays_after. */
3342 /* We don't strictly need prev in this loop; it should always be nil.
3343 But we use it for symmetry and in case that should cease to be true
3344 with some future change. */
3346 for (tail
= buf
->overlays_before
; tail
; prev
= tail
, tail
= next
)
3349 XSETMISC (overlay
, tail
);
3351 /* If the overlay is not valid, get rid of it. */
3352 if (!OVERLAY_VALID (overlay
))
3357 /* Splice the cons cell TAIL out of overlays_before. */
3361 buf
->overlays_before
= next
;
3367 beg
= OVERLAY_START (overlay
);
3368 end
= OVERLAY_END (overlay
);
3370 if (OVERLAY_POSITION (end
) > pos
)
3372 /* OVERLAY needs to be moved. */
3373 int where
= OVERLAY_POSITION (beg
);
3374 struct Lisp_Overlay
*other
, *other_prev
;
3376 /* Splice the cons cell TAIL out of overlays_before. */
3380 buf
->overlays_before
= next
;
3382 /* Search thru overlays_after for where to put it. */
3384 for (other
= buf
->overlays_after
; other
;
3385 other_prev
= other
, other
= other
->next
)
3387 Lisp_Object otherbeg
, otheroverlay
;
3389 XSETMISC (otheroverlay
, other
);
3390 eassert (OVERLAY_VALID (otheroverlay
));
3392 otherbeg
= OVERLAY_START (otheroverlay
);
3393 if (OVERLAY_POSITION (otherbeg
) >= where
)
3397 /* Add TAIL to overlays_after before OTHER. */
3400 other_prev
->next
= tail
;
3402 buf
->overlays_after
= tail
;
3406 /* We've reached the things that should stay in overlays_before.
3407 All the rest of overlays_before must end even earlier,
3412 /* See if anything in overlays_after should be in overlays_before. */
3414 for (tail
= buf
->overlays_after
; tail
; prev
= tail
, tail
= next
)
3417 XSETMISC (overlay
, tail
);
3419 /* If the overlay is not valid, get rid of it. */
3420 if (!OVERLAY_VALID (overlay
))
3425 /* Splice the cons cell TAIL out of overlays_after. */
3429 buf
->overlays_after
= next
;
3435 beg
= OVERLAY_START (overlay
);
3436 end
= OVERLAY_END (overlay
);
3438 /* Stop looking, when we know that nothing further
3439 can possibly end before POS. */
3440 if (OVERLAY_POSITION (beg
) > pos
)
3443 if (OVERLAY_POSITION (end
) <= pos
)
3445 /* OVERLAY needs to be moved. */
3446 int where
= OVERLAY_POSITION (end
);
3447 struct Lisp_Overlay
*other
, *other_prev
;
3449 /* Splice the cons cell TAIL out of overlays_after. */
3453 buf
->overlays_after
= next
;
3455 /* Search thru overlays_before for where to put it. */
3457 for (other
= buf
->overlays_before
; other
;
3458 other_prev
= other
, other
= other
->next
)
3460 Lisp_Object otherend
, otheroverlay
;
3462 XSETMISC (otheroverlay
, other
);
3463 eassert (OVERLAY_VALID (otheroverlay
));
3465 otherend
= OVERLAY_END (otheroverlay
);
3466 if (OVERLAY_POSITION (otherend
) <= where
)
3470 /* Add TAIL to overlays_before before OTHER. */
3473 other_prev
->next
= tail
;
3475 buf
->overlays_before
= tail
;
3480 buf
->overlay_center
= pos
;
3484 adjust_overlays_for_insert (pos
, length
)
3488 /* After an insertion, the lists are still sorted properly,
3489 but we may need to update the value of the overlay center. */
3490 if (current_buffer
->overlay_center
>= pos
)
3491 current_buffer
->overlay_center
+= length
;
3495 adjust_overlays_for_delete (pos
, length
)
3499 if (current_buffer
->overlay_center
< pos
)
3500 /* The deletion was to our right. No change needed; the before- and
3501 after-lists are still consistent. */
3503 else if (current_buffer
->overlay_center
> pos
+ length
)
3504 /* The deletion was to our left. We need to adjust the center value
3505 to account for the change in position, but the lists are consistent
3506 given the new value. */
3507 current_buffer
->overlay_center
-= length
;
3509 /* We're right in the middle. There might be things on the after-list
3510 that now belong on the before-list. Recentering will move them,
3511 and also update the center point. */
3512 recenter_overlay_lists (current_buffer
, pos
);
3515 /* Fix up overlays that were garbled as a result of permuting markers
3516 in the range START through END. Any overlay with at least one
3517 endpoint in this range will need to be unlinked from the overlay
3518 list and reinserted in its proper place.
3519 Such an overlay might even have negative size at this point.
3520 If so, we'll make the overlay empty. */
3522 fix_start_end_in_overlays (start
, end
)
3523 register int start
, end
;
3525 Lisp_Object overlay
;
3526 struct Lisp_Overlay
*before_list
, *after_list
;
3527 /* These are either nil, indicating that before_list or after_list
3528 should be assigned, or the cons cell the cdr of which should be
3530 struct Lisp_Overlay
*beforep
= NULL
, *afterp
= NULL
;
3531 /* 'Parent', likewise, indicates a cons cell or
3532 current_buffer->overlays_before or overlays_after, depending
3533 which loop we're in. */
3534 struct Lisp_Overlay
*tail
, *parent
;
3535 int startpos
, endpos
;
3537 /* This algorithm shifts links around instead of consing and GCing.
3538 The loop invariant is that before_list (resp. after_list) is a
3539 well-formed list except that its last element, the CDR of beforep
3540 (resp. afterp) if beforep (afterp) isn't nil or before_list
3541 (after_list) if it is, is still uninitialized. So it's not a bug
3542 that before_list isn't initialized, although it may look
3544 for (parent
= NULL
, tail
= current_buffer
->overlays_before
; tail
;)
3546 XSETMISC (overlay
, tail
);
3548 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3549 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3551 /* If the overlay is backwards, make it empty. */
3552 if (endpos
< startpos
)
3555 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3563 || (startpos
>= start
&& startpos
< end
))
3565 /* Add it to the end of the wrong list. Later on,
3566 recenter_overlay_lists will move it to the right place. */
3567 if (endpos
< current_buffer
->overlay_center
)
3572 afterp
->next
= tail
;
3580 beforep
->next
= tail
;
3584 current_buffer
->overlays_before
= tail
->next
;
3586 parent
->next
= tail
->next
;
3590 parent
= tail
, tail
= parent
->next
;
3592 for (parent
= NULL
, tail
= current_buffer
->overlays_after
; tail
;)
3594 XSETMISC (overlay
, tail
);
3596 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3597 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3599 /* If the overlay is backwards, make it empty. */
3600 if (endpos
< startpos
)
3603 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3607 if (startpos
>= end
)
3610 if (startpos
>= start
3611 || (endpos
>= start
&& endpos
< end
))
3613 if (endpos
< current_buffer
->overlay_center
)
3618 afterp
->next
= tail
;
3626 beforep
->next
= tail
;
3630 current_buffer
->overlays_after
= tail
->next
;
3632 parent
->next
= tail
->next
;
3636 parent
= tail
, tail
= parent
->next
;
3639 /* Splice the constructed (wrong) lists into the buffer's lists,
3640 and let the recenter function make it sane again. */
3643 beforep
->next
= current_buffer
->overlays_before
;
3644 current_buffer
->overlays_before
= before_list
;
3646 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3650 afterp
->next
= current_buffer
->overlays_after
;
3651 current_buffer
->overlays_after
= after_list
;
3653 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3656 /* We have two types of overlay: the one whose ending marker is
3657 after-insertion-marker (this is the usual case) and the one whose
3658 ending marker is before-insertion-marker. When `overlays_before'
3659 contains overlays of the latter type and the former type in this
3660 order and both overlays end at inserting position, inserting a text
3661 increases only the ending marker of the latter type, which results
3662 in incorrect ordering of `overlays_before'.
3664 This function fixes ordering of overlays in the slot
3665 `overlays_before' of the buffer *BP. Before the insertion, `point'
3666 was at PREV, and now is at POS. */
3669 fix_overlays_before (bp
, prev
, pos
)
3671 EMACS_INT prev
, pos
;
3673 /* If parent is nil, replace overlays_before; otherwise, parent->next. */
3674 struct Lisp_Overlay
*tail
= bp
->overlays_before
, *parent
= NULL
, *right_pair
;
3678 /* After the insertion, the several overlays may be in incorrect
3679 order. The possibility is that, in the list `overlays_before',
3680 an overlay which ends at POS appears after an overlay which ends
3681 at PREV. Since POS is greater than PREV, we must fix the
3682 ordering of these overlays, by moving overlays ends at POS before
3683 the overlays ends at PREV. */
3685 /* At first, find a place where disordered overlays should be linked
3686 in. It is where an overlay which end before POS exists. (i.e. an
3687 overlay whose ending marker is after-insertion-marker if disorder
3690 && (XSETMISC (tem
, tail
),
3691 (end
= OVERLAY_POSITION (OVERLAY_END (tem
))) >= pos
))
3697 /* If we don't find such an overlay,
3698 or the found one ends before PREV,
3699 or the found one is the last one in the list,
3700 we don't have to fix anything. */
3701 if (!tail
|| end
< prev
|| !tail
->next
)
3704 right_pair
= parent
;
3708 /* Now, end position of overlays in the list TAIL should be before
3709 or equal to PREV. In the loop, an overlay which ends at POS is
3710 moved ahead to the place indicated by the CDR of RIGHT_PAIR. If
3711 we found an overlay which ends before PREV, the remaining
3712 overlays are in correct order. */
3715 XSETMISC (tem
, tail
);
3716 end
= OVERLAY_POSITION (OVERLAY_END (tem
));
3719 { /* This overlay is disordered. */
3720 struct Lisp_Overlay
*found
= tail
;
3722 /* Unlink the found overlay. */
3724 parent
->next
= tail
;
3725 /* Move an overlay at RIGHT_PLACE to the next of the found one,
3726 and link it into the right place. */
3729 found
->next
= bp
->overlays_before
;
3730 bp
->overlays_before
= found
;
3734 found
->next
= right_pair
->next
;
3735 right_pair
->next
= found
;
3738 else if (end
== prev
)
3743 else /* No more disordered overlay. */
3748 DEFUN ("overlayp", Foverlayp
, Soverlayp
, 1, 1, 0,
3749 doc
: /* Return t if OBJECT is an overlay. */)
3753 return (OVERLAYP (object
) ? Qt
: Qnil
);
3756 DEFUN ("make-overlay", Fmake_overlay
, Smake_overlay
, 2, 5, 0,
3757 doc
: /* Create a new overlay with range BEG to END in BUFFER.
3758 If omitted, BUFFER defaults to the current buffer.
3759 BEG and END may be integers or markers.
3760 The fourth arg FRONT-ADVANCE, if non-nil, makes the marker
3761 for the front of the overlay advance when text is inserted there
3762 \(which means the text *is not* included in the overlay).
3763 The fifth arg REAR-ADVANCE, if non-nil, makes the marker
3764 for the rear of the overlay advance when text is inserted there
3765 \(which means the text *is* included in the overlay). */)
3766 (beg
, end
, buffer
, front_advance
, rear_advance
)
3767 Lisp_Object beg
, end
, buffer
;
3768 Lisp_Object front_advance
, rear_advance
;
3770 Lisp_Object overlay
;
3774 XSETBUFFER (buffer
, current_buffer
);
3776 CHECK_BUFFER (buffer
);
3778 && ! EQ (Fmarker_buffer (beg
), buffer
))
3779 error ("Marker points into wrong buffer");
3781 && ! EQ (Fmarker_buffer (end
), buffer
))
3782 error ("Marker points into wrong buffer");
3784 CHECK_NUMBER_COERCE_MARKER (beg
);
3785 CHECK_NUMBER_COERCE_MARKER (end
);
3787 if (XINT (beg
) > XINT (end
))
3790 temp
= beg
; beg
= end
; end
= temp
;
3793 b
= XBUFFER (buffer
);
3795 beg
= Fset_marker (Fmake_marker (), beg
, buffer
);
3796 end
= Fset_marker (Fmake_marker (), end
, buffer
);
3798 if (!NILP (front_advance
))
3799 XMARKER (beg
)->insertion_type
= 1;
3800 if (!NILP (rear_advance
))
3801 XMARKER (end
)->insertion_type
= 1;
3803 overlay
= allocate_misc ();
3804 XMISCTYPE (overlay
) = Lisp_Misc_Overlay
;
3805 XOVERLAY (overlay
)->start
= beg
;
3806 XOVERLAY (overlay
)->end
= end
;
3807 XOVERLAY (overlay
)->plist
= Qnil
;
3808 XOVERLAY (overlay
)->next
= NULL
;
3810 /* Put the new overlay on the wrong list. */
3811 end
= OVERLAY_END (overlay
);
3812 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
3814 if (b
->overlays_after
)
3815 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3816 b
->overlays_after
= XOVERLAY (overlay
);
3820 if (b
->overlays_before
)
3821 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3822 b
->overlays_before
= XOVERLAY (overlay
);
3825 /* This puts it in the right list, and in the right order. */
3826 recenter_overlay_lists (b
, b
->overlay_center
);
3828 /* We don't need to redisplay the region covered by the overlay, because
3829 the overlay has no properties at the moment. */
3834 /* Mark a section of BUF as needing redisplay because of overlays changes. */
3837 modify_overlay (buf
, start
, end
)
3839 EMACS_INT start
, end
;
3848 BUF_COMPUTE_UNCHANGED (buf
, start
, end
);
3850 /* If this is a buffer not in the selected window,
3851 we must do other windows. */
3852 if (buf
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
3853 windows_or_buffers_changed
= 1;
3854 /* If multiple windows show this buffer, we must do other windows. */
3855 else if (buffer_shared
> 1)
3856 windows_or_buffers_changed
= 1;
3857 /* If we modify an overlay at the end of the buffer, we cannot
3858 be sure that window end is still valid. */
3859 else if (end
>= ZV
&& start
<= ZV
)
3860 windows_or_buffers_changed
= 1;
3862 ++BUF_OVERLAY_MODIFF (buf
);
3866 Lisp_Object
Fdelete_overlay ();
3868 static struct Lisp_Overlay
*
3869 unchain_overlay (list
, overlay
)
3870 struct Lisp_Overlay
*list
, *overlay
;
3872 struct Lisp_Overlay
*tmp
, *prev
;
3873 for (tmp
= list
, prev
= NULL
; tmp
; prev
= tmp
, tmp
= tmp
->next
)
3877 prev
->next
= tmp
->next
;
3880 overlay
->next
= NULL
;
3886 DEFUN ("move-overlay", Fmove_overlay
, Smove_overlay
, 3, 4, 0,
3887 doc
: /* Set the endpoints of OVERLAY to BEG and END in BUFFER.
3888 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.
3889 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current
3891 (overlay
, beg
, end
, buffer
)
3892 Lisp_Object overlay
, beg
, end
, buffer
;
3894 struct buffer
*b
, *ob
;
3895 Lisp_Object obuffer
;
3896 int count
= SPECPDL_INDEX ();
3898 CHECK_OVERLAY (overlay
);
3900 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3902 XSETBUFFER (buffer
, current_buffer
);
3903 CHECK_BUFFER (buffer
);
3906 && ! EQ (Fmarker_buffer (beg
), buffer
))
3907 error ("Marker points into wrong buffer");
3909 && ! EQ (Fmarker_buffer (end
), buffer
))
3910 error ("Marker points into wrong buffer");
3912 CHECK_NUMBER_COERCE_MARKER (beg
);
3913 CHECK_NUMBER_COERCE_MARKER (end
);
3915 if (XINT (beg
) == XINT (end
) && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
3916 return Fdelete_overlay (overlay
);
3918 if (XINT (beg
) > XINT (end
))
3921 temp
= beg
; beg
= end
; end
= temp
;
3924 specbind (Qinhibit_quit
, Qt
);
3926 obuffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3927 b
= XBUFFER (buffer
);
3928 ob
= BUFFERP (obuffer
) ? XBUFFER (obuffer
) : (struct buffer
*) 0;
3930 /* If the overlay has changed buffers, do a thorough redisplay. */
3931 if (!EQ (buffer
, obuffer
))
3933 /* Redisplay where the overlay was. */
3934 if (!NILP (obuffer
))
3939 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3940 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3942 modify_overlay (ob
, o_beg
, o_end
);
3945 /* Redisplay where the overlay is going to be. */
3946 modify_overlay (b
, XINT (beg
), XINT (end
));
3949 /* Redisplay the area the overlay has just left, or just enclosed. */
3953 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3954 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3956 if (o_beg
== XINT (beg
))
3957 modify_overlay (b
, o_end
, XINT (end
));
3958 else if (o_end
== XINT (end
))
3959 modify_overlay (b
, o_beg
, XINT (beg
));
3962 if (XINT (beg
) < o_beg
) o_beg
= XINT (beg
);
3963 if (XINT (end
) > o_end
) o_end
= XINT (end
);
3964 modify_overlay (b
, o_beg
, o_end
);
3968 if (!NILP (obuffer
))
3971 = unchain_overlay (ob
->overlays_before
, XOVERLAY (overlay
));
3973 = unchain_overlay (ob
->overlays_after
, XOVERLAY (overlay
));
3974 eassert (XOVERLAY (overlay
)->next
== NULL
);
3977 Fset_marker (OVERLAY_START (overlay
), beg
, buffer
);
3978 Fset_marker (OVERLAY_END (overlay
), end
, buffer
);
3980 /* Put the overlay on the wrong list. */
3981 end
= OVERLAY_END (overlay
);
3982 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
3984 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3985 b
->overlays_after
= XOVERLAY (overlay
);
3989 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3990 b
->overlays_before
= XOVERLAY (overlay
);
3993 /* This puts it in the right list, and in the right order. */
3994 recenter_overlay_lists (b
, b
->overlay_center
);
3996 return unbind_to (count
, overlay
);
3999 DEFUN ("delete-overlay", Fdelete_overlay
, Sdelete_overlay
, 1, 1, 0,
4000 doc
: /* Delete the overlay OVERLAY from its buffer. */)
4002 Lisp_Object overlay
;
4006 int count
= SPECPDL_INDEX ();
4008 CHECK_OVERLAY (overlay
);
4010 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4014 b
= XBUFFER (buffer
);
4015 specbind (Qinhibit_quit
, Qt
);
4017 b
->overlays_before
= unchain_overlay (b
->overlays_before
,XOVERLAY (overlay
));
4018 b
->overlays_after
= unchain_overlay (b
->overlays_after
, XOVERLAY (overlay
));
4019 eassert (XOVERLAY (overlay
)->next
== NULL
);
4021 marker_position (OVERLAY_START (overlay
)),
4022 marker_position (OVERLAY_END (overlay
)));
4023 Fset_marker (OVERLAY_START (overlay
), Qnil
, Qnil
);
4024 Fset_marker (OVERLAY_END (overlay
), Qnil
, Qnil
);
4026 /* When deleting an overlay with before or after strings, turn off
4027 display optimizations for the affected buffer, on the basis that
4028 these strings may contain newlines. This is easier to do than to
4029 check for that situation during redisplay. */
4030 if (!windows_or_buffers_changed
4031 && (!NILP (Foverlay_get (overlay
, Qbefore_string
))
4032 || !NILP (Foverlay_get (overlay
, Qafter_string
))))
4033 b
->prevent_redisplay_optimizations_p
= 1;
4035 return unbind_to (count
, Qnil
);
4038 /* Overlay dissection functions. */
4040 DEFUN ("overlay-start", Foverlay_start
, Soverlay_start
, 1, 1, 0,
4041 doc
: /* Return the position at which OVERLAY starts. */)
4043 Lisp_Object overlay
;
4045 CHECK_OVERLAY (overlay
);
4047 return (Fmarker_position (OVERLAY_START (overlay
)));
4050 DEFUN ("overlay-end", Foverlay_end
, Soverlay_end
, 1, 1, 0,
4051 doc
: /* Return the position at which OVERLAY ends. */)
4053 Lisp_Object overlay
;
4055 CHECK_OVERLAY (overlay
);
4057 return (Fmarker_position (OVERLAY_END (overlay
)));
4060 DEFUN ("overlay-buffer", Foverlay_buffer
, Soverlay_buffer
, 1, 1, 0,
4061 doc
: /* Return the buffer OVERLAY belongs to.
4062 Return nil if OVERLAY has been deleted. */)
4064 Lisp_Object overlay
;
4066 CHECK_OVERLAY (overlay
);
4068 return Fmarker_buffer (OVERLAY_START (overlay
));
4071 DEFUN ("overlay-properties", Foverlay_properties
, Soverlay_properties
, 1, 1, 0,
4072 doc
: /* Return a list of the properties on OVERLAY.
4073 This is a copy of OVERLAY's plist; modifying its conses has no effect on
4076 Lisp_Object overlay
;
4078 CHECK_OVERLAY (overlay
);
4080 return Fcopy_sequence (XOVERLAY (overlay
)->plist
);
4084 DEFUN ("overlays-at", Foverlays_at
, Soverlays_at
, 1, 1, 0,
4085 doc
: /* Return a list of the overlays that contain the character at POS. */)
4090 Lisp_Object
*overlay_vec
;
4094 CHECK_NUMBER_COERCE_MARKER (pos
);
4097 /* We can't use alloca here because overlays_at can call xrealloc. */
4098 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
4100 /* Put all the overlays we want in a vector in overlay_vec.
4101 Store the length in len. */
4102 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4103 (EMACS_INT
*) 0, (EMACS_INT
*) 0, 0);
4105 /* Make a list of them all. */
4106 result
= Flist (noverlays
, overlay_vec
);
4108 xfree (overlay_vec
);
4112 DEFUN ("overlays-in", Foverlays_in
, Soverlays_in
, 2, 2, 0,
4113 doc
: /* Return a list of the overlays that overlap the region BEG ... END.
4114 Overlap means that at least one character is contained within the overlay
4115 and also contained within the specified region.
4116 Empty overlays are included in the result if they are located at BEG,
4117 between BEG and END, or at END provided END denotes the position at the
4118 end of the buffer. */)
4120 Lisp_Object beg
, end
;
4123 Lisp_Object
*overlay_vec
;
4127 CHECK_NUMBER_COERCE_MARKER (beg
);
4128 CHECK_NUMBER_COERCE_MARKER (end
);
4131 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
4133 /* Put all the overlays we want in a vector in overlay_vec.
4134 Store the length in len. */
4135 noverlays
= overlays_in (XINT (beg
), XINT (end
), 1, &overlay_vec
, &len
,
4136 (int *) 0, (int *) 0);
4138 /* Make a list of them all. */
4139 result
= Flist (noverlays
, overlay_vec
);
4141 xfree (overlay_vec
);
4145 DEFUN ("next-overlay-change", Fnext_overlay_change
, Snext_overlay_change
,
4147 doc
: /* Return the next position after POS where an overlay starts or ends.
4148 If there are no overlay boundaries from POS to (point-max),
4149 the value is (point-max). */)
4155 Lisp_Object
*overlay_vec
;
4159 CHECK_NUMBER_COERCE_MARKER (pos
);
4162 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
4164 /* Put all the overlays we want in a vector in overlay_vec.
4165 Store the length in len.
4166 endpos gets the position where the next overlay starts. */
4167 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4168 &endpos
, (EMACS_INT
*) 0, 1);
4170 /* If any of these overlays ends before endpos,
4171 use its ending point instead. */
4172 for (i
= 0; i
< noverlays
; i
++)
4177 oend
= OVERLAY_END (overlay_vec
[i
]);
4178 oendpos
= OVERLAY_POSITION (oend
);
4179 if (oendpos
< endpos
)
4183 xfree (overlay_vec
);
4184 return make_number (endpos
);
4187 DEFUN ("previous-overlay-change", Fprevious_overlay_change
,
4188 Sprevious_overlay_change
, 1, 1, 0,
4189 doc
: /* Return the previous position before POS where an overlay starts or ends.
4190 If there are no overlay boundaries from (point-min) to POS,
4191 the value is (point-min). */)
4197 Lisp_Object
*overlay_vec
;
4200 CHECK_NUMBER_COERCE_MARKER (pos
);
4202 /* At beginning of buffer, we know the answer;
4203 avoid bug subtracting 1 below. */
4204 if (XINT (pos
) == BEGV
)
4208 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
4210 /* Put all the overlays we want in a vector in overlay_vec.
4211 Store the length in len.
4212 prevpos gets the position of the previous change. */
4213 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4214 (EMACS_INT
*) 0, &prevpos
, 1);
4216 xfree (overlay_vec
);
4217 return make_number (prevpos
);
4220 /* These functions are for debugging overlays. */
4222 DEFUN ("overlay-lists", Foverlay_lists
, Soverlay_lists
, 0, 0, 0,
4223 doc
: /* Return a pair of lists giving all the overlays of the current buffer.
4224 The car has all the overlays before the overlay center;
4225 the cdr has all the overlays after the overlay center.
4226 Recentering overlays moves overlays between these lists.
4227 The lists you get are copies, so that changing them has no effect.
4228 However, the overlays you get are the real objects that the buffer uses. */)
4231 struct Lisp_Overlay
*ol
;
4232 Lisp_Object before
= Qnil
, after
= Qnil
, tmp
;
4233 for (ol
= current_buffer
->overlays_before
; ol
; ol
= ol
->next
)
4236 before
= Fcons (tmp
, before
);
4238 for (ol
= current_buffer
->overlays_after
; ol
; ol
= ol
->next
)
4241 after
= Fcons (tmp
, after
);
4243 return Fcons (Fnreverse (before
), Fnreverse (after
));
4246 DEFUN ("overlay-recenter", Foverlay_recenter
, Soverlay_recenter
, 1, 1, 0,
4247 doc
: /* Recenter the overlays of the current buffer around position POS.
4248 That makes overlay lookup faster for positions near POS (but perhaps slower
4249 for positions far away from POS). */)
4253 CHECK_NUMBER_COERCE_MARKER (pos
);
4255 recenter_overlay_lists (current_buffer
, XINT (pos
));
4259 DEFUN ("overlay-get", Foverlay_get
, Soverlay_get
, 2, 2, 0,
4260 doc
: /* Get the property of overlay OVERLAY with property name PROP. */)
4262 Lisp_Object overlay
, prop
;
4264 CHECK_OVERLAY (overlay
);
4265 return lookup_char_property (XOVERLAY (overlay
)->plist
, prop
, 0);
4268 DEFUN ("overlay-put", Foverlay_put
, Soverlay_put
, 3, 3, 0,
4269 doc
: /* Set one property of overlay OVERLAY: give property PROP value VALUE. */)
4270 (overlay
, prop
, value
)
4271 Lisp_Object overlay
, prop
, value
;
4273 Lisp_Object tail
, buffer
;
4276 CHECK_OVERLAY (overlay
);
4278 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4280 for (tail
= XOVERLAY (overlay
)->plist
;
4281 CONSP (tail
) && CONSP (XCDR (tail
));
4282 tail
= XCDR (XCDR (tail
)))
4283 if (EQ (XCAR (tail
), prop
))
4285 changed
= !EQ (XCAR (XCDR (tail
)), value
);
4286 XSETCAR (XCDR (tail
), value
);
4289 /* It wasn't in the list, so add it to the front. */
4290 changed
= !NILP (value
);
4291 XOVERLAY (overlay
)->plist
4292 = Fcons (prop
, Fcons (value
, XOVERLAY (overlay
)->plist
));
4294 if (! NILP (buffer
))
4297 modify_overlay (XBUFFER (buffer
),
4298 marker_position (OVERLAY_START (overlay
)),
4299 marker_position (OVERLAY_END (overlay
)));
4300 if (EQ (prop
, Qevaporate
) && ! NILP (value
)
4301 && (OVERLAY_POSITION (OVERLAY_START (overlay
))
4302 == OVERLAY_POSITION (OVERLAY_END (overlay
))))
4303 Fdelete_overlay (overlay
);
4309 /* Subroutine of report_overlay_modification. */
4311 /* Lisp vector holding overlay hook functions to call.
4312 Vector elements come in pairs.
4313 Each even-index element is a list of hook functions.
4314 The following odd-index element is the overlay they came from.
4316 Before the buffer change, we fill in this vector
4317 as we call overlay hook functions.
4318 After the buffer change, we get the functions to call from this vector.
4319 This way we always call the same functions before and after the change. */
4320 static Lisp_Object last_overlay_modification_hooks
;
4322 /* Number of elements actually used in last_overlay_modification_hooks. */
4323 static int last_overlay_modification_hooks_used
;
4325 /* Add one functionlist/overlay pair
4326 to the end of last_overlay_modification_hooks. */
4329 add_overlay_mod_hooklist (functionlist
, overlay
)
4330 Lisp_Object functionlist
, overlay
;
4332 int oldsize
= XVECTOR (last_overlay_modification_hooks
)->size
;
4334 if (last_overlay_modification_hooks_used
== oldsize
)
4335 last_overlay_modification_hooks
= larger_vector
4336 (last_overlay_modification_hooks
, oldsize
* 2, Qnil
);
4337 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4338 functionlist
); last_overlay_modification_hooks_used
++;
4339 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4340 overlay
); last_overlay_modification_hooks_used
++;
4343 /* Run the modification-hooks of overlays that include
4344 any part of the text in START to END.
4345 If this change is an insertion, also
4346 run the insert-before-hooks of overlay starting at END,
4347 and the insert-after-hooks of overlay ending at START.
4349 This is called both before and after the modification.
4350 AFTER is nonzero when we call after the modification.
4352 ARG1, ARG2, ARG3 are arguments to pass to the hook functions.
4353 When AFTER is nonzero, they are the start position,
4354 the position after the inserted new text,
4355 and the length of deleted or replaced old text. */
4358 report_overlay_modification (start
, end
, after
, arg1
, arg2
, arg3
)
4359 Lisp_Object start
, end
;
4361 Lisp_Object arg1
, arg2
, arg3
;
4363 Lisp_Object prop
, overlay
;
4364 struct Lisp_Overlay
*tail
;
4365 /* 1 if this change is an insertion. */
4366 int insertion
= (after
? XFASTINT (arg3
) == 0 : EQ (start
, end
));
4367 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4372 /* We used to run the functions as soon as we found them and only register
4373 them in last_overlay_modification_hooks for the purpose of the `after'
4374 case. But running elisp code as we traverse the list of overlays is
4375 painful because the list can be modified by the elisp code so we had to
4376 copy at several places. We now simply do a read-only traversal that
4377 only collects the functions to run and we run them afterwards. It's
4378 simpler, especially since all the code was already there. -stef */
4382 /* We are being called before a change.
4383 Scan the overlays to find the functions to call. */
4384 last_overlay_modification_hooks_used
= 0;
4385 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4387 int startpos
, endpos
;
4388 Lisp_Object ostart
, oend
;
4390 XSETMISC (overlay
, tail
);
4392 ostart
= OVERLAY_START (overlay
);
4393 oend
= OVERLAY_END (overlay
);
4394 endpos
= OVERLAY_POSITION (oend
);
4395 if (XFASTINT (start
) > endpos
)
4397 startpos
= OVERLAY_POSITION (ostart
);
4398 if (insertion
&& (XFASTINT (start
) == startpos
4399 || XFASTINT (end
) == startpos
))
4401 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4403 add_overlay_mod_hooklist (prop
, overlay
);
4405 if (insertion
&& (XFASTINT (start
) == endpos
4406 || XFASTINT (end
) == endpos
))
4408 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4410 add_overlay_mod_hooklist (prop
, overlay
);
4412 /* Test for intersecting intervals. This does the right thing
4413 for both insertion and deletion. */
4414 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4416 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4418 add_overlay_mod_hooklist (prop
, overlay
);
4422 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4424 int startpos
, endpos
;
4425 Lisp_Object ostart
, oend
;
4427 XSETMISC (overlay
, tail
);
4429 ostart
= OVERLAY_START (overlay
);
4430 oend
= OVERLAY_END (overlay
);
4431 startpos
= OVERLAY_POSITION (ostart
);
4432 endpos
= OVERLAY_POSITION (oend
);
4433 if (XFASTINT (end
) < startpos
)
4435 if (insertion
&& (XFASTINT (start
) == startpos
4436 || XFASTINT (end
) == startpos
))
4438 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4440 add_overlay_mod_hooklist (prop
, overlay
);
4442 if (insertion
&& (XFASTINT (start
) == endpos
4443 || XFASTINT (end
) == endpos
))
4445 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4447 add_overlay_mod_hooklist (prop
, overlay
);
4449 /* Test for intersecting intervals. This does the right thing
4450 for both insertion and deletion. */
4451 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4453 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4455 add_overlay_mod_hooklist (prop
, overlay
);
4460 GCPRO4 (overlay
, arg1
, arg2
, arg3
);
4462 /* Call the functions recorded in last_overlay_modification_hooks.
4463 First copy the vector contents, in case some of these hooks
4464 do subsequent modification of the buffer. */
4465 int size
= last_overlay_modification_hooks_used
;
4466 Lisp_Object
*copy
= (Lisp_Object
*) alloca (size
* sizeof (Lisp_Object
));
4469 bcopy (XVECTOR (last_overlay_modification_hooks
)->contents
,
4470 copy
, size
* sizeof (Lisp_Object
));
4472 gcpro1
.nvars
= size
;
4474 for (i
= 0; i
< size
;)
4476 Lisp_Object prop
, overlay
;
4478 overlay
= copy
[i
++];
4479 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
4486 call_overlay_mod_hooks (list
, overlay
, after
, arg1
, arg2
, arg3
)
4487 Lisp_Object list
, overlay
;
4489 Lisp_Object arg1
, arg2
, arg3
;
4491 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4493 GCPRO4 (list
, arg1
, arg2
, arg3
);
4495 while (CONSP (list
))
4498 call4 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
);
4500 call5 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
, arg3
);
4506 /* Delete any zero-sized overlays at position POS, if the `evaporate'
4509 evaporate_overlays (pos
)
4512 Lisp_Object overlay
, hit_list
;
4513 struct Lisp_Overlay
*tail
;
4516 if (pos
<= current_buffer
->overlay_center
)
4517 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4520 XSETMISC (overlay
, tail
);
4521 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4524 if (endpos
== pos
&& OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
4525 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4526 hit_list
= Fcons (overlay
, hit_list
);
4529 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4532 XSETMISC (overlay
, tail
);
4533 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4536 if (startpos
== pos
&& OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
4537 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4538 hit_list
= Fcons (overlay
, hit_list
);
4540 for (; CONSP (hit_list
); hit_list
= XCDR (hit_list
))
4541 Fdelete_overlay (XCAR (hit_list
));
4544 /* Somebody has tried to store a value with an unacceptable type
4545 in the slot with offset OFFSET. */
4548 buffer_slot_type_mismatch (newval
, type
)
4552 Lisp_Object predicate
;
4556 case Lisp_Int
: predicate
= Qintegerp
; break;
4557 case Lisp_String
: predicate
= Qstringp
; break;
4558 case Lisp_Symbol
: predicate
= Qsymbolp
; break;
4562 wrong_type_argument (predicate
, newval
);
4566 /***********************************************************************
4567 Allocation with mmap
4568 ***********************************************************************/
4570 #ifdef USE_MMAP_FOR_BUFFERS
4572 #include <sys/types.h>
4573 #include <sys/mman.h>
4576 #ifdef MAP_ANONYMOUS
4577 #define MAP_ANON MAP_ANONYMOUS
4584 #define MAP_FAILED ((void *) -1)
4597 /* Memory is allocated in regions which are mapped using mmap(2).
4598 The current implementation lets the system select mapped
4599 addresses; we're not using MAP_FIXED in general, except when
4600 trying to enlarge regions.
4602 Each mapped region starts with a mmap_region structure, the user
4603 area starts after that structure, aligned to MEM_ALIGN.
4605 +-----------------------+
4606 | struct mmap_info + |
4608 +-----------------------+
4612 +-----------------------+ */
4616 /* User-specified size. */
4617 size_t nbytes_specified
;
4619 /* Number of bytes mapped */
4620 size_t nbytes_mapped
;
4622 /* Pointer to the location holding the address of the memory
4623 allocated with the mmap'd block. The variable actually points
4624 after this structure. */
4627 /* Next and previous in list of all mmap'd regions. */
4628 struct mmap_region
*next
, *prev
;
4631 /* Doubly-linked list of mmap'd regions. */
4633 static struct mmap_region
*mmap_regions
;
4635 /* File descriptor for mmap. If we don't have anonymous mapping,
4636 /dev/zero will be opened on it. */
4640 /* Temporary storage for mmap_set_vars, see there. */
4642 static struct mmap_region
*mmap_regions_1
;
4643 static int mmap_fd_1
;
4645 /* Page size on this system. */
4647 static int mmap_page_size
;
4649 /* 1 means mmap has been intialized. */
4651 static int mmap_initialized_p
;
4653 /* Value is X rounded up to the next multiple of N. */
4655 #define ROUND(X, N) (((X) + (N) - 1) / (N) * (N))
4657 /* Size of mmap_region structure plus padding. */
4659 #define MMAP_REGION_STRUCT_SIZE \
4660 ROUND (sizeof (struct mmap_region), MEM_ALIGN)
4662 /* Given a pointer P to the start of the user-visible part of a mapped
4663 region, return a pointer to the start of the region. */
4665 #define MMAP_REGION(P) \
4666 ((struct mmap_region *) ((char *) (P) - MMAP_REGION_STRUCT_SIZE))
4668 /* Given a pointer P to the start of a mapped region, return a pointer
4669 to the start of the user-visible part of the region. */
4671 #define MMAP_USER_AREA(P) \
4672 ((POINTER_TYPE *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
4674 #define MEM_ALIGN sizeof (double)
4676 /* Predicate returning true if part of the address range [START .. END]
4677 is currently mapped. Used to prevent overwriting an existing
4680 Default is to conservativly assume the address range is occupied by
4681 something else. This can be overridden by system configuration
4682 files if system-specific means to determine this exists. */
4684 #ifndef MMAP_ALLOCATED_P
4685 #define MMAP_ALLOCATED_P(start, end) 1
4688 /* Function prototypes. */
4690 static int mmap_free_1
P_ ((struct mmap_region
*));
4691 static int mmap_enlarge
P_ ((struct mmap_region
*, int));
4692 static struct mmap_region
*mmap_find
P_ ((POINTER_TYPE
*, POINTER_TYPE
*));
4693 static POINTER_TYPE
*mmap_alloc
P_ ((POINTER_TYPE
**, size_t));
4694 static POINTER_TYPE
*mmap_realloc
P_ ((POINTER_TYPE
**, size_t));
4695 static void mmap_free
P_ ((POINTER_TYPE
**ptr
));
4696 static void mmap_init
P_ ((void));
4699 /* Return a region overlapping address range START...END, or null if
4700 none. END is not including, i.e. the last byte in the range
4703 static struct mmap_region
*
4704 mmap_find (start
, end
)
4705 POINTER_TYPE
*start
, *end
;
4707 struct mmap_region
*r
;
4708 char *s
= (char *) start
, *e
= (char *) end
;
4710 for (r
= mmap_regions
; r
; r
= r
->next
)
4712 char *rstart
= (char *) r
;
4713 char *rend
= rstart
+ r
->nbytes_mapped
;
4715 if (/* First byte of range, i.e. START, in this region? */
4716 (s
>= rstart
&& s
< rend
)
4717 /* Last byte of range, i.e. END - 1, in this region? */
4718 || (e
> rstart
&& e
<= rend
)
4719 /* First byte of this region in the range? */
4720 || (rstart
>= s
&& rstart
< e
)
4721 /* Last byte of this region in the range? */
4722 || (rend
> s
&& rend
<= e
))
4730 /* Unmap a region. P is a pointer to the start of the user-araa of
4731 the region. Value is non-zero if successful. */
4735 struct mmap_region
*r
;
4738 r
->next
->prev
= r
->prev
;
4740 r
->prev
->next
= r
->next
;
4742 mmap_regions
= r
->next
;
4744 if (munmap ((POINTER_TYPE
*) r
, r
->nbytes_mapped
) == -1)
4746 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4754 /* Enlarge region R by NPAGES pages. NPAGES < 0 means shrink R.
4755 Value is non-zero if successful. */
4758 mmap_enlarge (r
, npages
)
4759 struct mmap_region
*r
;
4762 char *region_end
= (char *) r
+ r
->nbytes_mapped
;
4768 /* Unmap pages at the end of the region. */
4769 nbytes
= - npages
* mmap_page_size
;
4770 if (munmap (region_end
- nbytes
, nbytes
) == -1)
4771 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4774 r
->nbytes_mapped
-= nbytes
;
4778 else if (npages
> 0)
4780 nbytes
= npages
* mmap_page_size
;
4782 /* Try to map additional pages at the end of the region. We
4783 cannot do this if the address range is already occupied by
4784 something else because mmap deletes any previous mapping.
4785 I'm not sure this is worth doing, let's see. */
4786 if (!MMAP_ALLOCATED_P (region_end
, region_end
+ nbytes
))
4790 p
= mmap (region_end
, nbytes
, PROT_READ
| PROT_WRITE
,
4791 MAP_ANON
| MAP_PRIVATE
| MAP_FIXED
, mmap_fd
, 0);
4792 if (p
== MAP_FAILED
)
4793 ; /* fprintf (stderr, "mmap: %s\n", emacs_strerror (errno)); */
4794 else if (p
!= (POINTER_TYPE
*) region_end
)
4796 /* Kernels are free to choose a different address. In
4797 that case, unmap what we've mapped above; we have
4799 if (munmap (p
, nbytes
) == -1)
4800 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4804 r
->nbytes_mapped
+= nbytes
;
4814 /* Set or reset variables holding references to mapped regions. If
4815 RESTORE_P is zero, set all variables to null. If RESTORE_P is
4816 non-zero, set all variables to the start of the user-areas
4819 This function is called from Fdump_emacs to ensure that the dumped
4820 Emacs doesn't contain references to memory that won't be mapped
4821 when Emacs starts. */
4824 mmap_set_vars (restore_p
)
4827 struct mmap_region
*r
;
4831 mmap_regions
= mmap_regions_1
;
4832 mmap_fd
= mmap_fd_1
;
4833 for (r
= mmap_regions
; r
; r
= r
->next
)
4834 *r
->var
= MMAP_USER_AREA (r
);
4838 for (r
= mmap_regions
; r
; r
= r
->next
)
4840 mmap_regions_1
= mmap_regions
;
4841 mmap_regions
= NULL
;
4842 mmap_fd_1
= mmap_fd
;
4848 /* Allocate a block of storage large enough to hold NBYTES bytes of
4849 data. A pointer to the data is returned in *VAR. VAR is thus the
4850 address of some variable which will use the data area.
4852 The allocation of 0 bytes is valid.
4854 If we can't allocate the necessary memory, set *VAR to null, and
4857 static POINTER_TYPE
*
4858 mmap_alloc (var
, nbytes
)
4867 map
= ROUND (nbytes
+ MMAP_REGION_STRUCT_SIZE
, mmap_page_size
);
4868 p
= mmap (NULL
, map
, PROT_READ
| PROT_WRITE
, MAP_ANON
| MAP_PRIVATE
,
4871 if (p
== MAP_FAILED
)
4873 if (errno
!= ENOMEM
)
4874 fprintf (stderr
, "mmap: %s\n", emacs_strerror (errno
));
4879 struct mmap_region
*r
= (struct mmap_region
*) p
;
4881 r
->nbytes_specified
= nbytes
;
4882 r
->nbytes_mapped
= map
;
4885 r
->next
= mmap_regions
;
4890 p
= MMAP_USER_AREA (p
);
4897 /* Given a pointer at address VAR to data allocated with mmap_alloc,
4898 resize it to size NBYTES. Change *VAR to reflect the new block,
4899 and return this value. If more memory cannot be allocated, then
4900 leave *VAR unchanged, and return null. */
4902 static POINTER_TYPE
*
4903 mmap_realloc (var
, nbytes
)
4907 POINTER_TYPE
*result
;
4912 result
= mmap_alloc (var
, nbytes
);
4913 else if (nbytes
== 0)
4916 result
= mmap_alloc (var
, nbytes
);
4920 struct mmap_region
*r
= MMAP_REGION (*var
);
4921 size_t room
= r
->nbytes_mapped
- MMAP_REGION_STRUCT_SIZE
;
4926 POINTER_TYPE
*old_ptr
= *var
;
4928 /* Try to map additional pages at the end of the region.
4929 If that fails, allocate a new region, copy data
4930 from the old region, then free it. */
4931 if (mmap_enlarge (r
, (ROUND (nbytes
- room
, mmap_page_size
)
4934 r
->nbytes_specified
= nbytes
;
4935 *var
= result
= old_ptr
;
4937 else if (mmap_alloc (var
, nbytes
))
4939 bcopy (old_ptr
, *var
, r
->nbytes_specified
);
4940 mmap_free_1 (MMAP_REGION (old_ptr
));
4942 r
= MMAP_REGION (result
);
4943 r
->nbytes_specified
= nbytes
;
4951 else if (room
- nbytes
>= mmap_page_size
)
4953 /* Shrinking by at least a page. Let's give some
4954 memory back to the system.
4956 The extra parens are to make the division happens first,
4957 on positive values, so we know it will round towards
4959 mmap_enlarge (r
, - ((room
- nbytes
) / mmap_page_size
));
4961 r
->nbytes_specified
= nbytes
;
4965 /* Leave it alone. */
4967 r
->nbytes_specified
= nbytes
;
4975 /* Free a block of relocatable storage whose data is pointed to by
4976 PTR. Store 0 in *PTR to show there's no block allocated. */
4986 mmap_free_1 (MMAP_REGION (*var
));
4992 /* Perform necessary intializations for the use of mmap. */
4998 /* The value of mmap_fd is initially 0 in temacs, and -1
4999 in a dumped Emacs. */
5002 /* No anonymous mmap -- we need the file descriptor. */
5003 mmap_fd
= open ("/dev/zero", O_RDONLY
);
5005 fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno
));
5007 #endif /* MAP_ANON == 0 */
5009 if (mmap_initialized_p
)
5011 mmap_initialized_p
= 1;
5017 mmap_page_size
= getpagesize ();
5020 #endif /* USE_MMAP_FOR_BUFFERS */
5024 /***********************************************************************
5025 Buffer-text Allocation
5026 ***********************************************************************/
5029 extern POINTER_TYPE
*r_alloc
P_ ((POINTER_TYPE
**, size_t));
5030 extern POINTER_TYPE
*r_re_alloc
P_ ((POINTER_TYPE
**, size_t));
5031 extern void r_alloc_free
P_ ((POINTER_TYPE
**ptr
));
5032 #endif /* REL_ALLOC */
5035 /* Allocate NBYTES bytes for buffer B's text buffer. */
5038 alloc_buffer_text (b
, nbytes
)
5045 #if defined USE_MMAP_FOR_BUFFERS
5046 p
= mmap_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
5047 #elif defined REL_ALLOC
5048 p
= r_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
5050 p
= xmalloc (nbytes
);
5059 b
->text
->beg
= (unsigned char *) p
;
5063 /* Enlarge buffer B's text buffer by DELTA bytes. DELTA < 0 means
5067 enlarge_buffer_text (struct buffer
*b
, EMACS_INT delta
)
5070 size_t nbytes
= (BUF_Z_BYTE (b
) - BUF_BEG_BYTE (b
) + BUF_GAP_SIZE (b
) + 1
5073 #if defined USE_MMAP_FOR_BUFFERS
5074 p
= mmap_realloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
5075 #elif defined REL_ALLOC
5076 p
= r_re_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
5078 p
= xrealloc (b
->text
->beg
, nbytes
);
5087 BUF_BEG_ADDR (b
) = (unsigned char *) p
;
5092 /* Free buffer B's text buffer. */
5095 free_buffer_text (b
)
5100 #if defined USE_MMAP_FOR_BUFFERS
5101 mmap_free ((POINTER_TYPE
**) &b
->text
->beg
);
5102 #elif defined REL_ALLOC
5103 r_alloc_free ((POINTER_TYPE
**) &b
->text
->beg
);
5105 xfree (b
->text
->beg
);
5108 BUF_BEG_ADDR (b
) = NULL
;
5114 /***********************************************************************
5116 ***********************************************************************/
5123 bzero (buffer_permanent_local_flags
, sizeof buffer_permanent_local_flags
);
5125 /* Make sure all markable slots in buffer_defaults
5126 are initialized reasonably, so mark_buffer won't choke. */
5127 reset_buffer (&buffer_defaults
);
5128 reset_buffer_local_variables (&buffer_defaults
, 1);
5129 reset_buffer (&buffer_local_symbols
);
5130 reset_buffer_local_variables (&buffer_local_symbols
, 1);
5131 /* Prevent GC from getting confused. */
5132 buffer_defaults
.text
= &buffer_defaults
.own_text
;
5133 buffer_local_symbols
.text
= &buffer_local_symbols
.own_text
;
5134 BUF_INTERVALS (&buffer_defaults
) = 0;
5135 BUF_INTERVALS (&buffer_local_symbols
) = 0;
5136 XSETPVECTYPE (&buffer_defaults
, PVEC_BUFFER
);
5137 XSETBUFFER (Vbuffer_defaults
, &buffer_defaults
);
5138 XSETPVECTYPE (&buffer_local_symbols
, PVEC_BUFFER
);
5139 XSETBUFFER (Vbuffer_local_symbols
, &buffer_local_symbols
);
5141 /* Set up the default values of various buffer slots. */
5142 /* Must do these before making the first buffer! */
5144 /* real setup is done in bindings.el */
5145 buffer_defaults
.mode_line_format
= build_string ("%-");
5146 buffer_defaults
.header_line_format
= Qnil
;
5147 buffer_defaults
.abbrev_mode
= Qnil
;
5148 buffer_defaults
.overwrite_mode
= Qnil
;
5149 buffer_defaults
.case_fold_search
= Qt
;
5150 buffer_defaults
.auto_fill_function
= Qnil
;
5151 buffer_defaults
.selective_display
= Qnil
;
5153 buffer_defaults
.selective_display_ellipses
= Qt
;
5155 buffer_defaults
.abbrev_table
= Qnil
;
5156 buffer_defaults
.display_table
= Qnil
;
5157 buffer_defaults
.undo_list
= Qnil
;
5158 buffer_defaults
.mark_active
= Qnil
;
5159 buffer_defaults
.file_format
= Qnil
;
5160 buffer_defaults
.auto_save_file_format
= Qt
;
5161 buffer_defaults
.overlays_before
= NULL
;
5162 buffer_defaults
.overlays_after
= NULL
;
5163 buffer_defaults
.overlay_center
= BEG
;
5165 XSETFASTINT (buffer_defaults
.tab_width
, 8);
5166 buffer_defaults
.truncate_lines
= Qnil
;
5167 buffer_defaults
.word_wrap
= Qnil
;
5168 buffer_defaults
.ctl_arrow
= Qt
;
5169 buffer_defaults
.direction_reversed
= Qnil
;
5170 buffer_defaults
.cursor_type
= Qt
;
5171 buffer_defaults
.extra_line_spacing
= Qnil
;
5172 buffer_defaults
.cursor_in_non_selected_windows
= Qt
;
5175 buffer_defaults
.buffer_file_type
= Qnil
; /* TEXT */
5177 buffer_defaults
.enable_multibyte_characters
= Qt
;
5178 buffer_defaults
.buffer_file_coding_system
= Qnil
;
5179 XSETFASTINT (buffer_defaults
.fill_column
, 70);
5180 XSETFASTINT (buffer_defaults
.left_margin
, 0);
5181 buffer_defaults
.cache_long_line_scans
= Qnil
;
5182 buffer_defaults
.file_truename
= Qnil
;
5183 XSETFASTINT (buffer_defaults
.display_count
, 0);
5184 XSETFASTINT (buffer_defaults
.left_margin_cols
, 0);
5185 XSETFASTINT (buffer_defaults
.right_margin_cols
, 0);
5186 buffer_defaults
.left_fringe_width
= Qnil
;
5187 buffer_defaults
.right_fringe_width
= Qnil
;
5188 buffer_defaults
.fringes_outside_margins
= Qnil
;
5189 buffer_defaults
.scroll_bar_width
= Qnil
;
5190 buffer_defaults
.vertical_scroll_bar_type
= Qt
;
5191 buffer_defaults
.indicate_empty_lines
= Qnil
;
5192 buffer_defaults
.indicate_buffer_boundaries
= Qnil
;
5193 buffer_defaults
.fringe_indicator_alist
= Qnil
;
5194 buffer_defaults
.fringe_cursor_alist
= Qnil
;
5195 buffer_defaults
.scroll_up_aggressively
= Qnil
;
5196 buffer_defaults
.scroll_down_aggressively
= Qnil
;
5197 buffer_defaults
.display_time
= Qnil
;
5199 /* Assign the local-flags to the slots that have default values.
5200 The local flag is a bit that is used in the buffer
5201 to say that it has its own local value for the slot.
5202 The local flag bits are in the local_var_flags slot of the buffer. */
5204 /* Nothing can work if this isn't true */
5205 if (sizeof (EMACS_INT
) != sizeof (Lisp_Object
)) abort ();
5207 /* 0 means not a lisp var, -1 means always local, else mask */
5208 bzero (&buffer_local_flags
, sizeof buffer_local_flags
);
5209 XSETINT (buffer_local_flags
.filename
, -1);
5210 XSETINT (buffer_local_flags
.directory
, -1);
5211 XSETINT (buffer_local_flags
.backed_up
, -1);
5212 XSETINT (buffer_local_flags
.save_length
, -1);
5213 XSETINT (buffer_local_flags
.auto_save_file_name
, -1);
5214 XSETINT (buffer_local_flags
.read_only
, -1);
5215 XSETINT (buffer_local_flags
.major_mode
, -1);
5216 XSETINT (buffer_local_flags
.mode_name
, -1);
5217 XSETINT (buffer_local_flags
.undo_list
, -1);
5218 XSETINT (buffer_local_flags
.mark_active
, -1);
5219 XSETINT (buffer_local_flags
.point_before_scroll
, -1);
5220 XSETINT (buffer_local_flags
.file_truename
, -1);
5221 XSETINT (buffer_local_flags
.invisibility_spec
, -1);
5222 XSETINT (buffer_local_flags
.file_format
, -1);
5223 XSETINT (buffer_local_flags
.auto_save_file_format
, -1);
5224 XSETINT (buffer_local_flags
.display_count
, -1);
5225 XSETINT (buffer_local_flags
.display_time
, -1);
5226 XSETINT (buffer_local_flags
.enable_multibyte_characters
, -1);
5229 XSETFASTINT (buffer_local_flags
.mode_line_format
, idx
); ++idx
;
5230 XSETFASTINT (buffer_local_flags
.abbrev_mode
, idx
); ++idx
;
5231 XSETFASTINT (buffer_local_flags
.overwrite_mode
, idx
); ++idx
;
5232 XSETFASTINT (buffer_local_flags
.case_fold_search
, idx
); ++idx
;
5233 XSETFASTINT (buffer_local_flags
.auto_fill_function
, idx
); ++idx
;
5234 XSETFASTINT (buffer_local_flags
.selective_display
, idx
); ++idx
;
5236 XSETFASTINT (buffer_local_flags
.selective_display_ellipses
, idx
); ++idx
;
5238 XSETFASTINT (buffer_local_flags
.tab_width
, idx
); ++idx
;
5239 XSETFASTINT (buffer_local_flags
.truncate_lines
, idx
); ++idx
;
5240 XSETFASTINT (buffer_local_flags
.word_wrap
, idx
); ++idx
;
5241 XSETFASTINT (buffer_local_flags
.ctl_arrow
, idx
); ++idx
;
5242 XSETFASTINT (buffer_local_flags
.fill_column
, idx
); ++idx
;
5243 XSETFASTINT (buffer_local_flags
.left_margin
, idx
); ++idx
;
5244 XSETFASTINT (buffer_local_flags
.abbrev_table
, idx
); ++idx
;
5245 XSETFASTINT (buffer_local_flags
.display_table
, idx
); ++idx
;
5247 XSETFASTINT (buffer_local_flags
.buffer_file_type
, idx
);
5248 /* Make this one a permanent local. */
5249 buffer_permanent_local_flags
[idx
++] = 1;
5251 XSETFASTINT (buffer_local_flags
.syntax_table
, idx
); ++idx
;
5252 XSETFASTINT (buffer_local_flags
.cache_long_line_scans
, idx
); ++idx
;
5253 XSETFASTINT (buffer_local_flags
.category_table
, idx
); ++idx
;
5254 XSETFASTINT (buffer_local_flags
.direction_reversed
, idx
); ++idx
;
5255 XSETFASTINT (buffer_local_flags
.buffer_file_coding_system
, idx
);
5256 /* Make this one a permanent local. */
5257 buffer_permanent_local_flags
[idx
++] = 1;
5258 XSETFASTINT (buffer_local_flags
.left_margin_cols
, idx
); ++idx
;
5259 XSETFASTINT (buffer_local_flags
.right_margin_cols
, idx
); ++idx
;
5260 XSETFASTINT (buffer_local_flags
.left_fringe_width
, idx
); ++idx
;
5261 XSETFASTINT (buffer_local_flags
.right_fringe_width
, idx
); ++idx
;
5262 XSETFASTINT (buffer_local_flags
.fringes_outside_margins
, idx
); ++idx
;
5263 XSETFASTINT (buffer_local_flags
.scroll_bar_width
, idx
); ++idx
;
5264 XSETFASTINT (buffer_local_flags
.vertical_scroll_bar_type
, idx
); ++idx
;
5265 XSETFASTINT (buffer_local_flags
.indicate_empty_lines
, idx
); ++idx
;
5266 XSETFASTINT (buffer_local_flags
.indicate_buffer_boundaries
, idx
); ++idx
;
5267 XSETFASTINT (buffer_local_flags
.fringe_indicator_alist
, idx
); ++idx
;
5268 XSETFASTINT (buffer_local_flags
.fringe_cursor_alist
, idx
); ++idx
;
5269 XSETFASTINT (buffer_local_flags
.scroll_up_aggressively
, idx
); ++idx
;
5270 XSETFASTINT (buffer_local_flags
.scroll_down_aggressively
, idx
); ++idx
;
5271 XSETFASTINT (buffer_local_flags
.header_line_format
, idx
); ++idx
;
5272 XSETFASTINT (buffer_local_flags
.cursor_type
, idx
); ++idx
;
5273 XSETFASTINT (buffer_local_flags
.extra_line_spacing
, idx
); ++idx
;
5274 XSETFASTINT (buffer_local_flags
.cursor_in_non_selected_windows
, idx
); ++idx
;
5276 /* Need more room? */
5277 if (idx
>= MAX_PER_BUFFER_VARS
)
5279 last_per_buffer_idx
= idx
;
5281 Vbuffer_alist
= Qnil
;
5285 QSFundamental
= build_string ("Fundamental");
5287 Qfundamental_mode
= intern ("fundamental-mode");
5288 buffer_defaults
.major_mode
= Qfundamental_mode
;
5290 Qmode_class
= intern ("mode-class");
5292 Qprotected_field
= intern ("protected-field");
5294 Qpermanent_local
= intern ("permanent-local");
5296 Qkill_buffer_hook
= intern ("kill-buffer-hook");
5297 Fput (Qkill_buffer_hook
, Qpermanent_local
, Qt
);
5299 Qucs_set_table_for_input
= intern ("ucs-set-table-for-input");
5301 Vprin1_to_string_buffer
= Fget_buffer_create (build_string (" prin1"));
5303 /* super-magic invisible buffer */
5304 Vbuffer_alist
= Qnil
;
5306 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
5308 inhibit_modification_hooks
= 0;
5318 #ifdef USE_MMAP_FOR_BUFFERS
5320 /* When using the ralloc implementation based on mmap(2), buffer
5321 text pointers will have been set to null in the dumped Emacs.
5325 for (b
= all_buffers
; b
; b
= b
->next
)
5326 if (b
->text
->beg
== NULL
)
5327 enlarge_buffer_text (b
, 0);
5329 #endif /* USE_MMAP_FOR_BUFFERS */
5331 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
5332 if (NILP (buffer_defaults
.enable_multibyte_characters
))
5333 Fset_buffer_multibyte (Qnil
);
5335 pwd
= get_current_dir_name ();
5338 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5340 /* Maybe this should really use some standard subroutine
5341 whose definition is filename syntax dependent. */
5343 if (!(IS_DIRECTORY_SEP (pwd
[len
- 1])))
5345 /* Grow buffer to add directory separator and '\0'. */
5346 pwd
= (char *) realloc (pwd
, len
+ 2);
5348 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5349 pwd
[len
] = DIRECTORY_SEP
;
5350 pwd
[len
+ 1] = '\0';
5353 current_buffer
->directory
= make_unibyte_string (pwd
, strlen (pwd
));
5354 if (! NILP (buffer_defaults
.enable_multibyte_characters
))
5355 /* At this moment, we still don't know how to decode the
5356 directory name. So, we keep the bytes in multibyte form so
5357 that ENCODE_FILE correctly gets the original bytes. */
5358 current_buffer
->directory
5359 = string_to_multibyte (current_buffer
->directory
);
5361 /* Add /: to the front of the name
5362 if it would otherwise be treated as magic. */
5363 temp
= Ffind_file_name_handler (current_buffer
->directory
, Qt
);
5365 /* If the default dir is just /, TEMP is non-nil
5366 because of the ange-ftp completion handler.
5367 However, it is not necessary to turn / into /:/.
5368 So avoid doing that. */
5369 && strcmp ("/", SDATA (current_buffer
->directory
)))
5370 current_buffer
->directory
5371 = concat2 (build_string ("/:"), current_buffer
->directory
);
5373 temp
= get_minibuffer (0);
5374 XBUFFER (temp
)->directory
= current_buffer
->directory
;
5379 /* Similar to defvar_lisp but define a variable whose value is the Lisp
5380 Object stored in the current buffer. address is the address of the slot
5381 in the buffer that is current now. */
5383 /* TYPE is nil for a general Lisp variable.
5384 An integer specifies a type; then only LIsp values
5385 with that type code are allowed (except that nil is allowed too).
5386 LNAME is the LIsp-level variable name.
5387 VNAME is the name of the buffer slot.
5388 DOC is a dummy where you write the doc string as a comment. */
5389 #define DEFVAR_PER_BUFFER(lname, vname, type, doc) \
5390 defvar_per_buffer (lname, vname, type, 0)
5393 defvar_per_buffer (namestring
, address
, type
, doc
)
5395 Lisp_Object
*address
;
5399 Lisp_Object sym
, val
;
5402 sym
= intern (namestring
);
5403 val
= allocate_misc ();
5404 offset
= (char *)address
- (char *)current_buffer
;
5406 XMISCTYPE (val
) = Lisp_Misc_Buffer_Objfwd
;
5407 XBUFFER_OBJFWD (val
)->offset
= offset
;
5408 XBUFFER_OBJFWD (val
)->slottype
= type
;
5409 SET_SYMBOL_VALUE (sym
, val
);
5410 PER_BUFFER_SYMBOL (offset
) = sym
;
5412 if (PER_BUFFER_IDX (offset
) == 0)
5413 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
5414 slot of buffer_local_flags */
5419 /* initialize the buffer routines */
5423 staticpro (&last_overlay_modification_hooks
);
5424 last_overlay_modification_hooks
5425 = Fmake_vector (make_number (10), Qnil
);
5427 staticpro (&Vbuffer_defaults
);
5428 staticpro (&Vbuffer_local_symbols
);
5429 staticpro (&Qfundamental_mode
);
5430 staticpro (&Qmode_class
);
5431 staticpro (&QSFundamental
);
5432 staticpro (&Vbuffer_alist
);
5433 staticpro (&Qprotected_field
);
5434 staticpro (&Qpermanent_local
);
5435 Qpermanent_local_hook
= intern ("permanent-local-hook");
5436 staticpro (&Qpermanent_local_hook
);
5437 staticpro (&Qkill_buffer_hook
);
5438 Qoverlayp
= intern ("overlayp");
5439 staticpro (&Qoverlayp
);
5440 Qevaporate
= intern ("evaporate");
5441 staticpro (&Qevaporate
);
5442 Qmodification_hooks
= intern ("modification-hooks");
5443 staticpro (&Qmodification_hooks
);
5444 Qinsert_in_front_hooks
= intern ("insert-in-front-hooks");
5445 staticpro (&Qinsert_in_front_hooks
);
5446 Qinsert_behind_hooks
= intern ("insert-behind-hooks");
5447 staticpro (&Qinsert_behind_hooks
);
5448 Qget_file_buffer
= intern ("get-file-buffer");
5449 staticpro (&Qget_file_buffer
);
5450 Qpriority
= intern ("priority");
5451 staticpro (&Qpriority
);
5452 Qwindow
= intern ("window");
5453 staticpro (&Qwindow
);
5454 Qbefore_string
= intern ("before-string");
5455 staticpro (&Qbefore_string
);
5456 Qafter_string
= intern ("after-string");
5457 staticpro (&Qafter_string
);
5458 Qfirst_change_hook
= intern ("first-change-hook");
5459 staticpro (&Qfirst_change_hook
);
5460 Qbefore_change_functions
= intern ("before-change-functions");
5461 staticpro (&Qbefore_change_functions
);
5462 Qafter_change_functions
= intern ("after-change-functions");
5463 staticpro (&Qafter_change_functions
);
5464 /* The next one is initialized in init_buffer_once. */
5465 staticpro (&Qucs_set_table_for_input
);
5467 Qkill_buffer_query_functions
= intern ("kill-buffer-query-functions");
5468 staticpro (&Qkill_buffer_query_functions
);
5470 Fput (Qprotected_field
, Qerror_conditions
,
5471 Fcons (Qprotected_field
, Fcons (Qerror
, Qnil
)));
5472 Fput (Qprotected_field
, Qerror_message
,
5473 build_string ("Attempt to modify a protected field"));
5475 /* All these use DEFVAR_LISP_NOPRO because the slots in
5476 buffer_defaults will all be marked via Vbuffer_defaults. */
5478 DEFVAR_LISP_NOPRO ("default-mode-line-format",
5479 &buffer_defaults
.mode_line_format
,
5480 doc
: /* Default value of `mode-line-format' for buffers that don't override it.
5481 This is the same as (default-value 'mode-line-format). */);
5483 DEFVAR_LISP_NOPRO ("default-header-line-format",
5484 &buffer_defaults
.header_line_format
,
5485 doc
: /* Default value of `header-line-format' for buffers that don't override it.
5486 This is the same as (default-value 'header-line-format). */);
5488 DEFVAR_LISP_NOPRO ("default-cursor-type", &buffer_defaults
.cursor_type
,
5489 doc
: /* Default value of `cursor-type' for buffers that don't override it.
5490 This is the same as (default-value 'cursor-type). */);
5492 DEFVAR_LISP_NOPRO ("default-line-spacing",
5493 &buffer_defaults
.extra_line_spacing
,
5494 doc
: /* Default value of `line-spacing' for buffers that don't override it.
5495 This is the same as (default-value 'line-spacing). */);
5497 DEFVAR_LISP_NOPRO ("default-cursor-in-non-selected-windows",
5498 &buffer_defaults
.cursor_in_non_selected_windows
,
5499 doc
: /* Default value of `cursor-in-non-selected-windows'.
5500 This is the same as (default-value 'cursor-in-non-selected-windows). */);
5502 DEFVAR_LISP_NOPRO ("default-abbrev-mode",
5503 &buffer_defaults
.abbrev_mode
,
5504 doc
: /* Default value of `abbrev-mode' for buffers that do not override it.
5505 This is the same as (default-value 'abbrev-mode). */);
5507 DEFVAR_LISP_NOPRO ("default-ctl-arrow",
5508 &buffer_defaults
.ctl_arrow
,
5509 doc
: /* Default value of `ctl-arrow' for buffers that do not override it.
5510 This is the same as (default-value 'ctl-arrow). */);
5512 DEFVAR_LISP_NOPRO ("default-direction-reversed",
5513 &buffer_defaults
.direction_reversed
,
5514 doc
: /* Default value of `direction-reversed' for buffers that do not override it.
5515 This is the same as (default-value 'direction-reversed). */);
5517 DEFVAR_LISP_NOPRO ("default-enable-multibyte-characters",
5518 &buffer_defaults
.enable_multibyte_characters
,
5519 doc
: /* *Default value of `enable-multibyte-characters' for buffers not overriding it.
5520 This is the same as (default-value 'enable-multibyte-characters). */);
5522 DEFVAR_LISP_NOPRO ("default-buffer-file-coding-system",
5523 &buffer_defaults
.buffer_file_coding_system
,
5524 doc
: /* Default value of `buffer-file-coding-system' for buffers not overriding it.
5525 This is the same as (default-value 'buffer-file-coding-system). */);
5527 DEFVAR_LISP_NOPRO ("default-truncate-lines",
5528 &buffer_defaults
.truncate_lines
,
5529 doc
: /* Default value of `truncate-lines' for buffers that do not override it.
5530 This is the same as (default-value 'truncate-lines). */);
5532 DEFVAR_LISP_NOPRO ("default-fill-column",
5533 &buffer_defaults
.fill_column
,
5534 doc
: /* Default value of `fill-column' for buffers that do not override it.
5535 This is the same as (default-value 'fill-column). */);
5537 DEFVAR_LISP_NOPRO ("default-left-margin",
5538 &buffer_defaults
.left_margin
,
5539 doc
: /* Default value of `left-margin' for buffers that do not override it.
5540 This is the same as (default-value 'left-margin). */);
5542 DEFVAR_LISP_NOPRO ("default-tab-width",
5543 &buffer_defaults
.tab_width
,
5544 doc
: /* Default value of `tab-width' for buffers that do not override it.
5545 This is the same as (default-value 'tab-width). */);
5547 DEFVAR_LISP_NOPRO ("default-case-fold-search",
5548 &buffer_defaults
.case_fold_search
,
5549 doc
: /* Default value of `case-fold-search' for buffers that don't override it.
5550 This is the same as (default-value 'case-fold-search). */);
5553 DEFVAR_LISP_NOPRO ("default-buffer-file-type",
5554 &buffer_defaults
.buffer_file_type
,
5555 doc
: /* Default file type for buffers that do not override it.
5556 This is the same as (default-value 'buffer-file-type).
5557 The file type is nil for text, t for binary. */);
5560 DEFVAR_LISP_NOPRO ("default-left-margin-width",
5561 &buffer_defaults
.left_margin_cols
,
5562 doc
: /* Default value of `left-margin-width' for buffers that don't override it.
5563 This is the same as (default-value 'left-margin-width). */);
5565 DEFVAR_LISP_NOPRO ("default-right-margin-width",
5566 &buffer_defaults
.right_margin_cols
,
5567 doc
: /* Default value of `right-margin-width' for buffers that don't override it.
5568 This is the same as (default-value 'right-margin-width). */);
5570 DEFVAR_LISP_NOPRO ("default-left-fringe-width",
5571 &buffer_defaults
.left_fringe_width
,
5572 doc
: /* Default value of `left-fringe-width' for buffers that don't override it.
5573 This is the same as (default-value 'left-fringe-width). */);
5575 DEFVAR_LISP_NOPRO ("default-right-fringe-width",
5576 &buffer_defaults
.right_fringe_width
,
5577 doc
: /* Default value of `right-fringe-width' for buffers that don't override it.
5578 This is the same as (default-value 'right-fringe-width). */);
5580 DEFVAR_LISP_NOPRO ("default-fringes-outside-margins",
5581 &buffer_defaults
.fringes_outside_margins
,
5582 doc
: /* Default value of `fringes-outside-margins' for buffers that don't override it.
5583 This is the same as (default-value 'fringes-outside-margins). */);
5585 DEFVAR_LISP_NOPRO ("default-scroll-bar-width",
5586 &buffer_defaults
.scroll_bar_width
,
5587 doc
: /* Default value of `scroll-bar-width' for buffers that don't override it.
5588 This is the same as (default-value 'scroll-bar-width). */);
5590 DEFVAR_LISP_NOPRO ("default-vertical-scroll-bar",
5591 &buffer_defaults
.vertical_scroll_bar_type
,
5592 doc
: /* Default value of `vertical-scroll-bar' for buffers that don't override it.
5593 This is the same as (default-value 'vertical-scroll-bar). */);
5595 DEFVAR_LISP_NOPRO ("default-indicate-empty-lines",
5596 &buffer_defaults
.indicate_empty_lines
,
5597 doc
: /* Default value of `indicate-empty-lines' for buffers that don't override it.
5598 This is the same as (default-value 'indicate-empty-lines). */);
5600 DEFVAR_LISP_NOPRO ("default-indicate-buffer-boundaries",
5601 &buffer_defaults
.indicate_buffer_boundaries
,
5602 doc
: /* Default value of `indicate-buffer-boundaries' for buffers that don't override it.
5603 This is the same as (default-value 'indicate-buffer-boundaries). */);
5605 DEFVAR_LISP_NOPRO ("default-fringe-indicator-alist",
5606 &buffer_defaults
.fringe_indicator_alist
,
5607 doc
: /* Default value of `fringe-indicator-alist' for buffers that don't override it.
5608 This is the same as (default-value 'fringe-indicator-alist'). */);
5610 DEFVAR_LISP_NOPRO ("default-fringe-cursor-alist",
5611 &buffer_defaults
.fringe_cursor_alist
,
5612 doc
: /* Default value of `fringe-cursor-alist' for buffers that don't override it.
5613 This is the same as (default-value 'fringe-cursor-alist'). */);
5615 DEFVAR_LISP_NOPRO ("default-scroll-up-aggressively",
5616 &buffer_defaults
.scroll_up_aggressively
,
5617 doc
: /* Default value of `scroll-up-aggressively'.
5618 This value applies in buffers that don't have their own local values.
5619 This is the same as (default-value 'scroll-up-aggressively). */);
5621 DEFVAR_LISP_NOPRO ("default-scroll-down-aggressively",
5622 &buffer_defaults
.scroll_down_aggressively
,
5623 doc
: /* Default value of `scroll-down-aggressively'.
5624 This value applies in buffers that don't have their own local values.
5625 This is the same as (default-value 'scroll-down-aggressively). */);
5627 DEFVAR_PER_BUFFER ("header-line-format",
5628 ¤t_buffer
->header_line_format
,
5630 doc
: /* Analogous to `mode-line-format', but controls the header line.
5631 The header line appears, optionally, at the top of a window;
5632 the mode line appears at the bottom. */);
5634 DEFVAR_PER_BUFFER ("mode-line-format", ¤t_buffer
->mode_line_format
,
5636 doc
: /* Template for displaying mode line for current buffer.
5637 Each buffer has its own value of this variable.
5638 Value may be nil, a string, a symbol or a list or cons cell.
5639 A value of nil means don't display a mode line.
5640 For a symbol, its value is used (but it is ignored if t or nil).
5641 A string appearing directly as the value of a symbol is processed verbatim
5642 in that the %-constructs below are not recognized.
5643 Note that unless the symbol is marked as a `risky-local-variable', all
5644 properties in any strings, as well as all :eval and :propertize forms
5645 in the value of that symbol will be ignored.
5646 For a list of the form `(:eval FORM)', FORM is evaluated and the result
5647 is used as a mode line element. Be careful--FORM should not load any files,
5648 because that can cause an infinite recursion.
5649 For a list of the form `(:propertize ELT PROPS...)', ELT is displayed
5650 with the specified properties PROPS applied.
5651 For a list whose car is a symbol, the symbol's value is taken,
5652 and if that is non-nil, the cadr of the list is processed recursively.
5653 Otherwise, the caddr of the list (if there is one) is processed.
5654 For a list whose car is a string or list, each element is processed
5655 recursively and the results are effectively concatenated.
5656 For a list whose car is an integer, the cdr of the list is processed
5657 and padded (if the number is positive) or truncated (if negative)
5658 to the width specified by that number.
5659 A string is printed verbatim in the mode line except for %-constructs:
5660 (%-constructs are allowed when the string is the entire mode-line-format
5661 or when it is found in a cons-cell or a list)
5662 %b -- print buffer name. %f -- print visited file name.
5663 %F -- print frame name.
5664 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
5665 %& is like %*, but ignore read-only-ness.
5666 % means buffer is read-only and * means it is modified.
5667 For a modified read-only buffer, %* gives % and %+ gives *.
5668 %s -- print process status. %l -- print the current line number.
5669 %c -- print the current column number (this makes editing slower).
5670 To make the column number update correctly in all cases,
5671 `column-number-mode' must be non-nil.
5672 %i -- print the size of the buffer.
5673 %I -- like %i, but use k, M, G, etc., to abbreviate.
5674 %p -- print percent of buffer above top of window, or Top, Bot or All.
5675 %P -- print percent of buffer above bottom of window, perhaps plus Top,
5676 or print Bottom or All.
5677 %n -- print Narrow if appropriate.
5678 %t -- visited file is text or binary (if OS supports this distinction).
5679 %z -- print mnemonics of keyboard, terminal, and buffer coding systems.
5680 %Z -- like %z, but including the end-of-line format.
5681 %e -- print error message about full memory.
5682 %@ -- print @ or hyphen. @ means that default-directory is on a
5684 %[ -- print one [ for each recursive editing level. %] similar.
5685 %% -- print %. %- -- print infinitely many dashes.
5686 Decimal digits after the % specify field width to which to pad. */);
5688 DEFVAR_LISP_NOPRO ("default-major-mode", &buffer_defaults
.major_mode
,
5689 doc
: /* *Major mode for new buffers. Defaults to `fundamental-mode'.
5690 A value of nil means use current buffer's major mode,
5691 provided it is not marked as "special".
5693 When a mode is used by default, `find-file' switches to it
5694 before it reads the contents into the buffer and before
5695 it finishes setting up the buffer. Thus, the mode and
5696 its hooks should not expect certain variables such as
5697 `buffer-read-only' and `buffer-file-coding-system' to be set up. */);
5699 DEFVAR_PER_BUFFER ("major-mode", ¤t_buffer
->major_mode
,
5700 make_number (Lisp_Symbol
),
5701 doc
: /* Symbol for current buffer's major mode. */);
5703 DEFVAR_PER_BUFFER ("mode-name", ¤t_buffer
->mode_name
,
5705 doc
: /* Pretty name of current buffer's major mode.
5706 Usually a string, but can use any of the constructs for `mode-line-format',
5708 Format with `format-mode-line' to produce a string value. */);
5710 DEFVAR_PER_BUFFER ("local-abbrev-table", ¤t_buffer
->abbrev_table
, Qnil
,
5711 doc
: /* Local (mode-specific) abbrev table of current buffer. */);
5713 DEFVAR_PER_BUFFER ("abbrev-mode", ¤t_buffer
->abbrev_mode
, Qnil
,
5714 doc
: /* Non-nil turns on automatic expansion of abbrevs as they are inserted. */);
5716 DEFVAR_PER_BUFFER ("case-fold-search", ¤t_buffer
->case_fold_search
,
5718 doc
: /* *Non-nil if searches and matches should ignore case. */);
5720 DEFVAR_PER_BUFFER ("fill-column", ¤t_buffer
->fill_column
,
5721 make_number (Lisp_Int
),
5722 doc
: /* *Column beyond which automatic line-wrapping should happen.
5723 Interactively, you can set the buffer local value using \\[set-fill-column]. */);
5725 DEFVAR_PER_BUFFER ("left-margin", ¤t_buffer
->left_margin
,
5726 make_number (Lisp_Int
),
5727 doc
: /* *Column for the default `indent-line-function' to indent to.
5728 Linefeed indents to this column in Fundamental mode. */);
5730 DEFVAR_PER_BUFFER ("tab-width", ¤t_buffer
->tab_width
,
5731 make_number (Lisp_Int
),
5732 doc
: /* *Distance between tab stops (for display of tab characters), in columns. */);
5734 DEFVAR_PER_BUFFER ("ctl-arrow", ¤t_buffer
->ctl_arrow
, Qnil
,
5735 doc
: /* *Non-nil means display control chars with uparrow.
5736 A value of nil means use backslash and octal digits.
5737 This variable does not apply to characters whose display is specified
5738 in the current display table (if there is one). */);
5740 DEFVAR_PER_BUFFER ("enable-multibyte-characters",
5741 ¤t_buffer
->enable_multibyte_characters
,
5743 doc
: /* Non-nil means the buffer contents are regarded as multi-byte characters.
5744 Otherwise they are regarded as unibyte. This affects the display,
5745 file I/O and the behavior of various editing commands.
5747 This variable is buffer-local but you cannot set it directly;
5748 use the function `set-buffer-multibyte' to change a buffer's representation.
5749 Changing its default value with `setq-default' is supported.
5750 See also variable `default-enable-multibyte-characters' and Info node
5751 `(elisp)Text Representations'. */);
5752 XSYMBOL (intern ("enable-multibyte-characters"))->constant
= 1;
5754 DEFVAR_PER_BUFFER ("buffer-file-coding-system",
5755 ¤t_buffer
->buffer_file_coding_system
, Qnil
,
5756 doc
: /* Coding system to be used for encoding the buffer contents on saving.
5757 This variable applies to saving the buffer, and also to `write-region'
5758 and other functions that use `write-region'.
5759 It does not apply to sending output to subprocesses, however.
5761 If this is nil, the buffer is saved without any code conversion
5762 unless some coding system is specified in `file-coding-system-alist'
5763 for the buffer file.
5765 If the text to be saved cannot be encoded as specified by this variable,
5766 an alternative encoding is selected by `select-safe-coding-system', which see.
5768 The variable `coding-system-for-write', if non-nil, overrides this variable.
5770 This variable is never applied to a way of decoding a file while reading it. */);
5772 DEFVAR_PER_BUFFER ("direction-reversed", ¤t_buffer
->direction_reversed
,
5774 doc
: /* *Non-nil means lines in the buffer are displayed right to left. */);
5776 DEFVAR_PER_BUFFER ("truncate-lines", ¤t_buffer
->truncate_lines
, Qnil
,
5777 doc
: /* *Non-nil means do not display continuation lines.
5778 Instead, give each line of text just one screen line.
5780 Note that this is overridden by the variable
5781 `truncate-partial-width-windows' if that variable is non-nil
5782 and this buffer is not full-frame width. */);
5784 DEFVAR_PER_BUFFER ("word-wrap", ¤t_buffer
->word_wrap
, Qnil
,
5785 doc
: /* *Non-nil means to use word-wrapping for continuation lines.
5786 When word-wrapping is on, continuation lines are wrapped at the space
5787 or tab character nearest to the right window edge.
5788 If nil, continuation lines are wrapped at the right screen edge.
5790 This variable has no effect if long lines are truncated (see
5791 `truncate-lines' and `truncate-partial-width-windows'). If you use
5792 word-wrapping, you might want to reduce the value of
5793 `truncate-partial-width-windows', since wrapping can make text readable
5794 in narrower windows. */);
5797 DEFVAR_PER_BUFFER ("buffer-file-type", ¤t_buffer
->buffer_file_type
,
5799 doc
: /* Non-nil if the visited file is a binary file.
5800 This variable is meaningful on MS-DOG and Windows NT.
5801 On those systems, it is automatically local in every buffer.
5802 On other systems, this variable is normally always nil. */);
5805 DEFVAR_PER_BUFFER ("default-directory", ¤t_buffer
->directory
,
5806 make_number (Lisp_String
),
5807 doc
: /* Name of default directory of current buffer. Should end with slash.
5808 To interactively change the default directory, use command `cd'. */);
5810 DEFVAR_PER_BUFFER ("auto-fill-function", ¤t_buffer
->auto_fill_function
,
5812 doc
: /* Function called (if non-nil) to perform auto-fill.
5813 It is called after self-inserting any character specified in
5814 the `auto-fill-chars' table.
5815 NOTE: This variable is not a hook;
5816 its value may not be a list of functions. */);
5818 DEFVAR_PER_BUFFER ("buffer-file-name", ¤t_buffer
->filename
,
5819 make_number (Lisp_String
),
5820 doc
: /* Name of file visited in current buffer, or nil if not visiting a file. */);
5822 DEFVAR_PER_BUFFER ("buffer-file-truename", ¤t_buffer
->file_truename
,
5823 make_number (Lisp_String
),
5824 doc
: /* Abbreviated truename of file visited in current buffer, or nil if none.
5825 The truename of a file is calculated by `file-truename'
5826 and then abbreviated with `abbreviate-file-name'. */);
5828 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
5829 ¤t_buffer
->auto_save_file_name
,
5830 make_number (Lisp_String
),
5831 doc
: /* Name of file for auto-saving current buffer.
5832 If it is nil, that means don't auto-save this buffer. */);
5834 DEFVAR_PER_BUFFER ("buffer-read-only", ¤t_buffer
->read_only
, Qnil
,
5835 doc
: /* Non-nil if this buffer is read-only. */);
5837 DEFVAR_PER_BUFFER ("buffer-backed-up", ¤t_buffer
->backed_up
, Qnil
,
5838 doc
: /* Non-nil if this buffer's file has been backed up.
5839 Backing up is done before the first time the file is saved. */);
5841 DEFVAR_PER_BUFFER ("buffer-saved-size", ¤t_buffer
->save_length
,
5842 make_number (Lisp_Int
),
5843 doc
: /* Length of current buffer when last read in, saved or auto-saved.
5846 DEFVAR_PER_BUFFER ("selective-display", ¤t_buffer
->selective_display
,
5848 doc
: /* Non-nil enables selective display.
5849 An integer N as value means display only lines
5850 that start with less than N columns of space.
5851 A value of t means that the character ^M makes itself and
5852 all the rest of the line invisible; also, when saving the buffer
5853 in a file, save the ^M as a newline. */);
5856 DEFVAR_PER_BUFFER ("selective-display-ellipses",
5857 ¤t_buffer
->selective_display_ellipses
,
5859 doc
: /* Non-nil means display ... on previous line when a line is invisible. */);
5862 DEFVAR_PER_BUFFER ("overwrite-mode", ¤t_buffer
->overwrite_mode
, Qnil
,
5863 doc
: /* Non-nil if self-insertion should replace existing text.
5864 The value should be one of `overwrite-mode-textual',
5865 `overwrite-mode-binary', or nil.
5866 If it is `overwrite-mode-textual', self-insertion still
5867 inserts at the end of a line, and inserts when point is before a tab,
5868 until the tab is filled in.
5869 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too. */);
5871 DEFVAR_PER_BUFFER ("buffer-display-table", ¤t_buffer
->display_table
,
5873 doc
: /* Display table that controls display of the contents of current buffer.
5875 If this variable is nil, the value of `standard-display-table' is used.
5876 Each window can have its own, overriding display table, see
5877 `set-window-display-table' and `window-display-table'.
5879 The display table is a char-table created with `make-display-table'.
5880 A char-table is an array indexed by character codes. Normal array
5881 primitives `aref' and `aset' can be used to access elements of a char-table.
5883 Each of the char-table elements control how to display the corresponding
5884 text character: the element at index C in the table says how to display
5885 the character whose code is C. Each element should be a vector of
5886 characters or nil. The value nil means display the character in the
5887 default fashion; otherwise, the characters from the vector are delivered
5888 to the screen instead of the original character.
5890 For example, (aset buffer-display-table ?X [?Y]) tells Emacs
5891 to display a capital Y instead of each X character.
5893 In addition, a char-table has six extra slots to control the display of:
5895 the end of a truncated screen line (extra-slot 0, a single character);
5896 the end of a continued line (extra-slot 1, a single character);
5897 the escape character used to display character codes in octal
5898 (extra-slot 2, a single character);
5899 the character used as an arrow for control characters (extra-slot 3,
5900 a single character);
5901 the decoration indicating the presence of invisible lines (extra-slot 4,
5902 a vector of characters);
5903 the character used to draw the border between side-by-side windows
5904 (extra-slot 5, a single character).
5906 See also the functions `display-table-slot' and `set-display-table-slot'. */);
5908 DEFVAR_PER_BUFFER ("left-margin-width", ¤t_buffer
->left_margin_cols
,
5910 doc
: /* *Width of left marginal area for display of a buffer.
5911 A value of nil means no marginal area. */);
5913 DEFVAR_PER_BUFFER ("right-margin-width", ¤t_buffer
->right_margin_cols
,
5915 doc
: /* *Width of right marginal area for display of a buffer.
5916 A value of nil means no marginal area. */);
5918 DEFVAR_PER_BUFFER ("left-fringe-width", ¤t_buffer
->left_fringe_width
,
5920 doc
: /* *Width of this buffer's left fringe (in pixels).
5921 A value of 0 means no left fringe is shown in this buffer's window.
5922 A value of nil means to use the left fringe width from the window's frame. */);
5924 DEFVAR_PER_BUFFER ("right-fringe-width", ¤t_buffer
->right_fringe_width
,
5926 doc
: /* *Width of this buffer's right fringe (in pixels).
5927 A value of 0 means no right fringe is shown in this buffer's window.
5928 A value of nil means to use the right fringe width from the window's frame. */);
5930 DEFVAR_PER_BUFFER ("fringes-outside-margins", ¤t_buffer
->fringes_outside_margins
,
5932 doc
: /* *Non-nil means to display fringes outside display margins.
5933 A value of nil means to display fringes between margins and buffer text. */);
5935 DEFVAR_PER_BUFFER ("scroll-bar-width", ¤t_buffer
->scroll_bar_width
,
5937 doc
: /* *Width of this buffer's scroll bars in pixels.
5938 A value of nil means to use the scroll bar width from the window's frame. */);
5940 DEFVAR_PER_BUFFER ("vertical-scroll-bar", ¤t_buffer
->vertical_scroll_bar_type
,
5942 doc
: /* *Position of this buffer's vertical scroll bar.
5943 The value takes effect whenever you tell a window to display this buffer;
5944 for instance, with `set-window-buffer' or when `display-buffer' displays it.
5946 A value of `left' or `right' means put the vertical scroll bar at that side
5947 of the window; a value of nil means don't show any vertical scroll bars.
5948 A value of t (the default) means do whatever the window's frame specifies. */);
5950 DEFVAR_PER_BUFFER ("indicate-empty-lines",
5951 ¤t_buffer
->indicate_empty_lines
, Qnil
,
5952 doc
: /* *Visually indicate empty lines after the buffer end.
5953 If non-nil, a bitmap is displayed in the left fringe of a window on
5954 window-systems. */);
5956 DEFVAR_PER_BUFFER ("indicate-buffer-boundaries",
5957 ¤t_buffer
->indicate_buffer_boundaries
, Qnil
,
5958 doc
: /* *Visually indicate buffer boundaries and scrolling.
5959 If non-nil, the first and last line of the buffer are marked in the fringe
5960 of a window on window-systems with angle bitmaps, or if the window can be
5961 scrolled, the top and bottom line of the window are marked with up and down
5964 If value is a symbol `left' or `right', both angle and arrow bitmaps
5965 are displayed in the left or right fringe, resp. Any other value
5966 that doesn't look like an alist means display the angle bitmaps in
5967 the left fringe but no arrows.
5969 You can exercise more precise control by using an alist as the
5970 value. Each alist element (INDICATOR . POSITION) specifies
5971 where to show one of the indicators. INDICATOR is one of `top',
5972 `bottom', `up', `down', or t, which specifies the default position,
5973 and POSITION is one of `left', `right', or nil, meaning do not show
5976 For example, ((top . left) (t . right)) places the top angle bitmap in
5977 left fringe, the bottom angle bitmap in right fringe, and both arrow
5978 bitmaps in right fringe. To show just the angle bitmaps in the left
5979 fringe, but no arrow bitmaps, use ((top . left) (bottom . left)). */);
5981 DEFVAR_PER_BUFFER ("fringe-indicator-alist",
5982 ¤t_buffer
->fringe_indicator_alist
, Qnil
,
5983 doc
: /* *Mapping from logical to physical fringe indicator bitmaps.
5984 The value is an alist where each element (INDICATOR . BITMAPS)
5985 specifies the fringe bitmaps used to display a specific logical
5988 INDICATOR specifies the logical indicator type which is one of the
5989 following symbols: `truncation' , `continuation', `overlay-arrow',
5990 `top', `bottom', `up', `down', `one-line', `empty-line', or `unknown'.
5992 BITMAPS is list of symbols (LEFT RIGHT [LEFT1 RIGHT1]) which specifies
5993 the actual bitmap shown in the left or right fringe for the logical
5994 indicator. LEFT and RIGHT are the bitmaps shown in the left and/or
5995 right fringe for the specific indicator. The LEFT1 or RIGHT1 bitmaps
5996 are used only for the `bottom' and `one-line' indicators when the last
5997 \(only) line in has no final newline. BITMAPS may also be a single
5998 symbol which is used in both left and right fringes. */);
6000 DEFVAR_PER_BUFFER ("fringe-cursor-alist",
6001 ¤t_buffer
->fringe_cursor_alist
, Qnil
,
6002 doc
: /* *Mapping from logical to physical fringe cursor bitmaps.
6003 The value is an alist where each element (CURSOR . BITMAP)
6004 specifies the fringe bitmaps used to display a specific logical
6005 cursor type in the fringe.
6007 CURSOR specifies the logical cursor type which is one of the following
6008 symbols: `box' , `hollow', `bar', `hbar', or `hollow-small'. The last
6009 one is used to show a hollow cursor on narrow lines display lines
6010 where the normal hollow cursor will not fit.
6012 BITMAP is the corresponding fringe bitmap shown for the logical
6015 DEFVAR_PER_BUFFER ("scroll-up-aggressively",
6016 ¤t_buffer
->scroll_up_aggressively
, Qnil
,
6017 doc
: /* How far to scroll windows upward.
6018 If you move point off the bottom, the window scrolls automatically.
6019 This variable controls how far it scrolls. The value nil, the default,
6020 means scroll to center point. A fraction means scroll to put point
6021 that fraction of the window's height from the bottom of the window.
6022 When the value is 0.0, point goes at the bottom line, which in the
6023 simple case that you moved off with C-f means scrolling just one line.
6024 1.0 means point goes at the top, so that in that simple case, the
6025 window scrolls by a full window height. Meaningful values are
6026 between 0.0 and 1.0, inclusive. */);
6028 DEFVAR_PER_BUFFER ("scroll-down-aggressively",
6029 ¤t_buffer
->scroll_down_aggressively
, Qnil
,
6030 doc
: /* How far to scroll windows downward.
6031 If you move point off the top, the window scrolls automatically.
6032 This variable controls how far it scrolls. The value nil, the default,
6033 means scroll to center point. A fraction means scroll to put point
6034 that fraction of the window's height from the top of the window.
6035 When the value is 0.0, point goes at the top line, which in the
6036 simple case that you moved off with C-b means scrolling just one line.
6037 1.0 means point goes at the bottom, so that in that simple case, the
6038 window scrolls by a full window height. Meaningful values are
6039 between 0.0 and 1.0, inclusive. */);
6041 /*DEFVAR_LISP ("debug-check-symbol", &Vcheck_symbol,
6045 DEFVAR_LISP ("before-change-functions", &Vbefore_change_functions
,
6046 doc
: /* List of functions to call before each text change.
6047 Two arguments are passed to each function: the positions of
6048 the beginning and end of the range of old text to be changed.
6049 \(For an insertion, the beginning and end are at the same place.)
6050 No information is given about the length of the text after the change.
6052 Buffer changes made while executing the `before-change-functions'
6053 don't call any before-change or after-change functions.
6054 That's because these variables are temporarily set to nil.
6055 As a result, a hook function cannot straightforwardly alter the
6056 value of these variables. See the Emacs Lisp manual for a way of
6057 accomplishing an equivalent result by using other variables.
6059 If an unhandled error happens in running these functions,
6060 the variable's value remains nil. That prevents the error
6061 from happening repeatedly and making Emacs nonfunctional. */);
6062 Vbefore_change_functions
= Qnil
;
6064 DEFVAR_LISP ("after-change-functions", &Vafter_change_functions
,
6065 doc
: /* List of functions to call after each text change.
6066 Three arguments are passed to each function: the positions of
6067 the beginning and end of the range of changed text,
6068 and the length in bytes of the pre-change text replaced by that range.
6069 \(For an insertion, the pre-change length is zero;
6070 for a deletion, that length is the number of bytes deleted,
6071 and the post-change beginning and end are at the same place.)
6073 Buffer changes made while executing the `after-change-functions'
6074 don't call any before-change or after-change functions.
6075 That's because these variables are temporarily set to nil.
6076 As a result, a hook function cannot straightforwardly alter the
6077 value of these variables. See the Emacs Lisp manual for a way of
6078 accomplishing an equivalent result by using other variables.
6080 If an unhandled error happens in running these functions,
6081 the variable's value remains nil. That prevents the error
6082 from happening repeatedly and making Emacs nonfunctional. */);
6083 Vafter_change_functions
= Qnil
;
6085 DEFVAR_LISP ("first-change-hook", &Vfirst_change_hook
,
6086 doc
: /* A list of functions to call before changing a buffer which is unmodified.
6087 The functions are run using the `run-hooks' function. */);
6088 Vfirst_change_hook
= Qnil
;
6090 DEFVAR_PER_BUFFER ("buffer-undo-list", ¤t_buffer
->undo_list
, Qnil
,
6091 doc
: /* List of undo entries in current buffer.
6092 Recent changes come first; older changes follow newer.
6094 An entry (BEG . END) represents an insertion which begins at
6095 position BEG and ends at position END.
6097 An entry (TEXT . POSITION) represents the deletion of the string TEXT
6098 from (abs POSITION). If POSITION is positive, point was at the front
6099 of the text being deleted; if negative, point was at the end.
6101 An entry (t HIGH . LOW) indicates that the buffer previously had
6102 \"unmodified\" status. HIGH and LOW are the high and low 16-bit portions
6103 of the visited file's modification time, as of that time. If the
6104 modification time of the most recent save is different, this entry is
6107 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
6108 was modified between BEG and END. PROPERTY is the property name,
6109 and VALUE is the old value.
6111 An entry (apply FUN-NAME . ARGS) means undo the change with
6112 \(apply FUN-NAME ARGS).
6114 An entry (apply DELTA BEG END FUN-NAME . ARGS) supports selective undo
6115 in the active region. BEG and END is the range affected by this entry
6116 and DELTA is the number of bytes added or deleted in that range by
6119 An entry (MARKER . DISTANCE) indicates that the marker MARKER
6120 was adjusted in position by the offset DISTANCE (an integer).
6122 An entry of the form POSITION indicates that point was at the buffer
6123 location given by the integer. Undoing an entry of this form places
6126 Entries with value `nil' mark undo boundaries. The undo command treats
6127 the changes between two undo boundaries as a single step to be undone.
6129 If the value of the variable is t, undo information is not recorded. */);
6131 DEFVAR_PER_BUFFER ("mark-active", ¤t_buffer
->mark_active
, Qnil
,
6132 doc
: /* Non-nil means the mark and region are currently active in this buffer. */);
6134 DEFVAR_PER_BUFFER ("cache-long-line-scans", ¤t_buffer
->cache_long_line_scans
, Qnil
,
6135 doc
: /* Non-nil means that Emacs should use caches to handle long lines more quickly.
6137 Normally, the line-motion functions work by scanning the buffer for
6138 newlines. Columnar operations (like `move-to-column' and
6139 `compute-motion') also work by scanning the buffer, summing character
6140 widths as they go. This works well for ordinary text, but if the
6141 buffer's lines are very long (say, more than 500 characters), these
6142 motion functions will take longer to execute. Emacs may also take
6143 longer to update the display.
6145 If `cache-long-line-scans' is non-nil, these motion functions cache the
6146 results of their scans, and consult the cache to avoid rescanning
6147 regions of the buffer until the text is modified. The caches are most
6148 beneficial when they prevent the most searching---that is, when the
6149 buffer contains long lines and large regions of characters with the
6150 same, fixed screen width.
6152 When `cache-long-line-scans' is non-nil, processing short lines will
6153 become slightly slower (because of the overhead of consulting the
6154 cache), and the caches will use memory roughly proportional to the
6155 number of newlines and characters whose screen width varies.
6157 The caches require no explicit maintenance; their accuracy is
6158 maintained internally by the Emacs primitives. Enabling or disabling
6159 the cache should not affect the behavior of any of the motion
6160 functions; it should only affect their performance. */);
6162 DEFVAR_PER_BUFFER ("point-before-scroll", ¤t_buffer
->point_before_scroll
, Qnil
,
6163 doc
: /* Value of point before the last series of scroll operations, or nil. */);
6165 DEFVAR_PER_BUFFER ("buffer-file-format", ¤t_buffer
->file_format
, Qnil
,
6166 doc
: /* List of formats to use when saving this buffer.
6167 Formats are defined by `format-alist'. This variable is
6168 set when a file is visited. */);
6170 DEFVAR_PER_BUFFER ("buffer-auto-save-file-format",
6171 ¤t_buffer
->auto_save_file_format
, Qnil
,
6172 doc
: /* *Format in which to write auto-save files.
6173 Should be a list of symbols naming formats that are defined in `format-alist'.
6174 If it is t, which is the default, auto-save files are written in the
6175 same format as a regular save would use. */);
6177 DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
6178 ¤t_buffer
->invisibility_spec
, Qnil
,
6179 doc
: /* Invisibility spec of this buffer.
6180 The default is t, which means that text is invisible
6181 if it has a non-nil `invisible' property.
6182 If the value is a list, a text character is invisible if its `invisible'
6183 property is an element in that list (or is a list with members in common).
6184 If an element is a cons cell of the form (PROP . ELLIPSIS),
6185 then characters with property value PROP are invisible,
6186 and they have an ellipsis as well if ELLIPSIS is non-nil. */);
6188 DEFVAR_PER_BUFFER ("buffer-display-count",
6189 ¤t_buffer
->display_count
, Qnil
,
6190 doc
: /* A number incremented each time this buffer is displayed in a window.
6191 The function `set-window-buffer' increments it. */);
6193 DEFVAR_PER_BUFFER ("buffer-display-time",
6194 ¤t_buffer
->display_time
, Qnil
,
6195 doc
: /* Time stamp updated each time this buffer is displayed in a window.
6196 The function `set-window-buffer' updates this variable
6197 to the value obtained by calling `current-time'.
6198 If the buffer has never been shown in a window, the value is nil. */);
6200 DEFVAR_LISP ("transient-mark-mode", &Vtransient_mark_mode
,
6202 Vtransient_mark_mode
= Qnil
;
6203 /* The docstring is in simple.el. If we put it here, it would be
6204 overwritten when transient-mark-mode is defined using
6205 define-minor-mode. */
6207 DEFVAR_LISP ("inhibit-read-only", &Vinhibit_read_only
,
6208 doc
: /* *Non-nil means disregard read-only status of buffers or characters.
6209 If the value is t, disregard `buffer-read-only' and all `read-only'
6210 text properties. If the value is a list, disregard `buffer-read-only'
6211 and disregard a `read-only' text property if the property value
6212 is a member of the list. */);
6213 Vinhibit_read_only
= Qnil
;
6215 DEFVAR_PER_BUFFER ("cursor-type", ¤t_buffer
->cursor_type
, Qnil
,
6216 doc
: /* Cursor to use when this buffer is in the selected window.
6217 Values are interpreted as follows:
6219 t use the cursor specified for the frame
6220 nil don't display a cursor
6221 box display a filled box cursor
6222 hollow display a hollow box cursor
6223 bar display a vertical bar cursor with default width
6224 (bar . WIDTH) display a vertical bar cursor with width WIDTH
6225 hbar display a horizontal bar cursor with default height
6226 (hbar . HEIGHT) display a horizontal bar cursor with height HEIGHT
6227 ANYTHING ELSE display a hollow box cursor
6229 When the buffer is displayed in a non-selected window, the
6230 cursor's appearance is instead controlled by the variable
6231 `cursor-in-non-selected-windows'. */);
6233 DEFVAR_PER_BUFFER ("line-spacing",
6234 ¤t_buffer
->extra_line_spacing
, Qnil
,
6235 doc
: /* Additional space to put between lines when displaying a buffer.
6236 The space is measured in pixels, and put below lines on window systems.
6237 If value is a floating point number, it specifies the spacing relative
6238 to the default frame line height. A value of nil means add no extra space. */);
6240 DEFVAR_PER_BUFFER ("cursor-in-non-selected-windows",
6241 ¤t_buffer
->cursor_in_non_selected_windows
, Qnil
,
6242 doc
: /* *Cursor type to display in non-selected windows.
6243 The value t means to use hollow box cursor. See `cursor-type' for other values. */);
6245 DEFVAR_LISP ("kill-buffer-query-functions", &Vkill_buffer_query_functions
,
6246 doc
: /* List of functions called with no args to query before killing a buffer.
6247 The buffer being killed will be current while the functions are running.
6248 If any of them returns nil, the buffer is not killed. */);
6249 Vkill_buffer_query_functions
= Qnil
;
6251 DEFVAR_LISP ("change-major-mode-hook", &Vchange_major_mode_hook
,
6252 doc
: /* Normal hook run before changing the major mode of a buffer.
6253 The function `kill-all-local-variables' runs this before doing anything else. */);
6254 Vchange_major_mode_hook
= Qnil
;
6255 Qchange_major_mode_hook
= intern ("change-major-mode-hook");
6256 staticpro (&Qchange_major_mode_hook
);
6258 defsubr (&Sbuffer_live_p
);
6259 defsubr (&Sbuffer_list
);
6260 defsubr (&Sget_buffer
);
6261 defsubr (&Sget_file_buffer
);
6262 defsubr (&Sget_buffer_create
);
6263 defsubr (&Smake_indirect_buffer
);
6264 defsubr (&Sgenerate_new_buffer_name
);
6265 defsubr (&Sbuffer_name
);
6266 /*defsubr (&Sbuffer_number);*/
6267 defsubr (&Sbuffer_file_name
);
6268 defsubr (&Sbuffer_base_buffer
);
6269 defsubr (&Sbuffer_local_value
);
6270 defsubr (&Sbuffer_local_variables
);
6271 defsubr (&Sbuffer_modified_p
);
6272 defsubr (&Sset_buffer_modified_p
);
6273 defsubr (&Sbuffer_modified_tick
);
6274 defsubr (&Sbuffer_chars_modified_tick
);
6275 defsubr (&Srename_buffer
);
6276 defsubr (&Sother_buffer
);
6277 defsubr (&Sbuffer_enable_undo
);
6278 defsubr (&Skill_buffer
);
6279 defsubr (&Sset_buffer_major_mode
);
6280 defsubr (&Sswitch_to_buffer
);
6281 defsubr (&Scurrent_buffer
);
6282 defsubr (&Sset_buffer
);
6283 defsubr (&Sbarf_if_buffer_read_only
);
6284 defsubr (&Sbury_buffer
);
6285 defsubr (&Serase_buffer
);
6286 defsubr (&Sbuffer_swap_text
);
6287 defsubr (&Sset_buffer_multibyte
);
6288 defsubr (&Skill_all_local_variables
);
6290 defsubr (&Soverlayp
);
6291 defsubr (&Smake_overlay
);
6292 defsubr (&Sdelete_overlay
);
6293 defsubr (&Smove_overlay
);
6294 defsubr (&Soverlay_start
);
6295 defsubr (&Soverlay_end
);
6296 defsubr (&Soverlay_buffer
);
6297 defsubr (&Soverlay_properties
);
6298 defsubr (&Soverlays_at
);
6299 defsubr (&Soverlays_in
);
6300 defsubr (&Snext_overlay_change
);
6301 defsubr (&Sprevious_overlay_change
);
6302 defsubr (&Soverlay_recenter
);
6303 defsubr (&Soverlay_lists
);
6304 defsubr (&Soverlay_get
);
6305 defsubr (&Soverlay_put
);
6306 defsubr (&Srestore_buffer_modified_p
);
6312 initial_define_key (control_x_map
, 'b', "switch-to-buffer");
6313 initial_define_key (control_x_map
, 'k', "kill-buffer");
6315 /* This must not be in syms_of_buffer, because Qdisabled is not
6316 initialized when that function gets called. */
6317 Fput (intern ("erase-buffer"), Qdisabled
, Qt
);
6320 /* arch-tag: e48569bf-69a9-4b65-a23b-8e68769436e1
6321 (do not change this comment) */