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. */
2186 extern void r_alloc_reset_variable
P_ ((POINTER_TYPE
*, POINTER_TYPE
*));
2187 #endif /* REL_ALLOC */
2189 DEFUN ("buffer-swap-text", Fbuffer_swap_text
, Sbuffer_swap_text
,
2191 doc
: /* Swap the text between current buffer and BUFFER. */)
2195 struct buffer
*other_buffer
;
2196 CHECK_BUFFER (buffer
);
2197 other_buffer
= XBUFFER (buffer
);
2199 if (NILP (other_buffer
->name
))
2200 error ("Cannot swap a dead buffer's text");
2202 /* Actually, it probably works just fine.
2203 * if (other_buffer == current_buffer)
2204 * error ("Cannot swap a buffer's text with itself"); */
2206 /* Actually, this may be workable as well, tho probably only if they're
2208 if (other_buffer
->base_buffer
2209 || current_buffer
->base_buffer
)
2210 error ("Cannot swap indirect buffers's text");
2212 { /* This is probably harder to make work. */
2213 struct buffer
*other
;
2214 for (other
= all_buffers
; other
; other
= other
->next
)
2215 if (other
->base_buffer
== other_buffer
2216 || other
->base_buffer
== current_buffer
)
2217 error ("One of the buffers to swap has indirect buffers");
2220 #define swapfield(field, type) \
2222 type tmp##field = other_buffer->field; \
2223 other_buffer->field = current_buffer->field; \
2224 current_buffer->field = tmp##field; \
2227 swapfield (own_text
, struct buffer_text
);
2228 eassert (current_buffer
->text
== ¤t_buffer
->own_text
);
2229 eassert (other_buffer
->text
== &other_buffer
->own_text
);
2231 r_alloc_reset_variable ((POINTER_TYPE
**) ¤t_buffer
->own_text
.beg
,
2232 (POINTER_TYPE
**) &other_buffer
->own_text
.beg
);
2233 r_alloc_reset_variable ((POINTER_TYPE
**) &other_buffer
->own_text
.beg
,
2234 (POINTER_TYPE
**) ¤t_buffer
->own_text
.beg
);
2235 #endif /* REL_ALLOC */
2237 swapfield (pt
, EMACS_INT
);
2238 swapfield (pt_byte
, EMACS_INT
);
2239 swapfield (begv
, EMACS_INT
);
2240 swapfield (begv_byte
, EMACS_INT
);
2241 swapfield (zv
, EMACS_INT
);
2242 swapfield (zv_byte
, EMACS_INT
);
2243 eassert (!current_buffer
->base_buffer
);
2244 eassert (!other_buffer
->base_buffer
);
2245 current_buffer
->clip_changed
= 1; other_buffer
->clip_changed
= 1;
2246 swapfield (newline_cache
, struct region_cache
*);
2247 swapfield (width_run_cache
, struct region_cache
*);
2248 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2249 other_buffer
->prevent_redisplay_optimizations_p
= 1;
2250 swapfield (overlays_before
, struct Lisp_Overlay
*);
2251 swapfield (overlays_after
, struct Lisp_Overlay
*);
2252 swapfield (overlay_center
, EMACS_INT
);
2253 swapfield (undo_list
, Lisp_Object
);
2254 swapfield (mark
, Lisp_Object
);
2255 swapfield (enable_multibyte_characters
, Lisp_Object
);
2256 /* FIXME: Not sure what we should do with these *_marker fields.
2257 Hopefully they're just nil anyway. */
2258 swapfield (pt_marker
, Lisp_Object
);
2259 swapfield (begv_marker
, Lisp_Object
);
2260 swapfield (zv_marker
, Lisp_Object
);
2261 current_buffer
->point_before_scroll
= Qnil
;
2262 other_buffer
->point_before_scroll
= Qnil
;
2264 current_buffer
->text
->modiff
++; other_buffer
->text
->modiff
++;
2265 current_buffer
->text
->chars_modiff
++; other_buffer
->text
->chars_modiff
++;
2266 current_buffer
->text
->overlay_modiff
++; other_buffer
->text
->overlay_modiff
++;
2267 current_buffer
->text
->beg_unchanged
= current_buffer
->text
->gpt
;
2268 current_buffer
->text
->end_unchanged
= current_buffer
->text
->gpt
;
2269 other_buffer
->text
->beg_unchanged
= other_buffer
->text
->gpt
;
2270 other_buffer
->text
->end_unchanged
= other_buffer
->text
->gpt
;
2272 struct Lisp_Marker
*m
;
2273 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
2274 if (m
->buffer
== other_buffer
)
2275 m
->buffer
= current_buffer
;
2277 /* Since there's no indirect buffer in sight, markers on
2278 BUF_MARKERS(buf) should either be for `buf' or dead. */
2279 eassert (!m
->buffer
);
2280 for (m
= BUF_MARKERS (other_buffer
); m
; m
= m
->next
)
2281 if (m
->buffer
== current_buffer
)
2282 m
->buffer
= other_buffer
;
2284 /* Since there's no indirect buffer in sight, markers on
2285 BUF_MARKERS(buf) should either be for `buf' or dead. */
2286 eassert (!m
->buffer
);
2288 { /* Some of the C code expects that w->buffer == w->pointm->buffer.
2289 So since we just swapped the markers between the two buffers, we need
2290 to undo the effect of this swap for window markers. */
2291 Lisp_Object w
= Fselected_window (), ws
= Qnil
;
2292 Lisp_Object buf1
, buf2
;
2293 XSETBUFFER (buf1
, current_buffer
); XSETBUFFER (buf2
, other_buffer
);
2295 while (NILP (Fmemq (w
, ws
)))
2298 if (MARKERP (XWINDOW (w
)->pointm
)
2299 && (EQ (XWINDOW (w
)->buffer
, buf1
)
2300 || EQ (XWINDOW (w
)->buffer
, buf2
)))
2301 Fset_marker (XWINDOW (w
)->pointm
,
2302 make_number (BUF_BEGV (XBUFFER (XWINDOW (w
)->buffer
))),
2303 XWINDOW (w
)->buffer
);
2304 w
= Fnext_window (w
, Qt
, Qt
);
2308 if (current_buffer
->text
->intervals
)
2309 (eassert (EQ (current_buffer
->text
->intervals
->up
.obj
, buffer
)),
2310 XSETBUFFER (current_buffer
->text
->intervals
->up
.obj
, current_buffer
));
2311 if (other_buffer
->text
->intervals
)
2312 (eassert (EQ (other_buffer
->text
->intervals
->up
.obj
, Fcurrent_buffer ())),
2313 XSETBUFFER (other_buffer
->text
->intervals
->up
.obj
, other_buffer
));
2318 DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte
, Sset_buffer_multibyte
,
2320 doc
: /* Set the multibyte flag of the current buffer to FLAG.
2321 If FLAG is t, this makes the buffer a multibyte buffer.
2322 If FLAG is nil, this makes the buffer a single-byte buffer.
2323 In these cases, the buffer contents remain unchanged as a sequence of
2324 bytes but the contents viewed as characters do change.
2325 If FLAG is `to', this makes the buffer a multibyte buffer by changing
2326 all eight-bit bytes to eight-bit characters.
2327 If the multibyte flag was really changed, undo information of the
2328 current buffer is cleared. */)
2332 struct Lisp_Marker
*tail
, *markers
;
2333 struct buffer
*other
;
2335 int narrowed
= (BEG
!= BEGV
|| Z
!= ZV
);
2336 int modified_p
= !NILP (Fbuffer_modified_p (Qnil
));
2337 Lisp_Object old_undo
= current_buffer
->undo_list
;
2338 struct gcpro gcpro1
;
2340 if (current_buffer
->base_buffer
)
2341 error ("Cannot do `set-buffer-multibyte' on an indirect buffer");
2343 /* Do nothing if nothing actually changes. */
2344 if (NILP (flag
) == NILP (current_buffer
->enable_multibyte_characters
))
2349 /* Don't record these buffer changes. We will put a special undo entry
2351 current_buffer
->undo_list
= Qt
;
2353 /* If the cached position is for this buffer, clear it out. */
2354 clear_charpos_cache (current_buffer
);
2357 begv
= BEGV_BYTE
, zv
= ZV_BYTE
;
2359 begv
= BEGV
, zv
= ZV
;
2369 /* Do this first, so it can use CHAR_TO_BYTE
2370 to calculate the old correspondences. */
2371 set_intervals_multibyte (0);
2373 current_buffer
->enable_multibyte_characters
= Qnil
;
2379 TEMP_SET_PT_BOTH (PT_BYTE
, PT_BYTE
);
2382 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
2383 tail
->charpos
= tail
->bytepos
;
2385 /* Convert multibyte form of 8-bit characters to unibyte. */
2400 if (ASCII_BYTE_P (*p
))
2402 else if (CHAR_BYTE8_HEAD_P (*p
))
2404 c
= STRING_CHAR_AND_LENGTH (p
, stop
- pos
, bytes
);
2405 /* Delete all bytes for this 8-bit character but the
2406 last one, and change the last one to the charcter
2409 del_range_2 (pos
, pos
, pos
+ bytes
, pos
+ bytes
, 0);
2421 bytes
= BYTES_BY_CHAR_HEAD (*p
);
2422 p
+= bytes
, pos
+= bytes
;
2426 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2432 unsigned char *p
, *pend
;
2434 /* Be sure not to have a multibyte sequence striding over the GAP.
2435 Ex: We change this: "...abc\302 _GAP_ \241def..."
2436 to: "...abc _GAP_ \302\241def..." */
2439 && GPT_BYTE
> 1 && GPT_BYTE
< Z_BYTE
2440 && ! CHAR_HEAD_P (*(GAP_END_ADDR
)))
2442 unsigned char *p
= GPT_ADDR
- 1;
2444 while (! CHAR_HEAD_P (*p
) && p
> BEG_ADDR
) p
--;
2445 if (BASE_LEADING_CODE_P (*p
))
2447 int new_gpt
= GPT_BYTE
- (GPT_ADDR
- p
);
2449 move_gap_both (new_gpt
, new_gpt
);
2453 /* Make the buffer contents valid as multibyte by converting
2454 8-bit characters to multibyte form. */
2472 if (ASCII_BYTE_P (*p
))
2474 else if (EQ (flag
, Qt
) && (bytes
= MULTIBYTE_LENGTH (p
, pend
)) > 0)
2475 p
+= bytes
, pos
+= bytes
;
2478 unsigned char tmp
[MAX_MULTIBYTE_LENGTH
];
2481 c
= BYTE8_TO_CHAR (*p
);
2482 bytes
= CHAR_STRING (c
, tmp
);
2484 TEMP_SET_PT_BOTH (pos
+ 1, pos
+ 1);
2486 insert_1_both (tmp
+ 1, bytes
, bytes
, 1, 0, 0);
2487 /* Now the gap is after the just inserted data. */
2505 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2507 /* Do this first, so that chars_in_text asks the right question.
2508 set_intervals_multibyte needs it too. */
2509 current_buffer
->enable_multibyte_characters
= Qt
;
2511 GPT_BYTE
= advance_to_char_boundary (GPT_BYTE
);
2512 GPT
= chars_in_text (BEG_ADDR
, GPT_BYTE
- BEG_BYTE
) + BEG
;
2514 Z
= chars_in_text (GAP_END_ADDR
, Z_BYTE
- GPT_BYTE
) + GPT
;
2516 BEGV_BYTE
= advance_to_char_boundary (BEGV_BYTE
);
2517 if (BEGV_BYTE
> GPT_BYTE
)
2518 BEGV
= chars_in_text (GAP_END_ADDR
, BEGV_BYTE
- GPT_BYTE
) + GPT
;
2520 BEGV
= chars_in_text (BEG_ADDR
, BEGV_BYTE
- BEG_BYTE
) + BEG
;
2522 ZV_BYTE
= advance_to_char_boundary (ZV_BYTE
);
2523 if (ZV_BYTE
> GPT_BYTE
)
2524 ZV
= chars_in_text (GAP_END_ADDR
, ZV_BYTE
- GPT_BYTE
) + GPT
;
2526 ZV
= chars_in_text (BEG_ADDR
, ZV_BYTE
- BEG_BYTE
) + BEG
;
2529 int pt_byte
= advance_to_char_boundary (PT_BYTE
);
2532 if (pt_byte
> GPT_BYTE
)
2533 pt
= chars_in_text (GAP_END_ADDR
, pt_byte
- GPT_BYTE
) + GPT
;
2535 pt
= chars_in_text (BEG_ADDR
, pt_byte
- BEG_BYTE
) + BEG
;
2536 TEMP_SET_PT_BOTH (pt
, pt_byte
);
2539 tail
= markers
= BUF_MARKERS (current_buffer
);
2541 /* This prevents BYTE_TO_CHAR (that is, buf_bytepos_to_charpos) from
2542 getting confused by the markers that have not yet been updated.
2543 It is also a signal that it should never create a marker. */
2544 BUF_MARKERS (current_buffer
) = NULL
;
2546 for (; tail
; tail
= tail
->next
)
2548 tail
->bytepos
= advance_to_char_boundary (tail
->bytepos
);
2549 tail
->charpos
= BYTE_TO_CHAR (tail
->bytepos
);
2552 /* Make sure no markers were put on the chain
2553 while the chain value was incorrect. */
2554 if (BUF_MARKERS (current_buffer
))
2557 BUF_MARKERS (current_buffer
) = markers
;
2559 /* Do this last, so it can calculate the new correspondences
2560 between chars and bytes. */
2561 set_intervals_multibyte (1);
2564 if (!EQ (old_undo
, Qt
))
2566 /* Represent all the above changes by a special undo entry. */
2567 extern Lisp_Object Qapply
;
2568 current_buffer
->undo_list
= Fcons (list3 (Qapply
,
2569 intern ("set-buffer-multibyte"),
2570 NILP (flag
) ? Qt
: Qnil
),
2576 /* Changing the multibyteness of a buffer means that all windows
2577 showing that buffer must be updated thoroughly. */
2578 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2579 ++windows_or_buffers_changed
;
2581 /* Copy this buffer's new multibyte status
2582 into all of its indirect buffers. */
2583 for (other
= all_buffers
; other
; other
= other
->next
)
2584 if (other
->base_buffer
== current_buffer
&& !NILP (other
->name
))
2586 other
->enable_multibyte_characters
2587 = current_buffer
->enable_multibyte_characters
;
2588 other
->prevent_redisplay_optimizations_p
= 1;
2591 /* Restore the modifiedness of the buffer. */
2592 if (!modified_p
&& !NILP (Fbuffer_modified_p (Qnil
)))
2593 Fset_buffer_modified_p (Qnil
);
2596 /* Update coding systems of this buffer's process (if any). */
2598 Lisp_Object process
;
2600 process
= Fget_buffer_process (Fcurrent_buffer ());
2601 if (PROCESSP (process
))
2602 setup_process_coding_systems (process
);
2604 #endif /* subprocesses */
2609 DEFUN ("kill-all-local-variables", Fkill_all_local_variables
, Skill_all_local_variables
,
2611 doc
: /* Switch to Fundamental mode by killing current buffer's local variables.
2612 Most local variable bindings are eliminated so that the default values
2613 become effective once more. Also, the syntax table is set from
2614 `standard-syntax-table', the local keymap is set to nil,
2615 and the abbrev table from `fundamental-mode-abbrev-table'.
2616 This function also forces redisplay of the mode line.
2618 Every function to select a new major mode starts by
2619 calling this function.
2621 As a special exception, local variables whose names have
2622 a non-nil `permanent-local' property are not eliminated by this function.
2624 The first thing this function does is run
2625 the normal hook `change-major-mode-hook'. */)
2628 if (!NILP (Vrun_hooks
))
2629 call1 (Vrun_hooks
, Qchange_major_mode_hook
);
2631 /* Make sure none of the bindings in local_var_alist
2632 remain swapped in, in their symbols. */
2634 swap_out_buffer_local_variables (current_buffer
);
2636 /* Actually eliminate all local bindings of this buffer. */
2638 reset_buffer_local_variables (current_buffer
, 0);
2640 /* Force mode-line redisplay. Useful here because all major mode
2641 commands call this function. */
2642 update_mode_lines
++;
2647 /* Make sure no local variables remain set up with buffer B
2648 for their current values. */
2651 swap_out_buffer_local_variables (b
)
2654 Lisp_Object oalist
, alist
, sym
, tem
, buffer
;
2656 XSETBUFFER (buffer
, b
);
2657 oalist
= b
->local_var_alist
;
2659 for (alist
= oalist
; CONSP (alist
); alist
= XCDR (alist
))
2661 sym
= XCAR (XCAR (alist
));
2663 /* Need not do anything if some other buffer's binding is now encached. */
2664 tem
= XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->buffer
;
2665 if (EQ (tem
, buffer
))
2667 /* Symbol is set up for this buffer's old local value:
2669 swap_in_global_binding (sym
);
2674 /* Find all the overlays in the current buffer that contain position POS.
2675 Return the number found, and store them in a vector in *VEC_PTR.
2676 Store in *LEN_PTR the size allocated for the vector.
2677 Store in *NEXT_PTR the next position after POS where an overlay starts,
2678 or ZV if there are no more overlays between POS and ZV.
2679 Store in *PREV_PTR the previous position before POS where an overlay ends,
2680 or where an overlay starts which ends at or after POS;
2681 or BEGV if there are no such overlays from BEGV to POS.
2682 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2684 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2685 when this function is called.
2687 If EXTEND is non-zero, we make the vector bigger if necessary.
2688 If EXTEND is zero, we never extend the vector,
2689 and we store only as many overlays as will fit.
2690 But we still return the total number of overlays.
2692 If CHANGE_REQ is true, then any position written into *PREV_PTR or
2693 *NEXT_PTR is guaranteed to be not equal to POS, unless it is the
2694 default (BEGV or ZV). */
2697 overlays_at (pos
, extend
, vec_ptr
, len_ptr
, next_ptr
, prev_ptr
, change_req
)
2700 Lisp_Object
**vec_ptr
;
2702 EMACS_INT
*next_ptr
;
2703 EMACS_INT
*prev_ptr
;
2706 Lisp_Object overlay
, start
, end
;
2707 struct Lisp_Overlay
*tail
;
2710 Lisp_Object
*vec
= *vec_ptr
;
2713 int inhibit_storing
= 0;
2715 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2717 int startpos
, endpos
;
2719 XSETMISC (overlay
, tail
);
2721 start
= OVERLAY_START (overlay
);
2722 end
= OVERLAY_END (overlay
);
2723 endpos
= OVERLAY_POSITION (end
);
2730 startpos
= OVERLAY_POSITION (start
);
2731 /* This one ends at or after POS
2732 so its start counts for PREV_PTR if it's before POS. */
2733 if (prev
< startpos
&& startpos
< pos
)
2737 if (startpos
<= pos
)
2741 /* The supplied vector is full.
2742 Either make it bigger, or don't store any more in it. */
2745 /* Make it work with an initial len == 0. */
2750 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2754 inhibit_storing
= 1;
2757 if (!inhibit_storing
)
2759 /* Keep counting overlays even if we can't return them all. */
2762 else if (startpos
< next
)
2766 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2768 int startpos
, endpos
;
2770 XSETMISC (overlay
, tail
);
2772 start
= OVERLAY_START (overlay
);
2773 end
= OVERLAY_END (overlay
);
2774 startpos
= OVERLAY_POSITION (start
);
2777 if (startpos
< next
)
2781 endpos
= OVERLAY_POSITION (end
);
2788 /* Make it work with an initial len == 0. */
2793 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2797 inhibit_storing
= 1;
2800 if (!inhibit_storing
)
2804 if (startpos
< pos
&& startpos
> prev
)
2807 else if (endpos
< pos
&& endpos
> prev
)
2809 else if (endpos
== pos
&& startpos
> prev
2810 && (!change_req
|| startpos
< pos
))
2821 /* Find all the overlays in the current buffer that overlap the range
2822 BEG-END, or are empty at BEG, or are empty at END provided END
2823 denotes the position at the end of the current buffer.
2825 Return the number found, and store them in a vector in *VEC_PTR.
2826 Store in *LEN_PTR the size allocated for the vector.
2827 Store in *NEXT_PTR the next position after POS where an overlay starts,
2828 or ZV if there are no more overlays.
2829 Store in *PREV_PTR the previous position before POS where an overlay ends,
2830 or BEGV if there are no previous overlays.
2831 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2833 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2834 when this function is called.
2836 If EXTEND is non-zero, we make the vector bigger if necessary.
2837 If EXTEND is zero, we never extend the vector,
2838 and we store only as many overlays as will fit.
2839 But we still return the total number of overlays. */
2842 overlays_in (beg
, end
, extend
, vec_ptr
, len_ptr
, next_ptr
, prev_ptr
)
2845 Lisp_Object
**vec_ptr
;
2850 Lisp_Object overlay
, ostart
, oend
;
2851 struct Lisp_Overlay
*tail
;
2854 Lisp_Object
*vec
= *vec_ptr
;
2857 int inhibit_storing
= 0;
2858 int end_is_Z
= end
== Z
;
2860 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2862 int startpos
, endpos
;
2864 XSETMISC (overlay
, tail
);
2866 ostart
= OVERLAY_START (overlay
);
2867 oend
= OVERLAY_END (overlay
);
2868 endpos
= OVERLAY_POSITION (oend
);
2875 startpos
= OVERLAY_POSITION (ostart
);
2876 /* Count an interval if it overlaps the range, is empty at the
2877 start of the range, or is empty at END provided END denotes the
2878 end of the buffer. */
2879 if ((beg
< endpos
&& startpos
< end
)
2880 || (startpos
== endpos
2881 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
2885 /* The supplied vector is full.
2886 Either make it bigger, or don't store any more in it. */
2889 /* Make it work with an initial len == 0. */
2894 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2898 inhibit_storing
= 1;
2901 if (!inhibit_storing
)
2903 /* Keep counting overlays even if we can't return them all. */
2906 else if (startpos
< next
)
2910 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2912 int startpos
, endpos
;
2914 XSETMISC (overlay
, tail
);
2916 ostart
= OVERLAY_START (overlay
);
2917 oend
= OVERLAY_END (overlay
);
2918 startpos
= OVERLAY_POSITION (ostart
);
2921 if (startpos
< next
)
2925 endpos
= OVERLAY_POSITION (oend
);
2926 /* Count an interval if it overlaps the range, is empty at the
2927 start of the range, or is empty at END provided END denotes the
2928 end of the buffer. */
2929 if ((beg
< endpos
&& startpos
< end
)
2930 || (startpos
== endpos
2931 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
2937 /* Make it work with an initial len == 0. */
2942 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2946 inhibit_storing
= 1;
2949 if (!inhibit_storing
)
2953 else if (endpos
< beg
&& endpos
> prev
)
2965 /* Return non-zero if there exists an overlay with a non-nil
2966 `mouse-face' property overlapping OVERLAY. */
2969 mouse_face_overlay_overlaps (overlay
)
2970 Lisp_Object overlay
;
2972 int start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2973 int end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2975 Lisp_Object
*v
, tem
;
2978 v
= (Lisp_Object
*) alloca (size
* sizeof *v
);
2979 n
= overlays_in (start
, end
, 0, &v
, &size
, NULL
, NULL
);
2982 v
= (Lisp_Object
*) alloca (n
* sizeof *v
);
2983 overlays_in (start
, end
, 0, &v
, &n
, NULL
, NULL
);
2986 for (i
= 0; i
< n
; ++i
)
2987 if (!EQ (v
[i
], overlay
)
2988 && (tem
= Foverlay_get (overlay
, Qmouse_face
),
2997 /* Fast function to just test if we're at an overlay boundary. */
2999 overlay_touches_p (pos
)
3002 Lisp_Object overlay
;
3003 struct Lisp_Overlay
*tail
;
3005 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
3009 XSETMISC (overlay
,tail
);
3010 if (!OVERLAYP (overlay
))
3013 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3016 if (endpos
== pos
|| OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
)
3020 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
3024 XSETMISC (overlay
, tail
);
3025 if (!OVERLAYP (overlay
))
3028 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3031 if (startpos
== pos
|| OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
)
3039 Lisp_Object overlay
;
3045 compare_overlays (v1
, v2
)
3046 const void *v1
, *v2
;
3048 const struct sortvec
*s1
= (const struct sortvec
*) v1
;
3049 const struct sortvec
*s2
= (const struct sortvec
*) v2
;
3050 if (s1
->priority
!= s2
->priority
)
3051 return s1
->priority
- s2
->priority
;
3052 if (s1
->beg
!= s2
->beg
)
3053 return s1
->beg
- s2
->beg
;
3054 if (s1
->end
!= s2
->end
)
3055 return s2
->end
- s1
->end
;
3059 /* Sort an array of overlays by priority. The array is modified in place.
3060 The return value is the new size; this may be smaller than the original
3061 size if some of the overlays were invalid or were window-specific. */
3063 sort_overlays (overlay_vec
, noverlays
, w
)
3064 Lisp_Object
*overlay_vec
;
3069 struct sortvec
*sortvec
;
3070 sortvec
= (struct sortvec
*) alloca (noverlays
* sizeof (struct sortvec
));
3072 /* Put the valid and relevant overlays into sortvec. */
3074 for (i
= 0, j
= 0; i
< noverlays
; i
++)
3077 Lisp_Object overlay
;
3079 overlay
= overlay_vec
[i
];
3080 if (OVERLAY_VALID (overlay
)
3081 && OVERLAY_POSITION (OVERLAY_START (overlay
)) > 0
3082 && OVERLAY_POSITION (OVERLAY_END (overlay
)) > 0)
3084 /* If we're interested in a specific window, then ignore
3085 overlays that are limited to some other window. */
3090 window
= Foverlay_get (overlay
, Qwindow
);
3091 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3095 /* This overlay is good and counts: put it into sortvec. */
3096 sortvec
[j
].overlay
= overlay
;
3097 sortvec
[j
].beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3098 sortvec
[j
].end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3099 tem
= Foverlay_get (overlay
, Qpriority
);
3101 sortvec
[j
].priority
= XINT (tem
);
3103 sortvec
[j
].priority
= 0;
3109 /* Sort the overlays into the proper order: increasing priority. */
3112 qsort (sortvec
, noverlays
, sizeof (struct sortvec
), compare_overlays
);
3114 for (i
= 0; i
< noverlays
; i
++)
3115 overlay_vec
[i
] = sortvec
[i
].overlay
;
3121 Lisp_Object string
, string2
;
3128 struct sortstr
*buf
; /* An array that expands as needed; never freed. */
3129 int size
; /* Allocated length of that array. */
3130 int used
; /* How much of the array is currently in use. */
3131 int bytes
; /* Total length of the strings in buf. */
3134 /* Buffers for storing information about the overlays touching a given
3135 position. These could be automatic variables in overlay_strings, but
3136 it's more efficient to hold onto the memory instead of repeatedly
3137 allocating and freeing it. */
3138 static struct sortstrlist overlay_heads
, overlay_tails
;
3139 static unsigned char *overlay_str_buf
;
3141 /* Allocated length of overlay_str_buf. */
3142 static int overlay_str_len
;
3144 /* A comparison function suitable for passing to qsort. */
3146 cmp_for_strings (as1
, as2
)
3149 struct sortstr
*s1
= (struct sortstr
*)as1
;
3150 struct sortstr
*s2
= (struct sortstr
*)as2
;
3151 if (s1
->size
!= s2
->size
)
3152 return s2
->size
- s1
->size
;
3153 if (s1
->priority
!= s2
->priority
)
3154 return s1
->priority
- s2
->priority
;
3159 record_overlay_string (ssl
, str
, str2
, pri
, size
)
3160 struct sortstrlist
*ssl
;
3161 Lisp_Object str
, str2
, pri
;
3166 if (ssl
->used
== ssl
->size
)
3172 ssl
->buf
= ((struct sortstr
*)
3173 xrealloc (ssl
->buf
, ssl
->size
* sizeof (struct sortstr
)));
3175 ssl
->buf
[ssl
->used
].string
= str
;
3176 ssl
->buf
[ssl
->used
].string2
= str2
;
3177 ssl
->buf
[ssl
->used
].size
= size
;
3178 ssl
->buf
[ssl
->used
].priority
= (INTEGERP (pri
) ? XINT (pri
) : 0);
3181 if (NILP (current_buffer
->enable_multibyte_characters
))
3182 nbytes
= SCHARS (str
);
3183 else if (! STRING_MULTIBYTE (str
))
3184 nbytes
= count_size_as_multibyte (SDATA (str
),
3187 nbytes
= SBYTES (str
);
3189 ssl
->bytes
+= nbytes
;
3193 if (NILP (current_buffer
->enable_multibyte_characters
))
3194 nbytes
= SCHARS (str2
);
3195 else if (! STRING_MULTIBYTE (str2
))
3196 nbytes
= count_size_as_multibyte (SDATA (str2
),
3199 nbytes
= SBYTES (str2
);
3201 ssl
->bytes
+= nbytes
;
3205 /* Return the concatenation of the strings associated with overlays that
3206 begin or end at POS, ignoring overlays that are specific to a window
3207 other than W. The strings are concatenated in the appropriate order:
3208 shorter overlays nest inside longer ones, and higher priority inside
3209 lower. Normally all of the after-strings come first, but zero-sized
3210 overlays have their after-strings ride along with the before-strings
3211 because it would look strange to print them inside-out.
3213 Returns the string length, and stores the contents indirectly through
3214 PSTR, if that variable is non-null. The string may be overwritten by
3215 subsequent calls. */
3218 overlay_strings (pos
, w
, pstr
)
3221 unsigned char **pstr
;
3223 Lisp_Object overlay
, window
, str
;
3224 struct Lisp_Overlay
*ov
;
3225 int startpos
, endpos
;
3226 int multibyte
= ! NILP (current_buffer
->enable_multibyte_characters
);
3228 overlay_heads
.used
= overlay_heads
.bytes
= 0;
3229 overlay_tails
.used
= overlay_tails
.bytes
= 0;
3230 for (ov
= current_buffer
->overlays_before
; ov
; ov
= ov
->next
)
3232 XSETMISC (overlay
, ov
);
3233 eassert (OVERLAYP (overlay
));
3235 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3236 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3239 if (endpos
!= pos
&& startpos
!= pos
)
3241 window
= Foverlay_get (overlay
, Qwindow
);
3242 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3245 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3246 record_overlay_string (&overlay_heads
, str
,
3248 ? Foverlay_get (overlay
, Qafter_string
)
3250 Foverlay_get (overlay
, Qpriority
),
3252 else if (endpos
== pos
3253 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3254 record_overlay_string (&overlay_tails
, str
, Qnil
,
3255 Foverlay_get (overlay
, Qpriority
),
3258 for (ov
= current_buffer
->overlays_after
; ov
; ov
= ov
->next
)
3260 XSETMISC (overlay
, ov
);
3261 eassert (OVERLAYP (overlay
));
3263 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3264 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3267 if (endpos
!= pos
&& startpos
!= pos
)
3269 window
= Foverlay_get (overlay
, Qwindow
);
3270 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3273 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3274 record_overlay_string (&overlay_heads
, str
,
3276 ? Foverlay_get (overlay
, Qafter_string
)
3278 Foverlay_get (overlay
, Qpriority
),
3280 else if (endpos
== pos
3281 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3282 record_overlay_string (&overlay_tails
, str
, Qnil
,
3283 Foverlay_get (overlay
, Qpriority
),
3286 if (overlay_tails
.used
> 1)
3287 qsort (overlay_tails
.buf
, overlay_tails
.used
, sizeof (struct sortstr
),
3289 if (overlay_heads
.used
> 1)
3290 qsort (overlay_heads
.buf
, overlay_heads
.used
, sizeof (struct sortstr
),
3292 if (overlay_heads
.bytes
|| overlay_tails
.bytes
)
3297 int total
= overlay_heads
.bytes
+ overlay_tails
.bytes
;
3299 if (total
> overlay_str_len
)
3301 overlay_str_len
= total
;
3302 overlay_str_buf
= (unsigned char *)xrealloc (overlay_str_buf
,
3305 p
= overlay_str_buf
;
3306 for (i
= overlay_tails
.used
; --i
>= 0;)
3309 tem
= overlay_tails
.buf
[i
].string
;
3310 nbytes
= copy_text (SDATA (tem
), p
,
3312 STRING_MULTIBYTE (tem
), multibyte
);
3315 for (i
= 0; i
< overlay_heads
.used
; ++i
)
3318 tem
= overlay_heads
.buf
[i
].string
;
3319 nbytes
= copy_text (SDATA (tem
), p
,
3321 STRING_MULTIBYTE (tem
), multibyte
);
3323 tem
= overlay_heads
.buf
[i
].string2
;
3326 nbytes
= copy_text (SDATA (tem
), p
,
3328 STRING_MULTIBYTE (tem
), multibyte
);
3332 if (p
!= overlay_str_buf
+ total
)
3335 *pstr
= overlay_str_buf
;
3341 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
3344 recenter_overlay_lists (buf
, pos
)
3348 Lisp_Object overlay
, beg
, end
;
3349 struct Lisp_Overlay
*prev
, *tail
, *next
;
3351 /* See if anything in overlays_before should move to overlays_after. */
3353 /* We don't strictly need prev in this loop; it should always be nil.
3354 But we use it for symmetry and in case that should cease to be true
3355 with some future change. */
3357 for (tail
= buf
->overlays_before
; tail
; prev
= tail
, tail
= next
)
3360 XSETMISC (overlay
, tail
);
3362 /* If the overlay is not valid, get rid of it. */
3363 if (!OVERLAY_VALID (overlay
))
3368 /* Splice the cons cell TAIL out of overlays_before. */
3372 buf
->overlays_before
= next
;
3378 beg
= OVERLAY_START (overlay
);
3379 end
= OVERLAY_END (overlay
);
3381 if (OVERLAY_POSITION (end
) > pos
)
3383 /* OVERLAY needs to be moved. */
3384 int where
= OVERLAY_POSITION (beg
);
3385 struct Lisp_Overlay
*other
, *other_prev
;
3387 /* Splice the cons cell TAIL out of overlays_before. */
3391 buf
->overlays_before
= next
;
3393 /* Search thru overlays_after for where to put it. */
3395 for (other
= buf
->overlays_after
; other
;
3396 other_prev
= other
, other
= other
->next
)
3398 Lisp_Object otherbeg
, otheroverlay
;
3400 XSETMISC (otheroverlay
, other
);
3401 eassert (OVERLAY_VALID (otheroverlay
));
3403 otherbeg
= OVERLAY_START (otheroverlay
);
3404 if (OVERLAY_POSITION (otherbeg
) >= where
)
3408 /* Add TAIL to overlays_after before OTHER. */
3411 other_prev
->next
= tail
;
3413 buf
->overlays_after
= tail
;
3417 /* We've reached the things that should stay in overlays_before.
3418 All the rest of overlays_before must end even earlier,
3423 /* See if anything in overlays_after should be in overlays_before. */
3425 for (tail
= buf
->overlays_after
; tail
; prev
= tail
, tail
= next
)
3428 XSETMISC (overlay
, tail
);
3430 /* If the overlay is not valid, get rid of it. */
3431 if (!OVERLAY_VALID (overlay
))
3436 /* Splice the cons cell TAIL out of overlays_after. */
3440 buf
->overlays_after
= next
;
3446 beg
= OVERLAY_START (overlay
);
3447 end
= OVERLAY_END (overlay
);
3449 /* Stop looking, when we know that nothing further
3450 can possibly end before POS. */
3451 if (OVERLAY_POSITION (beg
) > pos
)
3454 if (OVERLAY_POSITION (end
) <= pos
)
3456 /* OVERLAY needs to be moved. */
3457 int where
= OVERLAY_POSITION (end
);
3458 struct Lisp_Overlay
*other
, *other_prev
;
3460 /* Splice the cons cell TAIL out of overlays_after. */
3464 buf
->overlays_after
= next
;
3466 /* Search thru overlays_before for where to put it. */
3468 for (other
= buf
->overlays_before
; other
;
3469 other_prev
= other
, other
= other
->next
)
3471 Lisp_Object otherend
, otheroverlay
;
3473 XSETMISC (otheroverlay
, other
);
3474 eassert (OVERLAY_VALID (otheroverlay
));
3476 otherend
= OVERLAY_END (otheroverlay
);
3477 if (OVERLAY_POSITION (otherend
) <= where
)
3481 /* Add TAIL to overlays_before before OTHER. */
3484 other_prev
->next
= tail
;
3486 buf
->overlays_before
= tail
;
3491 buf
->overlay_center
= pos
;
3495 adjust_overlays_for_insert (pos
, length
)
3499 /* After an insertion, the lists are still sorted properly,
3500 but we may need to update the value of the overlay center. */
3501 if (current_buffer
->overlay_center
>= pos
)
3502 current_buffer
->overlay_center
+= length
;
3506 adjust_overlays_for_delete (pos
, length
)
3510 if (current_buffer
->overlay_center
< pos
)
3511 /* The deletion was to our right. No change needed; the before- and
3512 after-lists are still consistent. */
3514 else if (current_buffer
->overlay_center
> pos
+ length
)
3515 /* The deletion was to our left. We need to adjust the center value
3516 to account for the change in position, but the lists are consistent
3517 given the new value. */
3518 current_buffer
->overlay_center
-= length
;
3520 /* We're right in the middle. There might be things on the after-list
3521 that now belong on the before-list. Recentering will move them,
3522 and also update the center point. */
3523 recenter_overlay_lists (current_buffer
, pos
);
3526 /* Fix up overlays that were garbled as a result of permuting markers
3527 in the range START through END. Any overlay with at least one
3528 endpoint in this range will need to be unlinked from the overlay
3529 list and reinserted in its proper place.
3530 Such an overlay might even have negative size at this point.
3531 If so, we'll make the overlay empty. */
3533 fix_start_end_in_overlays (start
, end
)
3534 register int start
, end
;
3536 Lisp_Object overlay
;
3537 struct Lisp_Overlay
*before_list
, *after_list
;
3538 /* These are either nil, indicating that before_list or after_list
3539 should be assigned, or the cons cell the cdr of which should be
3541 struct Lisp_Overlay
*beforep
= NULL
, *afterp
= NULL
;
3542 /* 'Parent', likewise, indicates a cons cell or
3543 current_buffer->overlays_before or overlays_after, depending
3544 which loop we're in. */
3545 struct Lisp_Overlay
*tail
, *parent
;
3546 int startpos
, endpos
;
3548 /* This algorithm shifts links around instead of consing and GCing.
3549 The loop invariant is that before_list (resp. after_list) is a
3550 well-formed list except that its last element, the CDR of beforep
3551 (resp. afterp) if beforep (afterp) isn't nil or before_list
3552 (after_list) if it is, is still uninitialized. So it's not a bug
3553 that before_list isn't initialized, although it may look
3555 for (parent
= NULL
, tail
= current_buffer
->overlays_before
; tail
;)
3557 XSETMISC (overlay
, tail
);
3559 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3560 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3562 /* If the overlay is backwards, make it empty. */
3563 if (endpos
< startpos
)
3566 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3574 || (startpos
>= start
&& startpos
< end
))
3576 /* Add it to the end of the wrong list. Later on,
3577 recenter_overlay_lists will move it to the right place. */
3578 if (endpos
< current_buffer
->overlay_center
)
3583 afterp
->next
= tail
;
3591 beforep
->next
= tail
;
3595 current_buffer
->overlays_before
= tail
->next
;
3597 parent
->next
= tail
->next
;
3601 parent
= tail
, tail
= parent
->next
;
3603 for (parent
= NULL
, tail
= current_buffer
->overlays_after
; tail
;)
3605 XSETMISC (overlay
, tail
);
3607 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3608 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3610 /* If the overlay is backwards, make it empty. */
3611 if (endpos
< startpos
)
3614 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3618 if (startpos
>= end
)
3621 if (startpos
>= start
3622 || (endpos
>= start
&& endpos
< end
))
3624 if (endpos
< current_buffer
->overlay_center
)
3629 afterp
->next
= tail
;
3637 beforep
->next
= tail
;
3641 current_buffer
->overlays_after
= tail
->next
;
3643 parent
->next
= tail
->next
;
3647 parent
= tail
, tail
= parent
->next
;
3650 /* Splice the constructed (wrong) lists into the buffer's lists,
3651 and let the recenter function make it sane again. */
3654 beforep
->next
= current_buffer
->overlays_before
;
3655 current_buffer
->overlays_before
= before_list
;
3657 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3661 afterp
->next
= current_buffer
->overlays_after
;
3662 current_buffer
->overlays_after
= after_list
;
3664 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3667 /* We have two types of overlay: the one whose ending marker is
3668 after-insertion-marker (this is the usual case) and the one whose
3669 ending marker is before-insertion-marker. When `overlays_before'
3670 contains overlays of the latter type and the former type in this
3671 order and both overlays end at inserting position, inserting a text
3672 increases only the ending marker of the latter type, which results
3673 in incorrect ordering of `overlays_before'.
3675 This function fixes ordering of overlays in the slot
3676 `overlays_before' of the buffer *BP. Before the insertion, `point'
3677 was at PREV, and now is at POS. */
3680 fix_overlays_before (bp
, prev
, pos
)
3682 EMACS_INT prev
, pos
;
3684 /* If parent is nil, replace overlays_before; otherwise, parent->next. */
3685 struct Lisp_Overlay
*tail
= bp
->overlays_before
, *parent
= NULL
, *right_pair
;
3689 /* After the insertion, the several overlays may be in incorrect
3690 order. The possibility is that, in the list `overlays_before',
3691 an overlay which ends at POS appears after an overlay which ends
3692 at PREV. Since POS is greater than PREV, we must fix the
3693 ordering of these overlays, by moving overlays ends at POS before
3694 the overlays ends at PREV. */
3696 /* At first, find a place where disordered overlays should be linked
3697 in. It is where an overlay which end before POS exists. (i.e. an
3698 overlay whose ending marker is after-insertion-marker if disorder
3701 && (XSETMISC (tem
, tail
),
3702 (end
= OVERLAY_POSITION (OVERLAY_END (tem
))) >= pos
))
3708 /* If we don't find such an overlay,
3709 or the found one ends before PREV,
3710 or the found one is the last one in the list,
3711 we don't have to fix anything. */
3712 if (!tail
|| end
< prev
|| !tail
->next
)
3715 right_pair
= parent
;
3719 /* Now, end position of overlays in the list TAIL should be before
3720 or equal to PREV. In the loop, an overlay which ends at POS is
3721 moved ahead to the place indicated by the CDR of RIGHT_PAIR. If
3722 we found an overlay which ends before PREV, the remaining
3723 overlays are in correct order. */
3726 XSETMISC (tem
, tail
);
3727 end
= OVERLAY_POSITION (OVERLAY_END (tem
));
3730 { /* This overlay is disordered. */
3731 struct Lisp_Overlay
*found
= tail
;
3733 /* Unlink the found overlay. */
3735 parent
->next
= tail
;
3736 /* Move an overlay at RIGHT_PLACE to the next of the found one,
3737 and link it into the right place. */
3740 found
->next
= bp
->overlays_before
;
3741 bp
->overlays_before
= found
;
3745 found
->next
= right_pair
->next
;
3746 right_pair
->next
= found
;
3749 else if (end
== prev
)
3754 else /* No more disordered overlay. */
3759 DEFUN ("overlayp", Foverlayp
, Soverlayp
, 1, 1, 0,
3760 doc
: /* Return t if OBJECT is an overlay. */)
3764 return (OVERLAYP (object
) ? Qt
: Qnil
);
3767 DEFUN ("make-overlay", Fmake_overlay
, Smake_overlay
, 2, 5, 0,
3768 doc
: /* Create a new overlay with range BEG to END in BUFFER.
3769 If omitted, BUFFER defaults to the current buffer.
3770 BEG and END may be integers or markers.
3771 The fourth arg FRONT-ADVANCE, if non-nil, makes the marker
3772 for the front of the overlay advance when text is inserted there
3773 \(which means the text *is not* included in the overlay).
3774 The fifth arg REAR-ADVANCE, if non-nil, makes the marker
3775 for the rear of the overlay advance when text is inserted there
3776 \(which means the text *is* included in the overlay). */)
3777 (beg
, end
, buffer
, front_advance
, rear_advance
)
3778 Lisp_Object beg
, end
, buffer
;
3779 Lisp_Object front_advance
, rear_advance
;
3781 Lisp_Object overlay
;
3785 XSETBUFFER (buffer
, current_buffer
);
3787 CHECK_BUFFER (buffer
);
3789 && ! EQ (Fmarker_buffer (beg
), buffer
))
3790 error ("Marker points into wrong buffer");
3792 && ! EQ (Fmarker_buffer (end
), buffer
))
3793 error ("Marker points into wrong buffer");
3795 CHECK_NUMBER_COERCE_MARKER (beg
);
3796 CHECK_NUMBER_COERCE_MARKER (end
);
3798 if (XINT (beg
) > XINT (end
))
3801 temp
= beg
; beg
= end
; end
= temp
;
3804 b
= XBUFFER (buffer
);
3806 beg
= Fset_marker (Fmake_marker (), beg
, buffer
);
3807 end
= Fset_marker (Fmake_marker (), end
, buffer
);
3809 if (!NILP (front_advance
))
3810 XMARKER (beg
)->insertion_type
= 1;
3811 if (!NILP (rear_advance
))
3812 XMARKER (end
)->insertion_type
= 1;
3814 overlay
= allocate_misc ();
3815 XMISCTYPE (overlay
) = Lisp_Misc_Overlay
;
3816 XOVERLAY (overlay
)->start
= beg
;
3817 XOVERLAY (overlay
)->end
= end
;
3818 XOVERLAY (overlay
)->plist
= Qnil
;
3819 XOVERLAY (overlay
)->next
= NULL
;
3821 /* Put the new overlay on the wrong list. */
3822 end
= OVERLAY_END (overlay
);
3823 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
3825 if (b
->overlays_after
)
3826 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3827 b
->overlays_after
= XOVERLAY (overlay
);
3831 if (b
->overlays_before
)
3832 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3833 b
->overlays_before
= XOVERLAY (overlay
);
3836 /* This puts it in the right list, and in the right order. */
3837 recenter_overlay_lists (b
, b
->overlay_center
);
3839 /* We don't need to redisplay the region covered by the overlay, because
3840 the overlay has no properties at the moment. */
3845 /* Mark a section of BUF as needing redisplay because of overlays changes. */
3848 modify_overlay (buf
, start
, end
)
3850 EMACS_INT start
, end
;
3859 BUF_COMPUTE_UNCHANGED (buf
, start
, end
);
3861 /* If this is a buffer not in the selected window,
3862 we must do other windows. */
3863 if (buf
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
3864 windows_or_buffers_changed
= 1;
3865 /* If multiple windows show this buffer, we must do other windows. */
3866 else if (buffer_shared
> 1)
3867 windows_or_buffers_changed
= 1;
3868 /* If we modify an overlay at the end of the buffer, we cannot
3869 be sure that window end is still valid. */
3870 else if (end
>= ZV
&& start
<= ZV
)
3871 windows_or_buffers_changed
= 1;
3873 ++BUF_OVERLAY_MODIFF (buf
);
3877 Lisp_Object
Fdelete_overlay ();
3879 static struct Lisp_Overlay
*
3880 unchain_overlay (list
, overlay
)
3881 struct Lisp_Overlay
*list
, *overlay
;
3883 struct Lisp_Overlay
*tmp
, *prev
;
3884 for (tmp
= list
, prev
= NULL
; tmp
; prev
= tmp
, tmp
= tmp
->next
)
3888 prev
->next
= tmp
->next
;
3891 overlay
->next
= NULL
;
3897 DEFUN ("move-overlay", Fmove_overlay
, Smove_overlay
, 3, 4, 0,
3898 doc
: /* Set the endpoints of OVERLAY to BEG and END in BUFFER.
3899 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.
3900 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current
3902 (overlay
, beg
, end
, buffer
)
3903 Lisp_Object overlay
, beg
, end
, buffer
;
3905 struct buffer
*b
, *ob
;
3906 Lisp_Object obuffer
;
3907 int count
= SPECPDL_INDEX ();
3909 CHECK_OVERLAY (overlay
);
3911 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3913 XSETBUFFER (buffer
, current_buffer
);
3914 CHECK_BUFFER (buffer
);
3917 && ! EQ (Fmarker_buffer (beg
), buffer
))
3918 error ("Marker points into wrong buffer");
3920 && ! EQ (Fmarker_buffer (end
), buffer
))
3921 error ("Marker points into wrong buffer");
3923 CHECK_NUMBER_COERCE_MARKER (beg
);
3924 CHECK_NUMBER_COERCE_MARKER (end
);
3926 if (XINT (beg
) == XINT (end
) && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
3927 return Fdelete_overlay (overlay
);
3929 if (XINT (beg
) > XINT (end
))
3932 temp
= beg
; beg
= end
; end
= temp
;
3935 specbind (Qinhibit_quit
, Qt
);
3937 obuffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3938 b
= XBUFFER (buffer
);
3939 ob
= BUFFERP (obuffer
) ? XBUFFER (obuffer
) : (struct buffer
*) 0;
3941 /* If the overlay has changed buffers, do a thorough redisplay. */
3942 if (!EQ (buffer
, obuffer
))
3944 /* Redisplay where the overlay was. */
3945 if (!NILP (obuffer
))
3950 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3951 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3953 modify_overlay (ob
, o_beg
, o_end
);
3956 /* Redisplay where the overlay is going to be. */
3957 modify_overlay (b
, XINT (beg
), XINT (end
));
3960 /* Redisplay the area the overlay has just left, or just enclosed. */
3964 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3965 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3967 if (o_beg
== XINT (beg
))
3968 modify_overlay (b
, o_end
, XINT (end
));
3969 else if (o_end
== XINT (end
))
3970 modify_overlay (b
, o_beg
, XINT (beg
));
3973 if (XINT (beg
) < o_beg
) o_beg
= XINT (beg
);
3974 if (XINT (end
) > o_end
) o_end
= XINT (end
);
3975 modify_overlay (b
, o_beg
, o_end
);
3979 if (!NILP (obuffer
))
3982 = unchain_overlay (ob
->overlays_before
, XOVERLAY (overlay
));
3984 = unchain_overlay (ob
->overlays_after
, XOVERLAY (overlay
));
3985 eassert (XOVERLAY (overlay
)->next
== NULL
);
3988 Fset_marker (OVERLAY_START (overlay
), beg
, buffer
);
3989 Fset_marker (OVERLAY_END (overlay
), end
, buffer
);
3991 /* Put the overlay on the wrong list. */
3992 end
= OVERLAY_END (overlay
);
3993 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
3995 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3996 b
->overlays_after
= XOVERLAY (overlay
);
4000 XOVERLAY (overlay
)->next
= b
->overlays_before
;
4001 b
->overlays_before
= XOVERLAY (overlay
);
4004 /* This puts it in the right list, and in the right order. */
4005 recenter_overlay_lists (b
, b
->overlay_center
);
4007 return unbind_to (count
, overlay
);
4010 DEFUN ("delete-overlay", Fdelete_overlay
, Sdelete_overlay
, 1, 1, 0,
4011 doc
: /* Delete the overlay OVERLAY from its buffer. */)
4013 Lisp_Object overlay
;
4017 int count
= SPECPDL_INDEX ();
4019 CHECK_OVERLAY (overlay
);
4021 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4025 b
= XBUFFER (buffer
);
4026 specbind (Qinhibit_quit
, Qt
);
4028 b
->overlays_before
= unchain_overlay (b
->overlays_before
,XOVERLAY (overlay
));
4029 b
->overlays_after
= unchain_overlay (b
->overlays_after
, XOVERLAY (overlay
));
4030 eassert (XOVERLAY (overlay
)->next
== NULL
);
4032 marker_position (OVERLAY_START (overlay
)),
4033 marker_position (OVERLAY_END (overlay
)));
4034 Fset_marker (OVERLAY_START (overlay
), Qnil
, Qnil
);
4035 Fset_marker (OVERLAY_END (overlay
), Qnil
, Qnil
);
4037 /* When deleting an overlay with before or after strings, turn off
4038 display optimizations for the affected buffer, on the basis that
4039 these strings may contain newlines. This is easier to do than to
4040 check for that situation during redisplay. */
4041 if (!windows_or_buffers_changed
4042 && (!NILP (Foverlay_get (overlay
, Qbefore_string
))
4043 || !NILP (Foverlay_get (overlay
, Qafter_string
))))
4044 b
->prevent_redisplay_optimizations_p
= 1;
4046 return unbind_to (count
, Qnil
);
4049 /* Overlay dissection functions. */
4051 DEFUN ("overlay-start", Foverlay_start
, Soverlay_start
, 1, 1, 0,
4052 doc
: /* Return the position at which OVERLAY starts. */)
4054 Lisp_Object overlay
;
4056 CHECK_OVERLAY (overlay
);
4058 return (Fmarker_position (OVERLAY_START (overlay
)));
4061 DEFUN ("overlay-end", Foverlay_end
, Soverlay_end
, 1, 1, 0,
4062 doc
: /* Return the position at which OVERLAY ends. */)
4064 Lisp_Object overlay
;
4066 CHECK_OVERLAY (overlay
);
4068 return (Fmarker_position (OVERLAY_END (overlay
)));
4071 DEFUN ("overlay-buffer", Foverlay_buffer
, Soverlay_buffer
, 1, 1, 0,
4072 doc
: /* Return the buffer OVERLAY belongs to.
4073 Return nil if OVERLAY has been deleted. */)
4075 Lisp_Object overlay
;
4077 CHECK_OVERLAY (overlay
);
4079 return Fmarker_buffer (OVERLAY_START (overlay
));
4082 DEFUN ("overlay-properties", Foverlay_properties
, Soverlay_properties
, 1, 1, 0,
4083 doc
: /* Return a list of the properties on OVERLAY.
4084 This is a copy of OVERLAY's plist; modifying its conses has no effect on
4087 Lisp_Object overlay
;
4089 CHECK_OVERLAY (overlay
);
4091 return Fcopy_sequence (XOVERLAY (overlay
)->plist
);
4095 DEFUN ("overlays-at", Foverlays_at
, Soverlays_at
, 1, 1, 0,
4096 doc
: /* Return a list of the overlays that contain the character at POS. */)
4101 Lisp_Object
*overlay_vec
;
4105 CHECK_NUMBER_COERCE_MARKER (pos
);
4108 /* We can't use alloca here because overlays_at can call xrealloc. */
4109 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
4111 /* Put all the overlays we want in a vector in overlay_vec.
4112 Store the length in len. */
4113 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4114 (EMACS_INT
*) 0, (EMACS_INT
*) 0, 0);
4116 /* Make a list of them all. */
4117 result
= Flist (noverlays
, overlay_vec
);
4119 xfree (overlay_vec
);
4123 DEFUN ("overlays-in", Foverlays_in
, Soverlays_in
, 2, 2, 0,
4124 doc
: /* Return a list of the overlays that overlap the region BEG ... END.
4125 Overlap means that at least one character is contained within the overlay
4126 and also contained within the specified region.
4127 Empty overlays are included in the result if they are located at BEG,
4128 between BEG and END, or at END provided END denotes the position at the
4129 end of the buffer. */)
4131 Lisp_Object beg
, end
;
4134 Lisp_Object
*overlay_vec
;
4138 CHECK_NUMBER_COERCE_MARKER (beg
);
4139 CHECK_NUMBER_COERCE_MARKER (end
);
4142 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
4144 /* Put all the overlays we want in a vector in overlay_vec.
4145 Store the length in len. */
4146 noverlays
= overlays_in (XINT (beg
), XINT (end
), 1, &overlay_vec
, &len
,
4147 (int *) 0, (int *) 0);
4149 /* Make a list of them all. */
4150 result
= Flist (noverlays
, overlay_vec
);
4152 xfree (overlay_vec
);
4156 DEFUN ("next-overlay-change", Fnext_overlay_change
, Snext_overlay_change
,
4158 doc
: /* Return the next position after POS where an overlay starts or ends.
4159 If there are no overlay boundaries from POS to (point-max),
4160 the value is (point-max). */)
4166 Lisp_Object
*overlay_vec
;
4170 CHECK_NUMBER_COERCE_MARKER (pos
);
4173 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
4175 /* Put all the overlays we want in a vector in overlay_vec.
4176 Store the length in len.
4177 endpos gets the position where the next overlay starts. */
4178 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4179 &endpos
, (EMACS_INT
*) 0, 1);
4181 /* If any of these overlays ends before endpos,
4182 use its ending point instead. */
4183 for (i
= 0; i
< noverlays
; i
++)
4188 oend
= OVERLAY_END (overlay_vec
[i
]);
4189 oendpos
= OVERLAY_POSITION (oend
);
4190 if (oendpos
< endpos
)
4194 xfree (overlay_vec
);
4195 return make_number (endpos
);
4198 DEFUN ("previous-overlay-change", Fprevious_overlay_change
,
4199 Sprevious_overlay_change
, 1, 1, 0,
4200 doc
: /* Return the previous position before POS where an overlay starts or ends.
4201 If there are no overlay boundaries from (point-min) to POS,
4202 the value is (point-min). */)
4208 Lisp_Object
*overlay_vec
;
4211 CHECK_NUMBER_COERCE_MARKER (pos
);
4213 /* At beginning of buffer, we know the answer;
4214 avoid bug subtracting 1 below. */
4215 if (XINT (pos
) == BEGV
)
4219 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
4221 /* Put all the overlays we want in a vector in overlay_vec.
4222 Store the length in len.
4223 prevpos gets the position of the previous change. */
4224 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4225 (EMACS_INT
*) 0, &prevpos
, 1);
4227 xfree (overlay_vec
);
4228 return make_number (prevpos
);
4231 /* These functions are for debugging overlays. */
4233 DEFUN ("overlay-lists", Foverlay_lists
, Soverlay_lists
, 0, 0, 0,
4234 doc
: /* Return a pair of lists giving all the overlays of the current buffer.
4235 The car has all the overlays before the overlay center;
4236 the cdr has all the overlays after the overlay center.
4237 Recentering overlays moves overlays between these lists.
4238 The lists you get are copies, so that changing them has no effect.
4239 However, the overlays you get are the real objects that the buffer uses. */)
4242 struct Lisp_Overlay
*ol
;
4243 Lisp_Object before
= Qnil
, after
= Qnil
, tmp
;
4244 for (ol
= current_buffer
->overlays_before
; ol
; ol
= ol
->next
)
4247 before
= Fcons (tmp
, before
);
4249 for (ol
= current_buffer
->overlays_after
; ol
; ol
= ol
->next
)
4252 after
= Fcons (tmp
, after
);
4254 return Fcons (Fnreverse (before
), Fnreverse (after
));
4257 DEFUN ("overlay-recenter", Foverlay_recenter
, Soverlay_recenter
, 1, 1, 0,
4258 doc
: /* Recenter the overlays of the current buffer around position POS.
4259 That makes overlay lookup faster for positions near POS (but perhaps slower
4260 for positions far away from POS). */)
4264 CHECK_NUMBER_COERCE_MARKER (pos
);
4266 recenter_overlay_lists (current_buffer
, XINT (pos
));
4270 DEFUN ("overlay-get", Foverlay_get
, Soverlay_get
, 2, 2, 0,
4271 doc
: /* Get the property of overlay OVERLAY with property name PROP. */)
4273 Lisp_Object overlay
, prop
;
4275 CHECK_OVERLAY (overlay
);
4276 return lookup_char_property (XOVERLAY (overlay
)->plist
, prop
, 0);
4279 DEFUN ("overlay-put", Foverlay_put
, Soverlay_put
, 3, 3, 0,
4280 doc
: /* Set one property of overlay OVERLAY: give property PROP value VALUE. */)
4281 (overlay
, prop
, value
)
4282 Lisp_Object overlay
, prop
, value
;
4284 Lisp_Object tail
, buffer
;
4287 CHECK_OVERLAY (overlay
);
4289 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4291 for (tail
= XOVERLAY (overlay
)->plist
;
4292 CONSP (tail
) && CONSP (XCDR (tail
));
4293 tail
= XCDR (XCDR (tail
)))
4294 if (EQ (XCAR (tail
), prop
))
4296 changed
= !EQ (XCAR (XCDR (tail
)), value
);
4297 XSETCAR (XCDR (tail
), value
);
4300 /* It wasn't in the list, so add it to the front. */
4301 changed
= !NILP (value
);
4302 XOVERLAY (overlay
)->plist
4303 = Fcons (prop
, Fcons (value
, XOVERLAY (overlay
)->plist
));
4305 if (! NILP (buffer
))
4308 modify_overlay (XBUFFER (buffer
),
4309 marker_position (OVERLAY_START (overlay
)),
4310 marker_position (OVERLAY_END (overlay
)));
4311 if (EQ (prop
, Qevaporate
) && ! NILP (value
)
4312 && (OVERLAY_POSITION (OVERLAY_START (overlay
))
4313 == OVERLAY_POSITION (OVERLAY_END (overlay
))))
4314 Fdelete_overlay (overlay
);
4320 /* Subroutine of report_overlay_modification. */
4322 /* Lisp vector holding overlay hook functions to call.
4323 Vector elements come in pairs.
4324 Each even-index element is a list of hook functions.
4325 The following odd-index element is the overlay they came from.
4327 Before the buffer change, we fill in this vector
4328 as we call overlay hook functions.
4329 After the buffer change, we get the functions to call from this vector.
4330 This way we always call the same functions before and after the change. */
4331 static Lisp_Object last_overlay_modification_hooks
;
4333 /* Number of elements actually used in last_overlay_modification_hooks. */
4334 static int last_overlay_modification_hooks_used
;
4336 /* Add one functionlist/overlay pair
4337 to the end of last_overlay_modification_hooks. */
4340 add_overlay_mod_hooklist (functionlist
, overlay
)
4341 Lisp_Object functionlist
, overlay
;
4343 int oldsize
= XVECTOR (last_overlay_modification_hooks
)->size
;
4345 if (last_overlay_modification_hooks_used
== oldsize
)
4346 last_overlay_modification_hooks
= larger_vector
4347 (last_overlay_modification_hooks
, oldsize
* 2, Qnil
);
4348 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4349 functionlist
); last_overlay_modification_hooks_used
++;
4350 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4351 overlay
); last_overlay_modification_hooks_used
++;
4354 /* Run the modification-hooks of overlays that include
4355 any part of the text in START to END.
4356 If this change is an insertion, also
4357 run the insert-before-hooks of overlay starting at END,
4358 and the insert-after-hooks of overlay ending at START.
4360 This is called both before and after the modification.
4361 AFTER is nonzero when we call after the modification.
4363 ARG1, ARG2, ARG3 are arguments to pass to the hook functions.
4364 When AFTER is nonzero, they are the start position,
4365 the position after the inserted new text,
4366 and the length of deleted or replaced old text. */
4369 report_overlay_modification (start
, end
, after
, arg1
, arg2
, arg3
)
4370 Lisp_Object start
, end
;
4372 Lisp_Object arg1
, arg2
, arg3
;
4374 Lisp_Object prop
, overlay
;
4375 struct Lisp_Overlay
*tail
;
4376 /* 1 if this change is an insertion. */
4377 int insertion
= (after
? XFASTINT (arg3
) == 0 : EQ (start
, end
));
4378 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4383 /* We used to run the functions as soon as we found them and only register
4384 them in last_overlay_modification_hooks for the purpose of the `after'
4385 case. But running elisp code as we traverse the list of overlays is
4386 painful because the list can be modified by the elisp code so we had to
4387 copy at several places. We now simply do a read-only traversal that
4388 only collects the functions to run and we run them afterwards. It's
4389 simpler, especially since all the code was already there. -stef */
4393 /* We are being called before a change.
4394 Scan the overlays to find the functions to call. */
4395 last_overlay_modification_hooks_used
= 0;
4396 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4398 int startpos
, endpos
;
4399 Lisp_Object ostart
, oend
;
4401 XSETMISC (overlay
, tail
);
4403 ostart
= OVERLAY_START (overlay
);
4404 oend
= OVERLAY_END (overlay
);
4405 endpos
= OVERLAY_POSITION (oend
);
4406 if (XFASTINT (start
) > endpos
)
4408 startpos
= OVERLAY_POSITION (ostart
);
4409 if (insertion
&& (XFASTINT (start
) == startpos
4410 || XFASTINT (end
) == startpos
))
4412 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4414 add_overlay_mod_hooklist (prop
, overlay
);
4416 if (insertion
&& (XFASTINT (start
) == endpos
4417 || XFASTINT (end
) == endpos
))
4419 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4421 add_overlay_mod_hooklist (prop
, overlay
);
4423 /* Test for intersecting intervals. This does the right thing
4424 for both insertion and deletion. */
4425 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4427 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4429 add_overlay_mod_hooklist (prop
, overlay
);
4433 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4435 int startpos
, endpos
;
4436 Lisp_Object ostart
, oend
;
4438 XSETMISC (overlay
, tail
);
4440 ostart
= OVERLAY_START (overlay
);
4441 oend
= OVERLAY_END (overlay
);
4442 startpos
= OVERLAY_POSITION (ostart
);
4443 endpos
= OVERLAY_POSITION (oend
);
4444 if (XFASTINT (end
) < startpos
)
4446 if (insertion
&& (XFASTINT (start
) == startpos
4447 || XFASTINT (end
) == startpos
))
4449 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4451 add_overlay_mod_hooklist (prop
, overlay
);
4453 if (insertion
&& (XFASTINT (start
) == endpos
4454 || XFASTINT (end
) == endpos
))
4456 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4458 add_overlay_mod_hooklist (prop
, overlay
);
4460 /* Test for intersecting intervals. This does the right thing
4461 for both insertion and deletion. */
4462 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4464 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4466 add_overlay_mod_hooklist (prop
, overlay
);
4471 GCPRO4 (overlay
, arg1
, arg2
, arg3
);
4473 /* Call the functions recorded in last_overlay_modification_hooks.
4474 First copy the vector contents, in case some of these hooks
4475 do subsequent modification of the buffer. */
4476 int size
= last_overlay_modification_hooks_used
;
4477 Lisp_Object
*copy
= (Lisp_Object
*) alloca (size
* sizeof (Lisp_Object
));
4480 bcopy (XVECTOR (last_overlay_modification_hooks
)->contents
,
4481 copy
, size
* sizeof (Lisp_Object
));
4483 gcpro1
.nvars
= size
;
4485 for (i
= 0; i
< size
;)
4487 Lisp_Object prop
, overlay
;
4489 overlay
= copy
[i
++];
4490 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
4497 call_overlay_mod_hooks (list
, overlay
, after
, arg1
, arg2
, arg3
)
4498 Lisp_Object list
, overlay
;
4500 Lisp_Object arg1
, arg2
, arg3
;
4502 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4504 GCPRO4 (list
, arg1
, arg2
, arg3
);
4506 while (CONSP (list
))
4509 call4 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
);
4511 call5 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
, arg3
);
4517 /* Delete any zero-sized overlays at position POS, if the `evaporate'
4520 evaporate_overlays (pos
)
4523 Lisp_Object overlay
, hit_list
;
4524 struct Lisp_Overlay
*tail
;
4527 if (pos
<= current_buffer
->overlay_center
)
4528 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4531 XSETMISC (overlay
, tail
);
4532 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4535 if (endpos
== pos
&& OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
4536 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4537 hit_list
= Fcons (overlay
, hit_list
);
4540 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4543 XSETMISC (overlay
, tail
);
4544 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4547 if (startpos
== pos
&& OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
4548 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4549 hit_list
= Fcons (overlay
, hit_list
);
4551 for (; CONSP (hit_list
); hit_list
= XCDR (hit_list
))
4552 Fdelete_overlay (XCAR (hit_list
));
4555 /* Somebody has tried to store a value with an unacceptable type
4556 in the slot with offset OFFSET. */
4559 buffer_slot_type_mismatch (newval
, type
)
4563 Lisp_Object predicate
;
4567 case Lisp_Int
: predicate
= Qintegerp
; break;
4568 case Lisp_String
: predicate
= Qstringp
; break;
4569 case Lisp_Symbol
: predicate
= Qsymbolp
; break;
4573 wrong_type_argument (predicate
, newval
);
4577 /***********************************************************************
4578 Allocation with mmap
4579 ***********************************************************************/
4581 #ifdef USE_MMAP_FOR_BUFFERS
4583 #include <sys/types.h>
4584 #include <sys/mman.h>
4587 #ifdef MAP_ANONYMOUS
4588 #define MAP_ANON MAP_ANONYMOUS
4595 #define MAP_FAILED ((void *) -1)
4608 /* Memory is allocated in regions which are mapped using mmap(2).
4609 The current implementation lets the system select mapped
4610 addresses; we're not using MAP_FIXED in general, except when
4611 trying to enlarge regions.
4613 Each mapped region starts with a mmap_region structure, the user
4614 area starts after that structure, aligned to MEM_ALIGN.
4616 +-----------------------+
4617 | struct mmap_info + |
4619 +-----------------------+
4623 +-----------------------+ */
4627 /* User-specified size. */
4628 size_t nbytes_specified
;
4630 /* Number of bytes mapped */
4631 size_t nbytes_mapped
;
4633 /* Pointer to the location holding the address of the memory
4634 allocated with the mmap'd block. The variable actually points
4635 after this structure. */
4638 /* Next and previous in list of all mmap'd regions. */
4639 struct mmap_region
*next
, *prev
;
4642 /* Doubly-linked list of mmap'd regions. */
4644 static struct mmap_region
*mmap_regions
;
4646 /* File descriptor for mmap. If we don't have anonymous mapping,
4647 /dev/zero will be opened on it. */
4651 /* Temporary storage for mmap_set_vars, see there. */
4653 static struct mmap_region
*mmap_regions_1
;
4654 static int mmap_fd_1
;
4656 /* Page size on this system. */
4658 static int mmap_page_size
;
4660 /* 1 means mmap has been intialized. */
4662 static int mmap_initialized_p
;
4664 /* Value is X rounded up to the next multiple of N. */
4666 #define ROUND(X, N) (((X) + (N) - 1) / (N) * (N))
4668 /* Size of mmap_region structure plus padding. */
4670 #define MMAP_REGION_STRUCT_SIZE \
4671 ROUND (sizeof (struct mmap_region), MEM_ALIGN)
4673 /* Given a pointer P to the start of the user-visible part of a mapped
4674 region, return a pointer to the start of the region. */
4676 #define MMAP_REGION(P) \
4677 ((struct mmap_region *) ((char *) (P) - MMAP_REGION_STRUCT_SIZE))
4679 /* Given a pointer P to the start of a mapped region, return a pointer
4680 to the start of the user-visible part of the region. */
4682 #define MMAP_USER_AREA(P) \
4683 ((POINTER_TYPE *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
4685 #define MEM_ALIGN sizeof (double)
4687 /* Predicate returning true if part of the address range [START .. END]
4688 is currently mapped. Used to prevent overwriting an existing
4691 Default is to conservativly assume the address range is occupied by
4692 something else. This can be overridden by system configuration
4693 files if system-specific means to determine this exists. */
4695 #ifndef MMAP_ALLOCATED_P
4696 #define MMAP_ALLOCATED_P(start, end) 1
4699 /* Function prototypes. */
4701 static int mmap_free_1
P_ ((struct mmap_region
*));
4702 static int mmap_enlarge
P_ ((struct mmap_region
*, int));
4703 static struct mmap_region
*mmap_find
P_ ((POINTER_TYPE
*, POINTER_TYPE
*));
4704 static POINTER_TYPE
*mmap_alloc
P_ ((POINTER_TYPE
**, size_t));
4705 static POINTER_TYPE
*mmap_realloc
P_ ((POINTER_TYPE
**, size_t));
4706 static void mmap_free
P_ ((POINTER_TYPE
**ptr
));
4707 static void mmap_init
P_ ((void));
4710 /* Return a region overlapping address range START...END, or null if
4711 none. END is not including, i.e. the last byte in the range
4714 static struct mmap_region
*
4715 mmap_find (start
, end
)
4716 POINTER_TYPE
*start
, *end
;
4718 struct mmap_region
*r
;
4719 char *s
= (char *) start
, *e
= (char *) end
;
4721 for (r
= mmap_regions
; r
; r
= r
->next
)
4723 char *rstart
= (char *) r
;
4724 char *rend
= rstart
+ r
->nbytes_mapped
;
4726 if (/* First byte of range, i.e. START, in this region? */
4727 (s
>= rstart
&& s
< rend
)
4728 /* Last byte of range, i.e. END - 1, in this region? */
4729 || (e
> rstart
&& e
<= rend
)
4730 /* First byte of this region in the range? */
4731 || (rstart
>= s
&& rstart
< e
)
4732 /* Last byte of this region in the range? */
4733 || (rend
> s
&& rend
<= e
))
4741 /* Unmap a region. P is a pointer to the start of the user-araa of
4742 the region. Value is non-zero if successful. */
4746 struct mmap_region
*r
;
4749 r
->next
->prev
= r
->prev
;
4751 r
->prev
->next
= r
->next
;
4753 mmap_regions
= r
->next
;
4755 if (munmap ((POINTER_TYPE
*) r
, r
->nbytes_mapped
) == -1)
4757 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4765 /* Enlarge region R by NPAGES pages. NPAGES < 0 means shrink R.
4766 Value is non-zero if successful. */
4769 mmap_enlarge (r
, npages
)
4770 struct mmap_region
*r
;
4773 char *region_end
= (char *) r
+ r
->nbytes_mapped
;
4779 /* Unmap pages at the end of the region. */
4780 nbytes
= - npages
* mmap_page_size
;
4781 if (munmap (region_end
- nbytes
, nbytes
) == -1)
4782 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4785 r
->nbytes_mapped
-= nbytes
;
4789 else if (npages
> 0)
4791 nbytes
= npages
* mmap_page_size
;
4793 /* Try to map additional pages at the end of the region. We
4794 cannot do this if the address range is already occupied by
4795 something else because mmap deletes any previous mapping.
4796 I'm not sure this is worth doing, let's see. */
4797 if (!MMAP_ALLOCATED_P (region_end
, region_end
+ nbytes
))
4801 p
= mmap (region_end
, nbytes
, PROT_READ
| PROT_WRITE
,
4802 MAP_ANON
| MAP_PRIVATE
| MAP_FIXED
, mmap_fd
, 0);
4803 if (p
== MAP_FAILED
)
4804 ; /* fprintf (stderr, "mmap: %s\n", emacs_strerror (errno)); */
4805 else if (p
!= (POINTER_TYPE
*) region_end
)
4807 /* Kernels are free to choose a different address. In
4808 that case, unmap what we've mapped above; we have
4810 if (munmap (p
, nbytes
) == -1)
4811 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4815 r
->nbytes_mapped
+= nbytes
;
4825 /* Set or reset variables holding references to mapped regions. If
4826 RESTORE_P is zero, set all variables to null. If RESTORE_P is
4827 non-zero, set all variables to the start of the user-areas
4830 This function is called from Fdump_emacs to ensure that the dumped
4831 Emacs doesn't contain references to memory that won't be mapped
4832 when Emacs starts. */
4835 mmap_set_vars (restore_p
)
4838 struct mmap_region
*r
;
4842 mmap_regions
= mmap_regions_1
;
4843 mmap_fd
= mmap_fd_1
;
4844 for (r
= mmap_regions
; r
; r
= r
->next
)
4845 *r
->var
= MMAP_USER_AREA (r
);
4849 for (r
= mmap_regions
; r
; r
= r
->next
)
4851 mmap_regions_1
= mmap_regions
;
4852 mmap_regions
= NULL
;
4853 mmap_fd_1
= mmap_fd
;
4859 /* Allocate a block of storage large enough to hold NBYTES bytes of
4860 data. A pointer to the data is returned in *VAR. VAR is thus the
4861 address of some variable which will use the data area.
4863 The allocation of 0 bytes is valid.
4865 If we can't allocate the necessary memory, set *VAR to null, and
4868 static POINTER_TYPE
*
4869 mmap_alloc (var
, nbytes
)
4878 map
= ROUND (nbytes
+ MMAP_REGION_STRUCT_SIZE
, mmap_page_size
);
4879 p
= mmap (NULL
, map
, PROT_READ
| PROT_WRITE
, MAP_ANON
| MAP_PRIVATE
,
4882 if (p
== MAP_FAILED
)
4884 if (errno
!= ENOMEM
)
4885 fprintf (stderr
, "mmap: %s\n", emacs_strerror (errno
));
4890 struct mmap_region
*r
= (struct mmap_region
*) p
;
4892 r
->nbytes_specified
= nbytes
;
4893 r
->nbytes_mapped
= map
;
4896 r
->next
= mmap_regions
;
4901 p
= MMAP_USER_AREA (p
);
4908 /* Given a pointer at address VAR to data allocated with mmap_alloc,
4909 resize it to size NBYTES. Change *VAR to reflect the new block,
4910 and return this value. If more memory cannot be allocated, then
4911 leave *VAR unchanged, and return null. */
4913 static POINTER_TYPE
*
4914 mmap_realloc (var
, nbytes
)
4918 POINTER_TYPE
*result
;
4923 result
= mmap_alloc (var
, nbytes
);
4924 else if (nbytes
== 0)
4927 result
= mmap_alloc (var
, nbytes
);
4931 struct mmap_region
*r
= MMAP_REGION (*var
);
4932 size_t room
= r
->nbytes_mapped
- MMAP_REGION_STRUCT_SIZE
;
4937 POINTER_TYPE
*old_ptr
= *var
;
4939 /* Try to map additional pages at the end of the region.
4940 If that fails, allocate a new region, copy data
4941 from the old region, then free it. */
4942 if (mmap_enlarge (r
, (ROUND (nbytes
- room
, mmap_page_size
)
4945 r
->nbytes_specified
= nbytes
;
4946 *var
= result
= old_ptr
;
4948 else if (mmap_alloc (var
, nbytes
))
4950 bcopy (old_ptr
, *var
, r
->nbytes_specified
);
4951 mmap_free_1 (MMAP_REGION (old_ptr
));
4953 r
= MMAP_REGION (result
);
4954 r
->nbytes_specified
= nbytes
;
4962 else if (room
- nbytes
>= mmap_page_size
)
4964 /* Shrinking by at least a page. Let's give some
4965 memory back to the system.
4967 The extra parens are to make the division happens first,
4968 on positive values, so we know it will round towards
4970 mmap_enlarge (r
, - ((room
- nbytes
) / mmap_page_size
));
4972 r
->nbytes_specified
= nbytes
;
4976 /* Leave it alone. */
4978 r
->nbytes_specified
= nbytes
;
4986 /* Free a block of relocatable storage whose data is pointed to by
4987 PTR. Store 0 in *PTR to show there's no block allocated. */
4997 mmap_free_1 (MMAP_REGION (*var
));
5003 /* Perform necessary intializations for the use of mmap. */
5009 /* The value of mmap_fd is initially 0 in temacs, and -1
5010 in a dumped Emacs. */
5013 /* No anonymous mmap -- we need the file descriptor. */
5014 mmap_fd
= open ("/dev/zero", O_RDONLY
);
5016 fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno
));
5018 #endif /* MAP_ANON == 0 */
5020 if (mmap_initialized_p
)
5022 mmap_initialized_p
= 1;
5028 mmap_page_size
= getpagesize ();
5031 #endif /* USE_MMAP_FOR_BUFFERS */
5035 /***********************************************************************
5036 Buffer-text Allocation
5037 ***********************************************************************/
5040 extern POINTER_TYPE
*r_alloc
P_ ((POINTER_TYPE
**, size_t));
5041 extern POINTER_TYPE
*r_re_alloc
P_ ((POINTER_TYPE
**, size_t));
5042 extern void r_alloc_free
P_ ((POINTER_TYPE
**ptr
));
5043 #endif /* REL_ALLOC */
5046 /* Allocate NBYTES bytes for buffer B's text buffer. */
5049 alloc_buffer_text (b
, nbytes
)
5056 #if defined USE_MMAP_FOR_BUFFERS
5057 p
= mmap_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
5058 #elif defined REL_ALLOC
5059 p
= r_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
5061 p
= xmalloc (nbytes
);
5070 b
->text
->beg
= (unsigned char *) p
;
5074 /* Enlarge buffer B's text buffer by DELTA bytes. DELTA < 0 means
5078 enlarge_buffer_text (struct buffer
*b
, EMACS_INT delta
)
5081 size_t nbytes
= (BUF_Z_BYTE (b
) - BUF_BEG_BYTE (b
) + BUF_GAP_SIZE (b
) + 1
5084 #if defined USE_MMAP_FOR_BUFFERS
5085 p
= mmap_realloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
5086 #elif defined REL_ALLOC
5087 p
= r_re_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
5089 p
= xrealloc (b
->text
->beg
, nbytes
);
5098 BUF_BEG_ADDR (b
) = (unsigned char *) p
;
5103 /* Free buffer B's text buffer. */
5106 free_buffer_text (b
)
5111 #if defined USE_MMAP_FOR_BUFFERS
5112 mmap_free ((POINTER_TYPE
**) &b
->text
->beg
);
5113 #elif defined REL_ALLOC
5114 r_alloc_free ((POINTER_TYPE
**) &b
->text
->beg
);
5116 xfree (b
->text
->beg
);
5119 BUF_BEG_ADDR (b
) = NULL
;
5125 /***********************************************************************
5127 ***********************************************************************/
5134 bzero (buffer_permanent_local_flags
, sizeof buffer_permanent_local_flags
);
5136 /* Make sure all markable slots in buffer_defaults
5137 are initialized reasonably, so mark_buffer won't choke. */
5138 reset_buffer (&buffer_defaults
);
5139 reset_buffer_local_variables (&buffer_defaults
, 1);
5140 reset_buffer (&buffer_local_symbols
);
5141 reset_buffer_local_variables (&buffer_local_symbols
, 1);
5142 /* Prevent GC from getting confused. */
5143 buffer_defaults
.text
= &buffer_defaults
.own_text
;
5144 buffer_local_symbols
.text
= &buffer_local_symbols
.own_text
;
5145 BUF_INTERVALS (&buffer_defaults
) = 0;
5146 BUF_INTERVALS (&buffer_local_symbols
) = 0;
5147 XSETPVECTYPE (&buffer_defaults
, PVEC_BUFFER
);
5148 XSETBUFFER (Vbuffer_defaults
, &buffer_defaults
);
5149 XSETPVECTYPE (&buffer_local_symbols
, PVEC_BUFFER
);
5150 XSETBUFFER (Vbuffer_local_symbols
, &buffer_local_symbols
);
5152 /* Set up the default values of various buffer slots. */
5153 /* Must do these before making the first buffer! */
5155 /* real setup is done in bindings.el */
5156 buffer_defaults
.mode_line_format
= build_string ("%-");
5157 buffer_defaults
.header_line_format
= Qnil
;
5158 buffer_defaults
.abbrev_mode
= Qnil
;
5159 buffer_defaults
.overwrite_mode
= Qnil
;
5160 buffer_defaults
.case_fold_search
= Qt
;
5161 buffer_defaults
.auto_fill_function
= Qnil
;
5162 buffer_defaults
.selective_display
= Qnil
;
5164 buffer_defaults
.selective_display_ellipses
= Qt
;
5166 buffer_defaults
.abbrev_table
= Qnil
;
5167 buffer_defaults
.display_table
= Qnil
;
5168 buffer_defaults
.undo_list
= Qnil
;
5169 buffer_defaults
.mark_active
= Qnil
;
5170 buffer_defaults
.file_format
= Qnil
;
5171 buffer_defaults
.auto_save_file_format
= Qt
;
5172 buffer_defaults
.overlays_before
= NULL
;
5173 buffer_defaults
.overlays_after
= NULL
;
5174 buffer_defaults
.overlay_center
= BEG
;
5176 XSETFASTINT (buffer_defaults
.tab_width
, 8);
5177 buffer_defaults
.truncate_lines
= Qnil
;
5178 buffer_defaults
.word_wrap
= Qnil
;
5179 buffer_defaults
.ctl_arrow
= Qt
;
5180 buffer_defaults
.direction_reversed
= Qnil
;
5181 buffer_defaults
.cursor_type
= Qt
;
5182 buffer_defaults
.extra_line_spacing
= Qnil
;
5183 buffer_defaults
.cursor_in_non_selected_windows
= Qt
;
5186 buffer_defaults
.buffer_file_type
= Qnil
; /* TEXT */
5188 buffer_defaults
.enable_multibyte_characters
= Qt
;
5189 buffer_defaults
.buffer_file_coding_system
= Qnil
;
5190 XSETFASTINT (buffer_defaults
.fill_column
, 70);
5191 XSETFASTINT (buffer_defaults
.left_margin
, 0);
5192 buffer_defaults
.cache_long_line_scans
= Qnil
;
5193 buffer_defaults
.file_truename
= Qnil
;
5194 XSETFASTINT (buffer_defaults
.display_count
, 0);
5195 XSETFASTINT (buffer_defaults
.left_margin_cols
, 0);
5196 XSETFASTINT (buffer_defaults
.right_margin_cols
, 0);
5197 buffer_defaults
.left_fringe_width
= Qnil
;
5198 buffer_defaults
.right_fringe_width
= Qnil
;
5199 buffer_defaults
.fringes_outside_margins
= Qnil
;
5200 buffer_defaults
.scroll_bar_width
= Qnil
;
5201 buffer_defaults
.vertical_scroll_bar_type
= Qt
;
5202 buffer_defaults
.indicate_empty_lines
= Qnil
;
5203 buffer_defaults
.indicate_buffer_boundaries
= Qnil
;
5204 buffer_defaults
.fringe_indicator_alist
= Qnil
;
5205 buffer_defaults
.fringe_cursor_alist
= Qnil
;
5206 buffer_defaults
.scroll_up_aggressively
= Qnil
;
5207 buffer_defaults
.scroll_down_aggressively
= Qnil
;
5208 buffer_defaults
.display_time
= Qnil
;
5210 /* Assign the local-flags to the slots that have default values.
5211 The local flag is a bit that is used in the buffer
5212 to say that it has its own local value for the slot.
5213 The local flag bits are in the local_var_flags slot of the buffer. */
5215 /* Nothing can work if this isn't true */
5216 if (sizeof (EMACS_INT
) != sizeof (Lisp_Object
)) abort ();
5218 /* 0 means not a lisp var, -1 means always local, else mask */
5219 bzero (&buffer_local_flags
, sizeof buffer_local_flags
);
5220 XSETINT (buffer_local_flags
.filename
, -1);
5221 XSETINT (buffer_local_flags
.directory
, -1);
5222 XSETINT (buffer_local_flags
.backed_up
, -1);
5223 XSETINT (buffer_local_flags
.save_length
, -1);
5224 XSETINT (buffer_local_flags
.auto_save_file_name
, -1);
5225 XSETINT (buffer_local_flags
.read_only
, -1);
5226 XSETINT (buffer_local_flags
.major_mode
, -1);
5227 XSETINT (buffer_local_flags
.mode_name
, -1);
5228 XSETINT (buffer_local_flags
.undo_list
, -1);
5229 XSETINT (buffer_local_flags
.mark_active
, -1);
5230 XSETINT (buffer_local_flags
.point_before_scroll
, -1);
5231 XSETINT (buffer_local_flags
.file_truename
, -1);
5232 XSETINT (buffer_local_flags
.invisibility_spec
, -1);
5233 XSETINT (buffer_local_flags
.file_format
, -1);
5234 XSETINT (buffer_local_flags
.auto_save_file_format
, -1);
5235 XSETINT (buffer_local_flags
.display_count
, -1);
5236 XSETINT (buffer_local_flags
.display_time
, -1);
5237 XSETINT (buffer_local_flags
.enable_multibyte_characters
, -1);
5240 XSETFASTINT (buffer_local_flags
.mode_line_format
, idx
); ++idx
;
5241 XSETFASTINT (buffer_local_flags
.abbrev_mode
, idx
); ++idx
;
5242 XSETFASTINT (buffer_local_flags
.overwrite_mode
, idx
); ++idx
;
5243 XSETFASTINT (buffer_local_flags
.case_fold_search
, idx
); ++idx
;
5244 XSETFASTINT (buffer_local_flags
.auto_fill_function
, idx
); ++idx
;
5245 XSETFASTINT (buffer_local_flags
.selective_display
, idx
); ++idx
;
5247 XSETFASTINT (buffer_local_flags
.selective_display_ellipses
, idx
); ++idx
;
5249 XSETFASTINT (buffer_local_flags
.tab_width
, idx
); ++idx
;
5250 XSETFASTINT (buffer_local_flags
.truncate_lines
, idx
); ++idx
;
5251 XSETFASTINT (buffer_local_flags
.word_wrap
, idx
); ++idx
;
5252 XSETFASTINT (buffer_local_flags
.ctl_arrow
, idx
); ++idx
;
5253 XSETFASTINT (buffer_local_flags
.fill_column
, idx
); ++idx
;
5254 XSETFASTINT (buffer_local_flags
.left_margin
, idx
); ++idx
;
5255 XSETFASTINT (buffer_local_flags
.abbrev_table
, idx
); ++idx
;
5256 XSETFASTINT (buffer_local_flags
.display_table
, idx
); ++idx
;
5258 XSETFASTINT (buffer_local_flags
.buffer_file_type
, idx
);
5259 /* Make this one a permanent local. */
5260 buffer_permanent_local_flags
[idx
++] = 1;
5262 XSETFASTINT (buffer_local_flags
.syntax_table
, idx
); ++idx
;
5263 XSETFASTINT (buffer_local_flags
.cache_long_line_scans
, idx
); ++idx
;
5264 XSETFASTINT (buffer_local_flags
.category_table
, idx
); ++idx
;
5265 XSETFASTINT (buffer_local_flags
.direction_reversed
, idx
); ++idx
;
5266 XSETFASTINT (buffer_local_flags
.buffer_file_coding_system
, idx
);
5267 /* Make this one a permanent local. */
5268 buffer_permanent_local_flags
[idx
++] = 1;
5269 XSETFASTINT (buffer_local_flags
.left_margin_cols
, idx
); ++idx
;
5270 XSETFASTINT (buffer_local_flags
.right_margin_cols
, idx
); ++idx
;
5271 XSETFASTINT (buffer_local_flags
.left_fringe_width
, idx
); ++idx
;
5272 XSETFASTINT (buffer_local_flags
.right_fringe_width
, idx
); ++idx
;
5273 XSETFASTINT (buffer_local_flags
.fringes_outside_margins
, idx
); ++idx
;
5274 XSETFASTINT (buffer_local_flags
.scroll_bar_width
, idx
); ++idx
;
5275 XSETFASTINT (buffer_local_flags
.vertical_scroll_bar_type
, idx
); ++idx
;
5276 XSETFASTINT (buffer_local_flags
.indicate_empty_lines
, idx
); ++idx
;
5277 XSETFASTINT (buffer_local_flags
.indicate_buffer_boundaries
, idx
); ++idx
;
5278 XSETFASTINT (buffer_local_flags
.fringe_indicator_alist
, idx
); ++idx
;
5279 XSETFASTINT (buffer_local_flags
.fringe_cursor_alist
, idx
); ++idx
;
5280 XSETFASTINT (buffer_local_flags
.scroll_up_aggressively
, idx
); ++idx
;
5281 XSETFASTINT (buffer_local_flags
.scroll_down_aggressively
, idx
); ++idx
;
5282 XSETFASTINT (buffer_local_flags
.header_line_format
, idx
); ++idx
;
5283 XSETFASTINT (buffer_local_flags
.cursor_type
, idx
); ++idx
;
5284 XSETFASTINT (buffer_local_flags
.extra_line_spacing
, idx
); ++idx
;
5285 XSETFASTINT (buffer_local_flags
.cursor_in_non_selected_windows
, idx
); ++idx
;
5287 /* Need more room? */
5288 if (idx
>= MAX_PER_BUFFER_VARS
)
5290 last_per_buffer_idx
= idx
;
5292 Vbuffer_alist
= Qnil
;
5296 QSFundamental
= build_string ("Fundamental");
5298 Qfundamental_mode
= intern ("fundamental-mode");
5299 buffer_defaults
.major_mode
= Qfundamental_mode
;
5301 Qmode_class
= intern ("mode-class");
5303 Qprotected_field
= intern ("protected-field");
5305 Qpermanent_local
= intern ("permanent-local");
5307 Qkill_buffer_hook
= intern ("kill-buffer-hook");
5308 Fput (Qkill_buffer_hook
, Qpermanent_local
, Qt
);
5310 Qucs_set_table_for_input
= intern ("ucs-set-table-for-input");
5312 Vprin1_to_string_buffer
= Fget_buffer_create (build_string (" prin1"));
5314 /* super-magic invisible buffer */
5315 Vbuffer_alist
= Qnil
;
5317 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
5319 inhibit_modification_hooks
= 0;
5329 #ifdef USE_MMAP_FOR_BUFFERS
5331 /* When using the ralloc implementation based on mmap(2), buffer
5332 text pointers will have been set to null in the dumped Emacs.
5336 for (b
= all_buffers
; b
; b
= b
->next
)
5337 if (b
->text
->beg
== NULL
)
5338 enlarge_buffer_text (b
, 0);
5340 #endif /* USE_MMAP_FOR_BUFFERS */
5342 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
5343 if (NILP (buffer_defaults
.enable_multibyte_characters
))
5344 Fset_buffer_multibyte (Qnil
);
5346 pwd
= get_current_dir_name ();
5349 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5351 /* Maybe this should really use some standard subroutine
5352 whose definition is filename syntax dependent. */
5354 if (!(IS_DIRECTORY_SEP (pwd
[len
- 1])))
5356 /* Grow buffer to add directory separator and '\0'. */
5357 pwd
= (char *) realloc (pwd
, len
+ 2);
5359 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5360 pwd
[len
] = DIRECTORY_SEP
;
5361 pwd
[len
+ 1] = '\0';
5364 current_buffer
->directory
= make_unibyte_string (pwd
, strlen (pwd
));
5365 if (! NILP (buffer_defaults
.enable_multibyte_characters
))
5366 /* At this moment, we still don't know how to decode the
5367 directory name. So, we keep the bytes in multibyte form so
5368 that ENCODE_FILE correctly gets the original bytes. */
5369 current_buffer
->directory
5370 = string_to_multibyte (current_buffer
->directory
);
5372 /* Add /: to the front of the name
5373 if it would otherwise be treated as magic. */
5374 temp
= Ffind_file_name_handler (current_buffer
->directory
, Qt
);
5376 /* If the default dir is just /, TEMP is non-nil
5377 because of the ange-ftp completion handler.
5378 However, it is not necessary to turn / into /:/.
5379 So avoid doing that. */
5380 && strcmp ("/", SDATA (current_buffer
->directory
)))
5381 current_buffer
->directory
5382 = concat2 (build_string ("/:"), current_buffer
->directory
);
5384 temp
= get_minibuffer (0);
5385 XBUFFER (temp
)->directory
= current_buffer
->directory
;
5390 /* Similar to defvar_lisp but define a variable whose value is the Lisp
5391 Object stored in the current buffer. address is the address of the slot
5392 in the buffer that is current now. */
5394 /* TYPE is nil for a general Lisp variable.
5395 An integer specifies a type; then only LIsp values
5396 with that type code are allowed (except that nil is allowed too).
5397 LNAME is the LIsp-level variable name.
5398 VNAME is the name of the buffer slot.
5399 DOC is a dummy where you write the doc string as a comment. */
5400 #define DEFVAR_PER_BUFFER(lname, vname, type, doc) \
5401 defvar_per_buffer (lname, vname, type, 0)
5404 defvar_per_buffer (namestring
, address
, type
, doc
)
5406 Lisp_Object
*address
;
5410 Lisp_Object sym
, val
;
5413 sym
= intern (namestring
);
5414 val
= allocate_misc ();
5415 offset
= (char *)address
- (char *)current_buffer
;
5417 XMISCTYPE (val
) = Lisp_Misc_Buffer_Objfwd
;
5418 XBUFFER_OBJFWD (val
)->offset
= offset
;
5419 XBUFFER_OBJFWD (val
)->slottype
= type
;
5420 SET_SYMBOL_VALUE (sym
, val
);
5421 PER_BUFFER_SYMBOL (offset
) = sym
;
5423 if (PER_BUFFER_IDX (offset
) == 0)
5424 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
5425 slot of buffer_local_flags */
5430 /* initialize the buffer routines */
5434 staticpro (&last_overlay_modification_hooks
);
5435 last_overlay_modification_hooks
5436 = Fmake_vector (make_number (10), Qnil
);
5438 staticpro (&Vbuffer_defaults
);
5439 staticpro (&Vbuffer_local_symbols
);
5440 staticpro (&Qfundamental_mode
);
5441 staticpro (&Qmode_class
);
5442 staticpro (&QSFundamental
);
5443 staticpro (&Vbuffer_alist
);
5444 staticpro (&Qprotected_field
);
5445 staticpro (&Qpermanent_local
);
5446 Qpermanent_local_hook
= intern ("permanent-local-hook");
5447 staticpro (&Qpermanent_local_hook
);
5448 staticpro (&Qkill_buffer_hook
);
5449 Qoverlayp
= intern ("overlayp");
5450 staticpro (&Qoverlayp
);
5451 Qevaporate
= intern ("evaporate");
5452 staticpro (&Qevaporate
);
5453 Qmodification_hooks
= intern ("modification-hooks");
5454 staticpro (&Qmodification_hooks
);
5455 Qinsert_in_front_hooks
= intern ("insert-in-front-hooks");
5456 staticpro (&Qinsert_in_front_hooks
);
5457 Qinsert_behind_hooks
= intern ("insert-behind-hooks");
5458 staticpro (&Qinsert_behind_hooks
);
5459 Qget_file_buffer
= intern ("get-file-buffer");
5460 staticpro (&Qget_file_buffer
);
5461 Qpriority
= intern ("priority");
5462 staticpro (&Qpriority
);
5463 Qwindow
= intern ("window");
5464 staticpro (&Qwindow
);
5465 Qbefore_string
= intern ("before-string");
5466 staticpro (&Qbefore_string
);
5467 Qafter_string
= intern ("after-string");
5468 staticpro (&Qafter_string
);
5469 Qfirst_change_hook
= intern ("first-change-hook");
5470 staticpro (&Qfirst_change_hook
);
5471 Qbefore_change_functions
= intern ("before-change-functions");
5472 staticpro (&Qbefore_change_functions
);
5473 Qafter_change_functions
= intern ("after-change-functions");
5474 staticpro (&Qafter_change_functions
);
5475 /* The next one is initialized in init_buffer_once. */
5476 staticpro (&Qucs_set_table_for_input
);
5478 Qkill_buffer_query_functions
= intern ("kill-buffer-query-functions");
5479 staticpro (&Qkill_buffer_query_functions
);
5481 Fput (Qprotected_field
, Qerror_conditions
,
5482 Fcons (Qprotected_field
, Fcons (Qerror
, Qnil
)));
5483 Fput (Qprotected_field
, Qerror_message
,
5484 build_string ("Attempt to modify a protected field"));
5486 /* All these use DEFVAR_LISP_NOPRO because the slots in
5487 buffer_defaults will all be marked via Vbuffer_defaults. */
5489 DEFVAR_LISP_NOPRO ("default-mode-line-format",
5490 &buffer_defaults
.mode_line_format
,
5491 doc
: /* Default value of `mode-line-format' for buffers that don't override it.
5492 This is the same as (default-value 'mode-line-format). */);
5494 DEFVAR_LISP_NOPRO ("default-header-line-format",
5495 &buffer_defaults
.header_line_format
,
5496 doc
: /* Default value of `header-line-format' for buffers that don't override it.
5497 This is the same as (default-value 'header-line-format). */);
5499 DEFVAR_LISP_NOPRO ("default-cursor-type", &buffer_defaults
.cursor_type
,
5500 doc
: /* Default value of `cursor-type' for buffers that don't override it.
5501 This is the same as (default-value 'cursor-type). */);
5503 DEFVAR_LISP_NOPRO ("default-line-spacing",
5504 &buffer_defaults
.extra_line_spacing
,
5505 doc
: /* Default value of `line-spacing' for buffers that don't override it.
5506 This is the same as (default-value 'line-spacing). */);
5508 DEFVAR_LISP_NOPRO ("default-cursor-in-non-selected-windows",
5509 &buffer_defaults
.cursor_in_non_selected_windows
,
5510 doc
: /* Default value of `cursor-in-non-selected-windows'.
5511 This is the same as (default-value 'cursor-in-non-selected-windows). */);
5513 DEFVAR_LISP_NOPRO ("default-abbrev-mode",
5514 &buffer_defaults
.abbrev_mode
,
5515 doc
: /* Default value of `abbrev-mode' for buffers that do not override it.
5516 This is the same as (default-value 'abbrev-mode). */);
5518 DEFVAR_LISP_NOPRO ("default-ctl-arrow",
5519 &buffer_defaults
.ctl_arrow
,
5520 doc
: /* Default value of `ctl-arrow' for buffers that do not override it.
5521 This is the same as (default-value 'ctl-arrow). */);
5523 DEFVAR_LISP_NOPRO ("default-direction-reversed",
5524 &buffer_defaults
.direction_reversed
,
5525 doc
: /* Default value of `direction-reversed' for buffers that do not override it.
5526 This is the same as (default-value 'direction-reversed). */);
5528 DEFVAR_LISP_NOPRO ("default-enable-multibyte-characters",
5529 &buffer_defaults
.enable_multibyte_characters
,
5530 doc
: /* *Default value of `enable-multibyte-characters' for buffers not overriding it.
5531 This is the same as (default-value 'enable-multibyte-characters). */);
5533 DEFVAR_LISP_NOPRO ("default-buffer-file-coding-system",
5534 &buffer_defaults
.buffer_file_coding_system
,
5535 doc
: /* Default value of `buffer-file-coding-system' for buffers not overriding it.
5536 This is the same as (default-value 'buffer-file-coding-system). */);
5538 DEFVAR_LISP_NOPRO ("default-truncate-lines",
5539 &buffer_defaults
.truncate_lines
,
5540 doc
: /* Default value of `truncate-lines' for buffers that do not override it.
5541 This is the same as (default-value 'truncate-lines). */);
5543 DEFVAR_LISP_NOPRO ("default-fill-column",
5544 &buffer_defaults
.fill_column
,
5545 doc
: /* Default value of `fill-column' for buffers that do not override it.
5546 This is the same as (default-value 'fill-column). */);
5548 DEFVAR_LISP_NOPRO ("default-left-margin",
5549 &buffer_defaults
.left_margin
,
5550 doc
: /* Default value of `left-margin' for buffers that do not override it.
5551 This is the same as (default-value 'left-margin). */);
5553 DEFVAR_LISP_NOPRO ("default-tab-width",
5554 &buffer_defaults
.tab_width
,
5555 doc
: /* Default value of `tab-width' for buffers that do not override it.
5556 This is the same as (default-value 'tab-width). */);
5558 DEFVAR_LISP_NOPRO ("default-case-fold-search",
5559 &buffer_defaults
.case_fold_search
,
5560 doc
: /* Default value of `case-fold-search' for buffers that don't override it.
5561 This is the same as (default-value 'case-fold-search). */);
5564 DEFVAR_LISP_NOPRO ("default-buffer-file-type",
5565 &buffer_defaults
.buffer_file_type
,
5566 doc
: /* Default file type for buffers that do not override it.
5567 This is the same as (default-value 'buffer-file-type).
5568 The file type is nil for text, t for binary. */);
5571 DEFVAR_LISP_NOPRO ("default-left-margin-width",
5572 &buffer_defaults
.left_margin_cols
,
5573 doc
: /* Default value of `left-margin-width' for buffers that don't override it.
5574 This is the same as (default-value 'left-margin-width). */);
5576 DEFVAR_LISP_NOPRO ("default-right-margin-width",
5577 &buffer_defaults
.right_margin_cols
,
5578 doc
: /* Default value of `right-margin-width' for buffers that don't override it.
5579 This is the same as (default-value 'right-margin-width). */);
5581 DEFVAR_LISP_NOPRO ("default-left-fringe-width",
5582 &buffer_defaults
.left_fringe_width
,
5583 doc
: /* Default value of `left-fringe-width' for buffers that don't override it.
5584 This is the same as (default-value 'left-fringe-width). */);
5586 DEFVAR_LISP_NOPRO ("default-right-fringe-width",
5587 &buffer_defaults
.right_fringe_width
,
5588 doc
: /* Default value of `right-fringe-width' for buffers that don't override it.
5589 This is the same as (default-value 'right-fringe-width). */);
5591 DEFVAR_LISP_NOPRO ("default-fringes-outside-margins",
5592 &buffer_defaults
.fringes_outside_margins
,
5593 doc
: /* Default value of `fringes-outside-margins' for buffers that don't override it.
5594 This is the same as (default-value 'fringes-outside-margins). */);
5596 DEFVAR_LISP_NOPRO ("default-scroll-bar-width",
5597 &buffer_defaults
.scroll_bar_width
,
5598 doc
: /* Default value of `scroll-bar-width' for buffers that don't override it.
5599 This is the same as (default-value 'scroll-bar-width). */);
5601 DEFVAR_LISP_NOPRO ("default-vertical-scroll-bar",
5602 &buffer_defaults
.vertical_scroll_bar_type
,
5603 doc
: /* Default value of `vertical-scroll-bar' for buffers that don't override it.
5604 This is the same as (default-value 'vertical-scroll-bar). */);
5606 DEFVAR_LISP_NOPRO ("default-indicate-empty-lines",
5607 &buffer_defaults
.indicate_empty_lines
,
5608 doc
: /* Default value of `indicate-empty-lines' for buffers that don't override it.
5609 This is the same as (default-value 'indicate-empty-lines). */);
5611 DEFVAR_LISP_NOPRO ("default-indicate-buffer-boundaries",
5612 &buffer_defaults
.indicate_buffer_boundaries
,
5613 doc
: /* Default value of `indicate-buffer-boundaries' for buffers that don't override it.
5614 This is the same as (default-value 'indicate-buffer-boundaries). */);
5616 DEFVAR_LISP_NOPRO ("default-fringe-indicator-alist",
5617 &buffer_defaults
.fringe_indicator_alist
,
5618 doc
: /* Default value of `fringe-indicator-alist' for buffers that don't override it.
5619 This is the same as (default-value 'fringe-indicator-alist'). */);
5621 DEFVAR_LISP_NOPRO ("default-fringe-cursor-alist",
5622 &buffer_defaults
.fringe_cursor_alist
,
5623 doc
: /* Default value of `fringe-cursor-alist' for buffers that don't override it.
5624 This is the same as (default-value 'fringe-cursor-alist'). */);
5626 DEFVAR_LISP_NOPRO ("default-scroll-up-aggressively",
5627 &buffer_defaults
.scroll_up_aggressively
,
5628 doc
: /* Default value of `scroll-up-aggressively'.
5629 This value applies in buffers that don't have their own local values.
5630 This is the same as (default-value 'scroll-up-aggressively). */);
5632 DEFVAR_LISP_NOPRO ("default-scroll-down-aggressively",
5633 &buffer_defaults
.scroll_down_aggressively
,
5634 doc
: /* Default value of `scroll-down-aggressively'.
5635 This value applies in buffers that don't have their own local values.
5636 This is the same as (default-value 'scroll-down-aggressively). */);
5638 DEFVAR_PER_BUFFER ("header-line-format",
5639 ¤t_buffer
->header_line_format
,
5641 doc
: /* Analogous to `mode-line-format', but controls the header line.
5642 The header line appears, optionally, at the top of a window;
5643 the mode line appears at the bottom. */);
5645 DEFVAR_PER_BUFFER ("mode-line-format", ¤t_buffer
->mode_line_format
,
5647 doc
: /* Template for displaying mode line for current buffer.
5648 Each buffer has its own value of this variable.
5649 Value may be nil, a string, a symbol or a list or cons cell.
5650 A value of nil means don't display a mode line.
5651 For a symbol, its value is used (but it is ignored if t or nil).
5652 A string appearing directly as the value of a symbol is processed verbatim
5653 in that the %-constructs below are not recognized.
5654 Note that unless the symbol is marked as a `risky-local-variable', all
5655 properties in any strings, as well as all :eval and :propertize forms
5656 in the value of that symbol will be ignored.
5657 For a list of the form `(:eval FORM)', FORM is evaluated and the result
5658 is used as a mode line element. Be careful--FORM should not load any files,
5659 because that can cause an infinite recursion.
5660 For a list of the form `(:propertize ELT PROPS...)', ELT is displayed
5661 with the specified properties PROPS applied.
5662 For a list whose car is a symbol, the symbol's value is taken,
5663 and if that is non-nil, the cadr of the list is processed recursively.
5664 Otherwise, the caddr of the list (if there is one) is processed.
5665 For a list whose car is a string or list, each element is processed
5666 recursively and the results are effectively concatenated.
5667 For a list whose car is an integer, the cdr of the list is processed
5668 and padded (if the number is positive) or truncated (if negative)
5669 to the width specified by that number.
5670 A string is printed verbatim in the mode line except for %-constructs:
5671 (%-constructs are allowed when the string is the entire mode-line-format
5672 or when it is found in a cons-cell or a list)
5673 %b -- print buffer name. %f -- print visited file name.
5674 %F -- print frame name.
5675 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
5676 %& is like %*, but ignore read-only-ness.
5677 % means buffer is read-only and * means it is modified.
5678 For a modified read-only buffer, %* gives % and %+ gives *.
5679 %s -- print process status. %l -- print the current line number.
5680 %c -- print the current column number (this makes editing slower).
5681 To make the column number update correctly in all cases,
5682 `column-number-mode' must be non-nil.
5683 %i -- print the size of the buffer.
5684 %I -- like %i, but use k, M, G, etc., to abbreviate.
5685 %p -- print percent of buffer above top of window, or Top, Bot or All.
5686 %P -- print percent of buffer above bottom of window, perhaps plus Top,
5687 or print Bottom or All.
5688 %n -- print Narrow if appropriate.
5689 %t -- visited file is text or binary (if OS supports this distinction).
5690 %z -- print mnemonics of keyboard, terminal, and buffer coding systems.
5691 %Z -- like %z, but including the end-of-line format.
5692 %e -- print error message about full memory.
5693 %@ -- print @ or hyphen. @ means that default-directory is on a
5695 %[ -- print one [ for each recursive editing level. %] similar.
5696 %% -- print %. %- -- print infinitely many dashes.
5697 Decimal digits after the % specify field width to which to pad. */);
5699 DEFVAR_LISP_NOPRO ("default-major-mode", &buffer_defaults
.major_mode
,
5700 doc
: /* *Major mode for new buffers. Defaults to `fundamental-mode'.
5701 A value of nil means use current buffer's major mode,
5702 provided it is not marked as "special".
5704 When a mode is used by default, `find-file' switches to it
5705 before it reads the contents into the buffer and before
5706 it finishes setting up the buffer. Thus, the mode and
5707 its hooks should not expect certain variables such as
5708 `buffer-read-only' and `buffer-file-coding-system' to be set up. */);
5710 DEFVAR_PER_BUFFER ("major-mode", ¤t_buffer
->major_mode
,
5711 make_number (Lisp_Symbol
),
5712 doc
: /* Symbol for current buffer's major mode. */);
5714 DEFVAR_PER_BUFFER ("mode-name", ¤t_buffer
->mode_name
,
5716 doc
: /* Pretty name of current buffer's major mode.
5717 Usually a string, but can use any of the constructs for `mode-line-format',
5719 Format with `format-mode-line' to produce a string value. */);
5721 DEFVAR_PER_BUFFER ("local-abbrev-table", ¤t_buffer
->abbrev_table
, Qnil
,
5722 doc
: /* Local (mode-specific) abbrev table of current buffer. */);
5724 DEFVAR_PER_BUFFER ("abbrev-mode", ¤t_buffer
->abbrev_mode
, Qnil
,
5725 doc
: /* Non-nil turns on automatic expansion of abbrevs as they are inserted. */);
5727 DEFVAR_PER_BUFFER ("case-fold-search", ¤t_buffer
->case_fold_search
,
5729 doc
: /* *Non-nil if searches and matches should ignore case. */);
5731 DEFVAR_PER_BUFFER ("fill-column", ¤t_buffer
->fill_column
,
5732 make_number (Lisp_Int
),
5733 doc
: /* *Column beyond which automatic line-wrapping should happen.
5734 Interactively, you can set the buffer local value using \\[set-fill-column]. */);
5736 DEFVAR_PER_BUFFER ("left-margin", ¤t_buffer
->left_margin
,
5737 make_number (Lisp_Int
),
5738 doc
: /* *Column for the default `indent-line-function' to indent to.
5739 Linefeed indents to this column in Fundamental mode. */);
5741 DEFVAR_PER_BUFFER ("tab-width", ¤t_buffer
->tab_width
,
5742 make_number (Lisp_Int
),
5743 doc
: /* *Distance between tab stops (for display of tab characters), in columns. */);
5745 DEFVAR_PER_BUFFER ("ctl-arrow", ¤t_buffer
->ctl_arrow
, Qnil
,
5746 doc
: /* *Non-nil means display control chars with uparrow.
5747 A value of nil means use backslash and octal digits.
5748 This variable does not apply to characters whose display is specified
5749 in the current display table (if there is one). */);
5751 DEFVAR_PER_BUFFER ("enable-multibyte-characters",
5752 ¤t_buffer
->enable_multibyte_characters
,
5754 doc
: /* Non-nil means the buffer contents are regarded as multi-byte characters.
5755 Otherwise they are regarded as unibyte. This affects the display,
5756 file I/O and the behavior of various editing commands.
5758 This variable is buffer-local but you cannot set it directly;
5759 use the function `set-buffer-multibyte' to change a buffer's representation.
5760 Changing its default value with `setq-default' is supported.
5761 See also variable `default-enable-multibyte-characters' and Info node
5762 `(elisp)Text Representations'. */);
5763 XSYMBOL (intern ("enable-multibyte-characters"))->constant
= 1;
5765 DEFVAR_PER_BUFFER ("buffer-file-coding-system",
5766 ¤t_buffer
->buffer_file_coding_system
, Qnil
,
5767 doc
: /* Coding system to be used for encoding the buffer contents on saving.
5768 This variable applies to saving the buffer, and also to `write-region'
5769 and other functions that use `write-region'.
5770 It does not apply to sending output to subprocesses, however.
5772 If this is nil, the buffer is saved without any code conversion
5773 unless some coding system is specified in `file-coding-system-alist'
5774 for the buffer file.
5776 If the text to be saved cannot be encoded as specified by this variable,
5777 an alternative encoding is selected by `select-safe-coding-system', which see.
5779 The variable `coding-system-for-write', if non-nil, overrides this variable.
5781 This variable is never applied to a way of decoding a file while reading it. */);
5783 DEFVAR_PER_BUFFER ("direction-reversed", ¤t_buffer
->direction_reversed
,
5785 doc
: /* *Non-nil means lines in the buffer are displayed right to left. */);
5787 DEFVAR_PER_BUFFER ("truncate-lines", ¤t_buffer
->truncate_lines
, Qnil
,
5788 doc
: /* *Non-nil means do not display continuation lines.
5789 Instead, give each line of text just one screen line.
5791 Note that this is overridden by the variable
5792 `truncate-partial-width-windows' if that variable is non-nil
5793 and this buffer is not full-frame width. */);
5795 DEFVAR_PER_BUFFER ("word-wrap", ¤t_buffer
->word_wrap
, Qnil
,
5796 doc
: /* *Non-nil means to use word-wrapping for continuation lines.
5797 When word-wrapping is on, continuation lines are wrapped at the space
5798 or tab character nearest to the right window edge.
5799 If nil, continuation lines are wrapped at the right screen edge.
5801 This variable has no effect if long lines are truncated (see
5802 `truncate-lines' and `truncate-partial-width-windows'). If you use
5803 word-wrapping, you might want to reduce the value of
5804 `truncate-partial-width-windows', since wrapping can make text readable
5805 in narrower windows. */);
5808 DEFVAR_PER_BUFFER ("buffer-file-type", ¤t_buffer
->buffer_file_type
,
5810 doc
: /* Non-nil if the visited file is a binary file.
5811 This variable is meaningful on MS-DOG and Windows NT.
5812 On those systems, it is automatically local in every buffer.
5813 On other systems, this variable is normally always nil. */);
5816 DEFVAR_PER_BUFFER ("default-directory", ¤t_buffer
->directory
,
5817 make_number (Lisp_String
),
5818 doc
: /* Name of default directory of current buffer. Should end with slash.
5819 To interactively change the default directory, use command `cd'. */);
5821 DEFVAR_PER_BUFFER ("auto-fill-function", ¤t_buffer
->auto_fill_function
,
5823 doc
: /* Function called (if non-nil) to perform auto-fill.
5824 It is called after self-inserting any character specified in
5825 the `auto-fill-chars' table.
5826 NOTE: This variable is not a hook;
5827 its value may not be a list of functions. */);
5829 DEFVAR_PER_BUFFER ("buffer-file-name", ¤t_buffer
->filename
,
5830 make_number (Lisp_String
),
5831 doc
: /* Name of file visited in current buffer, or nil if not visiting a file. */);
5833 DEFVAR_PER_BUFFER ("buffer-file-truename", ¤t_buffer
->file_truename
,
5834 make_number (Lisp_String
),
5835 doc
: /* Abbreviated truename of file visited in current buffer, or nil if none.
5836 The truename of a file is calculated by `file-truename'
5837 and then abbreviated with `abbreviate-file-name'. */);
5839 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
5840 ¤t_buffer
->auto_save_file_name
,
5841 make_number (Lisp_String
),
5842 doc
: /* Name of file for auto-saving current buffer.
5843 If it is nil, that means don't auto-save this buffer. */);
5845 DEFVAR_PER_BUFFER ("buffer-read-only", ¤t_buffer
->read_only
, Qnil
,
5846 doc
: /* Non-nil if this buffer is read-only. */);
5848 DEFVAR_PER_BUFFER ("buffer-backed-up", ¤t_buffer
->backed_up
, Qnil
,
5849 doc
: /* Non-nil if this buffer's file has been backed up.
5850 Backing up is done before the first time the file is saved. */);
5852 DEFVAR_PER_BUFFER ("buffer-saved-size", ¤t_buffer
->save_length
,
5853 make_number (Lisp_Int
),
5854 doc
: /* Length of current buffer when last read in, saved or auto-saved.
5857 DEFVAR_PER_BUFFER ("selective-display", ¤t_buffer
->selective_display
,
5859 doc
: /* Non-nil enables selective display.
5860 An integer N as value means display only lines
5861 that start with less than N columns of space.
5862 A value of t means that the character ^M makes itself and
5863 all the rest of the line invisible; also, when saving the buffer
5864 in a file, save the ^M as a newline. */);
5867 DEFVAR_PER_BUFFER ("selective-display-ellipses",
5868 ¤t_buffer
->selective_display_ellipses
,
5870 doc
: /* Non-nil means display ... on previous line when a line is invisible. */);
5873 DEFVAR_PER_BUFFER ("overwrite-mode", ¤t_buffer
->overwrite_mode
, Qnil
,
5874 doc
: /* Non-nil if self-insertion should replace existing text.
5875 The value should be one of `overwrite-mode-textual',
5876 `overwrite-mode-binary', or nil.
5877 If it is `overwrite-mode-textual', self-insertion still
5878 inserts at the end of a line, and inserts when point is before a tab,
5879 until the tab is filled in.
5880 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too. */);
5882 DEFVAR_PER_BUFFER ("buffer-display-table", ¤t_buffer
->display_table
,
5884 doc
: /* Display table that controls display of the contents of current buffer.
5886 If this variable is nil, the value of `standard-display-table' is used.
5887 Each window can have its own, overriding display table, see
5888 `set-window-display-table' and `window-display-table'.
5890 The display table is a char-table created with `make-display-table'.
5891 A char-table is an array indexed by character codes. Normal array
5892 primitives `aref' and `aset' can be used to access elements of a char-table.
5894 Each of the char-table elements control how to display the corresponding
5895 text character: the element at index C in the table says how to display
5896 the character whose code is C. Each element should be a vector of
5897 characters or nil. The value nil means display the character in the
5898 default fashion; otherwise, the characters from the vector are delivered
5899 to the screen instead of the original character.
5901 For example, (aset buffer-display-table ?X [?Y]) tells Emacs
5902 to display a capital Y instead of each X character.
5904 In addition, a char-table has six extra slots to control the display of:
5906 the end of a truncated screen line (extra-slot 0, a single character);
5907 the end of a continued line (extra-slot 1, a single character);
5908 the escape character used to display character codes in octal
5909 (extra-slot 2, a single character);
5910 the character used as an arrow for control characters (extra-slot 3,
5911 a single character);
5912 the decoration indicating the presence of invisible lines (extra-slot 4,
5913 a vector of characters);
5914 the character used to draw the border between side-by-side windows
5915 (extra-slot 5, a single character).
5917 See also the functions `display-table-slot' and `set-display-table-slot'. */);
5919 DEFVAR_PER_BUFFER ("left-margin-width", ¤t_buffer
->left_margin_cols
,
5921 doc
: /* *Width of left marginal area for display of a buffer.
5922 A value of nil means no marginal area. */);
5924 DEFVAR_PER_BUFFER ("right-margin-width", ¤t_buffer
->right_margin_cols
,
5926 doc
: /* *Width of right marginal area for display of a buffer.
5927 A value of nil means no marginal area. */);
5929 DEFVAR_PER_BUFFER ("left-fringe-width", ¤t_buffer
->left_fringe_width
,
5931 doc
: /* *Width of this buffer's left fringe (in pixels).
5932 A value of 0 means no left fringe is shown in this buffer's window.
5933 A value of nil means to use the left fringe width from the window's frame. */);
5935 DEFVAR_PER_BUFFER ("right-fringe-width", ¤t_buffer
->right_fringe_width
,
5937 doc
: /* *Width of this buffer's right fringe (in pixels).
5938 A value of 0 means no right fringe is shown in this buffer's window.
5939 A value of nil means to use the right fringe width from the window's frame. */);
5941 DEFVAR_PER_BUFFER ("fringes-outside-margins", ¤t_buffer
->fringes_outside_margins
,
5943 doc
: /* *Non-nil means to display fringes outside display margins.
5944 A value of nil means to display fringes between margins and buffer text. */);
5946 DEFVAR_PER_BUFFER ("scroll-bar-width", ¤t_buffer
->scroll_bar_width
,
5948 doc
: /* *Width of this buffer's scroll bars in pixels.
5949 A value of nil means to use the scroll bar width from the window's frame. */);
5951 DEFVAR_PER_BUFFER ("vertical-scroll-bar", ¤t_buffer
->vertical_scroll_bar_type
,
5953 doc
: /* *Position of this buffer's vertical scroll bar.
5954 The value takes effect whenever you tell a window to display this buffer;
5955 for instance, with `set-window-buffer' or when `display-buffer' displays it.
5957 A value of `left' or `right' means put the vertical scroll bar at that side
5958 of the window; a value of nil means don't show any vertical scroll bars.
5959 A value of t (the default) means do whatever the window's frame specifies. */);
5961 DEFVAR_PER_BUFFER ("indicate-empty-lines",
5962 ¤t_buffer
->indicate_empty_lines
, Qnil
,
5963 doc
: /* *Visually indicate empty lines after the buffer end.
5964 If non-nil, a bitmap is displayed in the left fringe of a window on
5965 window-systems. */);
5967 DEFVAR_PER_BUFFER ("indicate-buffer-boundaries",
5968 ¤t_buffer
->indicate_buffer_boundaries
, Qnil
,
5969 doc
: /* *Visually indicate buffer boundaries and scrolling.
5970 If non-nil, the first and last line of the buffer are marked in the fringe
5971 of a window on window-systems with angle bitmaps, or if the window can be
5972 scrolled, the top and bottom line of the window are marked with up and down
5975 If value is a symbol `left' or `right', both angle and arrow bitmaps
5976 are displayed in the left or right fringe, resp. Any other value
5977 that doesn't look like an alist means display the angle bitmaps in
5978 the left fringe but no arrows.
5980 You can exercise more precise control by using an alist as the
5981 value. Each alist element (INDICATOR . POSITION) specifies
5982 where to show one of the indicators. INDICATOR is one of `top',
5983 `bottom', `up', `down', or t, which specifies the default position,
5984 and POSITION is one of `left', `right', or nil, meaning do not show
5987 For example, ((top . left) (t . right)) places the top angle bitmap in
5988 left fringe, the bottom angle bitmap in right fringe, and both arrow
5989 bitmaps in right fringe. To show just the angle bitmaps in the left
5990 fringe, but no arrow bitmaps, use ((top . left) (bottom . left)). */);
5992 DEFVAR_PER_BUFFER ("fringe-indicator-alist",
5993 ¤t_buffer
->fringe_indicator_alist
, Qnil
,
5994 doc
: /* *Mapping from logical to physical fringe indicator bitmaps.
5995 The value is an alist where each element (INDICATOR . BITMAPS)
5996 specifies the fringe bitmaps used to display a specific logical
5999 INDICATOR specifies the logical indicator type which is one of the
6000 following symbols: `truncation' , `continuation', `overlay-arrow',
6001 `top', `bottom', `up', `down', `one-line', `empty-line', or `unknown'.
6003 BITMAPS is list of symbols (LEFT RIGHT [LEFT1 RIGHT1]) which specifies
6004 the actual bitmap shown in the left or right fringe for the logical
6005 indicator. LEFT and RIGHT are the bitmaps shown in the left and/or
6006 right fringe for the specific indicator. The LEFT1 or RIGHT1 bitmaps
6007 are used only for the `bottom' and `one-line' indicators when the last
6008 \(only) line in has no final newline. BITMAPS may also be a single
6009 symbol which is used in both left and right fringes. */);
6011 DEFVAR_PER_BUFFER ("fringe-cursor-alist",
6012 ¤t_buffer
->fringe_cursor_alist
, Qnil
,
6013 doc
: /* *Mapping from logical to physical fringe cursor bitmaps.
6014 The value is an alist where each element (CURSOR . BITMAP)
6015 specifies the fringe bitmaps used to display a specific logical
6016 cursor type in the fringe.
6018 CURSOR specifies the logical cursor type which is one of the following
6019 symbols: `box' , `hollow', `bar', `hbar', or `hollow-small'. The last
6020 one is used to show a hollow cursor on narrow lines display lines
6021 where the normal hollow cursor will not fit.
6023 BITMAP is the corresponding fringe bitmap shown for the logical
6026 DEFVAR_PER_BUFFER ("scroll-up-aggressively",
6027 ¤t_buffer
->scroll_up_aggressively
, Qnil
,
6028 doc
: /* How far to scroll windows upward.
6029 If you move point off the bottom, the window scrolls automatically.
6030 This variable controls how far it scrolls. The value nil, the default,
6031 means scroll to center point. A fraction means scroll to put point
6032 that fraction of the window's height from the bottom of the window.
6033 When the value is 0.0, point goes at the bottom line, which in the
6034 simple case that you moved off with C-f means scrolling just one line.
6035 1.0 means point goes at the top, so that in that simple case, the
6036 window scrolls by a full window height. Meaningful values are
6037 between 0.0 and 1.0, inclusive. */);
6039 DEFVAR_PER_BUFFER ("scroll-down-aggressively",
6040 ¤t_buffer
->scroll_down_aggressively
, Qnil
,
6041 doc
: /* How far to scroll windows downward.
6042 If you move point off the top, the window scrolls automatically.
6043 This variable controls how far it scrolls. The value nil, the default,
6044 means scroll to center point. A fraction means scroll to put point
6045 that fraction of the window's height from the top of the window.
6046 When the value is 0.0, point goes at the top line, which in the
6047 simple case that you moved off with C-b means scrolling just one line.
6048 1.0 means point goes at the bottom, so that in that simple case, the
6049 window scrolls by a full window height. Meaningful values are
6050 between 0.0 and 1.0, inclusive. */);
6052 /*DEFVAR_LISP ("debug-check-symbol", &Vcheck_symbol,
6056 DEFVAR_LISP ("before-change-functions", &Vbefore_change_functions
,
6057 doc
: /* List of functions to call before each text change.
6058 Two arguments are passed to each function: the positions of
6059 the beginning and end of the range of old text to be changed.
6060 \(For an insertion, the beginning and end are at the same place.)
6061 No information is given about the length of the text after the change.
6063 Buffer changes made while executing the `before-change-functions'
6064 don't call any before-change or after-change functions.
6065 That's because these variables are temporarily set to nil.
6066 As a result, a hook function cannot straightforwardly alter the
6067 value of these variables. See the Emacs Lisp manual for a way of
6068 accomplishing an equivalent result by using other variables.
6070 If an unhandled error happens in running these functions,
6071 the variable's value remains nil. That prevents the error
6072 from happening repeatedly and making Emacs nonfunctional. */);
6073 Vbefore_change_functions
= Qnil
;
6075 DEFVAR_LISP ("after-change-functions", &Vafter_change_functions
,
6076 doc
: /* List of functions to call after each text change.
6077 Three arguments are passed to each function: the positions of
6078 the beginning and end of the range of changed text,
6079 and the length in bytes of the pre-change text replaced by that range.
6080 \(For an insertion, the pre-change length is zero;
6081 for a deletion, that length is the number of bytes deleted,
6082 and the post-change beginning and end are at the same place.)
6084 Buffer changes made while executing the `after-change-functions'
6085 don't call any before-change or after-change functions.
6086 That's because these variables are temporarily set to nil.
6087 As a result, a hook function cannot straightforwardly alter the
6088 value of these variables. See the Emacs Lisp manual for a way of
6089 accomplishing an equivalent result by using other variables.
6091 If an unhandled error happens in running these functions,
6092 the variable's value remains nil. That prevents the error
6093 from happening repeatedly and making Emacs nonfunctional. */);
6094 Vafter_change_functions
= Qnil
;
6096 DEFVAR_LISP ("first-change-hook", &Vfirst_change_hook
,
6097 doc
: /* A list of functions to call before changing a buffer which is unmodified.
6098 The functions are run using the `run-hooks' function. */);
6099 Vfirst_change_hook
= Qnil
;
6101 DEFVAR_PER_BUFFER ("buffer-undo-list", ¤t_buffer
->undo_list
, Qnil
,
6102 doc
: /* List of undo entries in current buffer.
6103 Recent changes come first; older changes follow newer.
6105 An entry (BEG . END) represents an insertion which begins at
6106 position BEG and ends at position END.
6108 An entry (TEXT . POSITION) represents the deletion of the string TEXT
6109 from (abs POSITION). If POSITION is positive, point was at the front
6110 of the text being deleted; if negative, point was at the end.
6112 An entry (t HIGH . LOW) indicates that the buffer previously had
6113 \"unmodified\" status. HIGH and LOW are the high and low 16-bit portions
6114 of the visited file's modification time, as of that time. If the
6115 modification time of the most recent save is different, this entry is
6118 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
6119 was modified between BEG and END. PROPERTY is the property name,
6120 and VALUE is the old value.
6122 An entry (apply FUN-NAME . ARGS) means undo the change with
6123 \(apply FUN-NAME ARGS).
6125 An entry (apply DELTA BEG END FUN-NAME . ARGS) supports selective undo
6126 in the active region. BEG and END is the range affected by this entry
6127 and DELTA is the number of bytes added or deleted in that range by
6130 An entry (MARKER . DISTANCE) indicates that the marker MARKER
6131 was adjusted in position by the offset DISTANCE (an integer).
6133 An entry of the form POSITION indicates that point was at the buffer
6134 location given by the integer. Undoing an entry of this form places
6137 Entries with value `nil' mark undo boundaries. The undo command treats
6138 the changes between two undo boundaries as a single step to be undone.
6140 If the value of the variable is t, undo information is not recorded. */);
6142 DEFVAR_PER_BUFFER ("mark-active", ¤t_buffer
->mark_active
, Qnil
,
6143 doc
: /* Non-nil means the mark and region are currently active in this buffer. */);
6145 DEFVAR_PER_BUFFER ("cache-long-line-scans", ¤t_buffer
->cache_long_line_scans
, Qnil
,
6146 doc
: /* Non-nil means that Emacs should use caches to handle long lines more quickly.
6148 Normally, the line-motion functions work by scanning the buffer for
6149 newlines. Columnar operations (like `move-to-column' and
6150 `compute-motion') also work by scanning the buffer, summing character
6151 widths as they go. This works well for ordinary text, but if the
6152 buffer's lines are very long (say, more than 500 characters), these
6153 motion functions will take longer to execute. Emacs may also take
6154 longer to update the display.
6156 If `cache-long-line-scans' is non-nil, these motion functions cache the
6157 results of their scans, and consult the cache to avoid rescanning
6158 regions of the buffer until the text is modified. The caches are most
6159 beneficial when they prevent the most searching---that is, when the
6160 buffer contains long lines and large regions of characters with the
6161 same, fixed screen width.
6163 When `cache-long-line-scans' is non-nil, processing short lines will
6164 become slightly slower (because of the overhead of consulting the
6165 cache), and the caches will use memory roughly proportional to the
6166 number of newlines and characters whose screen width varies.
6168 The caches require no explicit maintenance; their accuracy is
6169 maintained internally by the Emacs primitives. Enabling or disabling
6170 the cache should not affect the behavior of any of the motion
6171 functions; it should only affect their performance. */);
6173 DEFVAR_PER_BUFFER ("point-before-scroll", ¤t_buffer
->point_before_scroll
, Qnil
,
6174 doc
: /* Value of point before the last series of scroll operations, or nil. */);
6176 DEFVAR_PER_BUFFER ("buffer-file-format", ¤t_buffer
->file_format
, Qnil
,
6177 doc
: /* List of formats to use when saving this buffer.
6178 Formats are defined by `format-alist'. This variable is
6179 set when a file is visited. */);
6181 DEFVAR_PER_BUFFER ("buffer-auto-save-file-format",
6182 ¤t_buffer
->auto_save_file_format
, Qnil
,
6183 doc
: /* *Format in which to write auto-save files.
6184 Should be a list of symbols naming formats that are defined in `format-alist'.
6185 If it is t, which is the default, auto-save files are written in the
6186 same format as a regular save would use. */);
6188 DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
6189 ¤t_buffer
->invisibility_spec
, Qnil
,
6190 doc
: /* Invisibility spec of this buffer.
6191 The default is t, which means that text is invisible
6192 if it has a non-nil `invisible' property.
6193 If the value is a list, a text character is invisible if its `invisible'
6194 property is an element in that list (or is a list with members in common).
6195 If an element is a cons cell of the form (PROP . ELLIPSIS),
6196 then characters with property value PROP are invisible,
6197 and they have an ellipsis as well if ELLIPSIS is non-nil. */);
6199 DEFVAR_PER_BUFFER ("buffer-display-count",
6200 ¤t_buffer
->display_count
, Qnil
,
6201 doc
: /* A number incremented each time this buffer is displayed in a window.
6202 The function `set-window-buffer' increments it. */);
6204 DEFVAR_PER_BUFFER ("buffer-display-time",
6205 ¤t_buffer
->display_time
, Qnil
,
6206 doc
: /* Time stamp updated each time this buffer is displayed in a window.
6207 The function `set-window-buffer' updates this variable
6208 to the value obtained by calling `current-time'.
6209 If the buffer has never been shown in a window, the value is nil. */);
6211 DEFVAR_LISP ("transient-mark-mode", &Vtransient_mark_mode
,
6213 Vtransient_mark_mode
= Qnil
;
6214 /* The docstring is in simple.el. If we put it here, it would be
6215 overwritten when transient-mark-mode is defined using
6216 define-minor-mode. */
6218 DEFVAR_LISP ("inhibit-read-only", &Vinhibit_read_only
,
6219 doc
: /* *Non-nil means disregard read-only status of buffers or characters.
6220 If the value is t, disregard `buffer-read-only' and all `read-only'
6221 text properties. If the value is a list, disregard `buffer-read-only'
6222 and disregard a `read-only' text property if the property value
6223 is a member of the list. */);
6224 Vinhibit_read_only
= Qnil
;
6226 DEFVAR_PER_BUFFER ("cursor-type", ¤t_buffer
->cursor_type
, Qnil
,
6227 doc
: /* Cursor to use when this buffer is in the selected window.
6228 Values are interpreted as follows:
6230 t use the cursor specified for the frame
6231 nil don't display a cursor
6232 box display a filled box cursor
6233 hollow display a hollow box cursor
6234 bar display a vertical bar cursor with default width
6235 (bar . WIDTH) display a vertical bar cursor with width WIDTH
6236 hbar display a horizontal bar cursor with default height
6237 (hbar . HEIGHT) display a horizontal bar cursor with height HEIGHT
6238 ANYTHING ELSE display a hollow box cursor
6240 When the buffer is displayed in a non-selected window, the
6241 cursor's appearance is instead controlled by the variable
6242 `cursor-in-non-selected-windows'. */);
6244 DEFVAR_PER_BUFFER ("line-spacing",
6245 ¤t_buffer
->extra_line_spacing
, Qnil
,
6246 doc
: /* Additional space to put between lines when displaying a buffer.
6247 The space is measured in pixels, and put below lines on window systems.
6248 If value is a floating point number, it specifies the spacing relative
6249 to the default frame line height. A value of nil means add no extra space. */);
6251 DEFVAR_PER_BUFFER ("cursor-in-non-selected-windows",
6252 ¤t_buffer
->cursor_in_non_selected_windows
, Qnil
,
6253 doc
: /* *Cursor type to display in non-selected windows.
6254 The value t means to use hollow box cursor. See `cursor-type' for other values. */);
6256 DEFVAR_LISP ("kill-buffer-query-functions", &Vkill_buffer_query_functions
,
6257 doc
: /* List of functions called with no args to query before killing a buffer.
6258 The buffer being killed will be current while the functions are running.
6259 If any of them returns nil, the buffer is not killed. */);
6260 Vkill_buffer_query_functions
= Qnil
;
6262 DEFVAR_LISP ("change-major-mode-hook", &Vchange_major_mode_hook
,
6263 doc
: /* Normal hook run before changing the major mode of a buffer.
6264 The function `kill-all-local-variables' runs this before doing anything else. */);
6265 Vchange_major_mode_hook
= Qnil
;
6266 Qchange_major_mode_hook
= intern ("change-major-mode-hook");
6267 staticpro (&Qchange_major_mode_hook
);
6269 defsubr (&Sbuffer_live_p
);
6270 defsubr (&Sbuffer_list
);
6271 defsubr (&Sget_buffer
);
6272 defsubr (&Sget_file_buffer
);
6273 defsubr (&Sget_buffer_create
);
6274 defsubr (&Smake_indirect_buffer
);
6275 defsubr (&Sgenerate_new_buffer_name
);
6276 defsubr (&Sbuffer_name
);
6277 /*defsubr (&Sbuffer_number);*/
6278 defsubr (&Sbuffer_file_name
);
6279 defsubr (&Sbuffer_base_buffer
);
6280 defsubr (&Sbuffer_local_value
);
6281 defsubr (&Sbuffer_local_variables
);
6282 defsubr (&Sbuffer_modified_p
);
6283 defsubr (&Sset_buffer_modified_p
);
6284 defsubr (&Sbuffer_modified_tick
);
6285 defsubr (&Sbuffer_chars_modified_tick
);
6286 defsubr (&Srename_buffer
);
6287 defsubr (&Sother_buffer
);
6288 defsubr (&Sbuffer_enable_undo
);
6289 defsubr (&Skill_buffer
);
6290 defsubr (&Sset_buffer_major_mode
);
6291 defsubr (&Sswitch_to_buffer
);
6292 defsubr (&Scurrent_buffer
);
6293 defsubr (&Sset_buffer
);
6294 defsubr (&Sbarf_if_buffer_read_only
);
6295 defsubr (&Sbury_buffer
);
6296 defsubr (&Serase_buffer
);
6297 defsubr (&Sbuffer_swap_text
);
6298 defsubr (&Sset_buffer_multibyte
);
6299 defsubr (&Skill_all_local_variables
);
6301 defsubr (&Soverlayp
);
6302 defsubr (&Smake_overlay
);
6303 defsubr (&Sdelete_overlay
);
6304 defsubr (&Smove_overlay
);
6305 defsubr (&Soverlay_start
);
6306 defsubr (&Soverlay_end
);
6307 defsubr (&Soverlay_buffer
);
6308 defsubr (&Soverlay_properties
);
6309 defsubr (&Soverlays_at
);
6310 defsubr (&Soverlays_in
);
6311 defsubr (&Snext_overlay_change
);
6312 defsubr (&Sprevious_overlay_change
);
6313 defsubr (&Soverlay_recenter
);
6314 defsubr (&Soverlay_lists
);
6315 defsubr (&Soverlay_get
);
6316 defsubr (&Soverlay_put
);
6317 defsubr (&Srestore_buffer_modified_p
);
6323 initial_define_key (control_x_map
, 'b', "switch-to-buffer");
6324 initial_define_key (control_x_map
, 'k', "kill-buffer");
6326 /* This must not be in syms_of_buffer, because Qdisabled is not
6327 initialized when that function gets called. */
6328 Fput (intern ("erase-buffer"), Qdisabled
, Qt
);
6331 /* arch-tag: e48569bf-69a9-4b65-a23b-8e68769436e1
6332 (do not change this comment) */