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, 2009
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>
41 #include "intervals.h"
45 #include "character.h"
46 #include "region-cache.h"
48 #include "blockinput.h"
53 struct buffer
*current_buffer
; /* the current buffer */
55 /* First buffer in chain of all buffers (in reverse order of creation).
56 Threaded through ->next. */
58 struct buffer
*all_buffers
;
60 /* This structure holds the default values of the buffer-local variables
61 defined with DEFVAR_PER_BUFFER, that have special slots in each buffer.
62 The default value occupies the same slot in this structure
63 as an individual buffer's value occupies in that buffer.
64 Setting the default value also goes through the alist of buffers
65 and stores into each buffer that does not say it has a local value. */
67 DECL_ALIGN (struct buffer
, buffer_defaults
);
69 /* A Lisp_Object pointer to the above, used for staticpro */
71 static Lisp_Object Vbuffer_defaults
;
73 /* This structure marks which slots in a buffer have corresponding
74 default values in buffer_defaults.
75 Each such slot has a nonzero value in this structure.
76 The value has only one nonzero bit.
78 When a buffer has its own local value for a slot,
79 the entry for that slot (found in the same slot in this structure)
80 is turned on in the buffer's local_flags array.
82 If a slot in this structure is -1, then even though there may
83 be a DEFVAR_PER_BUFFER for the slot, there is no default value for it;
84 and the corresponding slot in buffer_defaults is not used.
86 If a slot is -2, then there is no DEFVAR_PER_BUFFER for it,
87 but there is a default value which is copied into each buffer.
89 If a slot in this structure corresponding to a DEFVAR_PER_BUFFER is
90 zero, that is a bug */
92 struct buffer buffer_local_flags
;
94 /* This structure holds the names of symbols whose values may be
95 buffer-local. It is indexed and accessed in the same way as the above. */
97 DECL_ALIGN (struct buffer
, buffer_local_symbols
);
99 /* A Lisp_Object pointer to the above, used for staticpro */
100 static Lisp_Object Vbuffer_local_symbols
;
102 /* Flags indicating which built-in buffer-local variables
103 are permanent locals. */
104 static char buffer_permanent_local_flags
[MAX_PER_BUFFER_VARS
];
106 /* Number of per-buffer variables used. */
108 int last_per_buffer_idx
;
110 EXFUN (Fset_buffer
, 1);
111 void set_buffer_internal
P_ ((struct buffer
*b
));
112 void set_buffer_internal_1
P_ ((struct buffer
*b
));
113 static void call_overlay_mod_hooks
P_ ((Lisp_Object list
, Lisp_Object overlay
,
114 int after
, Lisp_Object arg1
,
115 Lisp_Object arg2
, Lisp_Object arg3
));
116 static void swap_out_buffer_local_variables
P_ ((struct buffer
*b
));
117 static void reset_buffer_local_variables
P_ ((struct buffer
*b
, int permanent_too
));
119 /* Alist of all buffer names vs the buffers. */
120 /* This used to be a variable, but is no longer,
121 to prevent lossage due to user rplac'ing this alist or its elements. */
122 Lisp_Object Vbuffer_alist
;
124 /* Functions to call before and after each text change. */
125 Lisp_Object Vbefore_change_functions
;
126 Lisp_Object Vafter_change_functions
;
128 Lisp_Object Vtransient_mark_mode
;
130 /* t means ignore all read-only text properties.
131 A list means ignore such a property if its value is a member of the list.
132 Any non-nil value means ignore buffer-read-only. */
133 Lisp_Object Vinhibit_read_only
;
135 /* List of functions to call that can query about killing a buffer.
136 If any of these functions returns nil, we don't kill it. */
137 Lisp_Object Vkill_buffer_query_functions
;
138 Lisp_Object Qkill_buffer_query_functions
;
140 /* Hook run before changing a major mode. */
141 Lisp_Object Vchange_major_mode_hook
, Qchange_major_mode_hook
;
143 /* List of functions to call before changing an unmodified buffer. */
144 Lisp_Object Vfirst_change_hook
;
146 Lisp_Object Qfirst_change_hook
;
147 Lisp_Object Qbefore_change_functions
;
148 Lisp_Object Qafter_change_functions
;
149 Lisp_Object Qucs_set_table_for_input
;
151 /* If nonzero, all modification hooks are suppressed. */
152 int inhibit_modification_hooks
;
154 Lisp_Object Qfundamental_mode
, Qmode_class
, Qpermanent_local
;
155 Lisp_Object Qpermanent_local_hook
;
157 Lisp_Object Qprotected_field
;
159 Lisp_Object QSFundamental
; /* A string "Fundamental" */
161 Lisp_Object Qkill_buffer_hook
;
163 Lisp_Object Qget_file_buffer
;
165 Lisp_Object Qoverlayp
;
167 Lisp_Object Qpriority
, Qwindow
, Qevaporate
, Qbefore_string
, Qafter_string
;
169 Lisp_Object Qmodification_hooks
;
170 Lisp_Object Qinsert_in_front_hooks
;
171 Lisp_Object Qinsert_behind_hooks
;
173 static void alloc_buffer_text
P_ ((struct buffer
*, size_t));
174 static void free_buffer_text
P_ ((struct buffer
*b
));
175 static struct Lisp_Overlay
* copy_overlays
P_ ((struct buffer
*, struct Lisp_Overlay
*));
176 static void modify_overlay
P_ ((struct buffer
*, EMACS_INT
, EMACS_INT
));
177 static Lisp_Object buffer_lisp_local_variables
P_ ((struct buffer
*));
179 extern char * emacs_strerror
P_ ((int));
181 /* For debugging; temporary. See set_buffer_internal. */
182 /* Lisp_Object Qlisp_mode, Vcheck_symbol; */
189 error ("No buffer named %s", SDATA (spec
));
190 error ("Invalid buffer argument");
193 DEFUN ("buffer-live-p", Fbuffer_live_p
, Sbuffer_live_p
, 1, 1, 0,
194 doc
: /* Return non-nil if OBJECT is a buffer which has not been killed.
195 Value is nil if OBJECT is not a buffer or if it has been killed. */)
199 return ((BUFFERP (object
) && ! NILP (XBUFFER (object
)->name
))
203 DEFUN ("buffer-list", Fbuffer_list
, Sbuffer_list
, 0, 1, 0,
204 doc
: /* Return a list of all existing live buffers.
205 If the optional arg FRAME is a frame, we return the buffer list
206 in the proper order for that frame: the buffers in FRAME's `buffer-list'
207 frame parameter come first, followed by the rest of the buffers. */)
212 general
= Fmapcar (Qcdr
, Vbuffer_alist
);
216 Lisp_Object framelist
, prevlist
, tail
;
221 framelist
= Fcopy_sequence (XFRAME (frame
)->buffer_list
);
222 prevlist
= Fnreverse (Fcopy_sequence (XFRAME (frame
)->buried_buffer_list
));
224 /* Remove from GENERAL any buffer that duplicates one in
225 FRAMELIST or PREVLIST. */
229 general
= Fdelq (XCAR (tail
), general
);
235 general
= Fdelq (XCAR (tail
), general
);
242 return Fnconc (3, args
);
248 /* Like Fassoc, but use Fstring_equal to compare
249 (which ignores text properties),
250 and don't ever QUIT. */
253 assoc_ignore_text_properties (key
, list
)
254 register Lisp_Object key
;
257 register Lisp_Object tail
;
258 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
260 register Lisp_Object elt
, tem
;
262 tem
= Fstring_equal (Fcar (elt
), key
);
269 DEFUN ("get-buffer", Fget_buffer
, Sget_buffer
, 1, 1, 0,
270 doc
: /* Return the buffer named BUFFER-OR-NAME.
271 BUFFER-OR-NAME must be either a string or a buffer. If BUFFER-OR-NAME
272 is a string and there is no buffer with that name, return nil. If
273 BUFFER-OR-NAME is a buffer, return it as given. */)
275 register Lisp_Object buffer_or_name
;
277 if (BUFFERP (buffer_or_name
))
278 return buffer_or_name
;
279 CHECK_STRING (buffer_or_name
);
281 return Fcdr (assoc_ignore_text_properties (buffer_or_name
, Vbuffer_alist
));
284 DEFUN ("get-file-buffer", Fget_file_buffer
, Sget_file_buffer
, 1, 1, 0,
285 doc
: /* Return the buffer visiting file FILENAME (a string).
286 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
287 If there is no such live buffer, return nil.
288 See also `find-buffer-visiting'. */)
290 register Lisp_Object filename
;
292 register Lisp_Object tail
, buf
, tem
;
295 CHECK_STRING (filename
);
296 filename
= Fexpand_file_name (filename
, Qnil
);
298 /* If the file name has special constructs in it,
299 call the corresponding file handler. */
300 handler
= Ffind_file_name_handler (filename
, Qget_file_buffer
);
302 return call2 (handler
, Qget_file_buffer
, filename
);
304 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
306 buf
= Fcdr (XCAR (tail
));
307 if (!BUFFERP (buf
)) continue;
308 if (!STRINGP (XBUFFER (buf
)->filename
)) continue;
309 tem
= Fstring_equal (XBUFFER (buf
)->filename
, filename
);
317 get_truename_buffer (filename
)
318 register Lisp_Object filename
;
320 register Lisp_Object tail
, buf
, tem
;
322 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
324 buf
= Fcdr (XCAR (tail
));
325 if (!BUFFERP (buf
)) continue;
326 if (!STRINGP (XBUFFER (buf
)->file_truename
)) continue;
327 tem
= Fstring_equal (XBUFFER (buf
)->file_truename
, filename
);
334 /* Incremented for each buffer created, to assign the buffer number. */
337 DEFUN ("get-buffer-create", Fget_buffer_create
, Sget_buffer_create
, 1, 1, 0,
338 doc
: /* Return the buffer specified by BUFFER-OR-NAME, creating a new one if needed.
339 If BUFFER-OR-NAME is a string and a live buffer with that name exists,
340 return that buffer. If no such buffer exists, create a new buffer with
341 that name and return it. If BUFFER-OR-NAME starts with a space, the new
342 buffer does not keep undo information.
344 If BUFFER-OR-NAME is a buffer instead of a string, return it as given,
345 even if it is dead. The return value is never nil. */)
347 register Lisp_Object buffer_or_name
;
349 register Lisp_Object buffer
, name
;
350 register struct buffer
*b
;
352 buffer
= Fget_buffer (buffer_or_name
);
356 if (SCHARS (buffer_or_name
) == 0)
357 error ("Empty string for buffer name is not allowed");
359 b
= allocate_buffer ();
361 /* An ordinary buffer uses its own struct buffer_text. */
362 b
->text
= &b
->own_text
;
365 BUF_GAP_SIZE (b
) = 20;
367 /* We allocate extra 1-byte at the tail and keep it always '\0' for
368 anchoring a search. */
369 alloc_buffer_text (b
, BUF_GAP_SIZE (b
) + 1);
371 if (! BUF_BEG_ADDR (b
))
372 buffer_memory_full ();
379 BUF_PT_BYTE (b
) = BEG_BYTE
;
380 BUF_GPT_BYTE (b
) = BEG_BYTE
;
381 BUF_BEGV_BYTE (b
) = BEG_BYTE
;
382 BUF_ZV_BYTE (b
) = BEG_BYTE
;
383 BUF_Z_BYTE (b
) = BEG_BYTE
;
385 BUF_CHARS_MODIFF (b
) = 1;
386 BUF_OVERLAY_MODIFF (b
) = 1;
387 BUF_SAVE_MODIFF (b
) = 1;
388 BUF_INTERVALS (b
) = 0;
389 BUF_UNCHANGED_MODIFIED (b
) = 1;
390 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = 1;
391 BUF_END_UNCHANGED (b
) = 0;
392 BUF_BEG_UNCHANGED (b
) = 0;
393 *(BUF_GPT_ADDR (b
)) = *(BUF_Z_ADDR (b
)) = 0; /* Put an anchor '\0'. */
395 b
->newline_cache
= 0;
396 b
->width_run_cache
= 0;
397 b
->width_table
= Qnil
;
398 b
->prevent_redisplay_optimizations_p
= 1;
400 /* Put this on the chain of all buffers including killed ones. */
401 b
->next
= all_buffers
;
404 /* An ordinary buffer normally doesn't need markers
405 to handle BEGV and ZV. */
407 b
->begv_marker
= Qnil
;
410 name
= Fcopy_sequence (buffer_or_name
);
411 STRING_SET_INTERVALS (name
, NULL_INTERVAL
);
414 b
->undo_list
= (SREF (name
, 0) != ' ') ? Qnil
: Qt
;
417 reset_buffer_local_variables (b
, 1);
419 b
->mark
= Fmake_marker ();
420 BUF_MARKERS (b
) = NULL
;
423 /* Put this in the alist of all live buffers. */
424 XSETBUFFER (buffer
, b
);
425 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buffer
), Qnil
));
427 /* An error in calling the function here (should someone redefine it)
428 can lead to infinite regress until you run out of stack. rms
429 says that's not worth protecting against. */
430 if (!NILP (Ffboundp (Qucs_set_table_for_input
)))
431 /* buffer is on buffer-alist, so no gcpro. */
432 call1 (Qucs_set_table_for_input
, buffer
);
438 /* Return a list of overlays which is a copy of the overlay list
439 LIST, but for buffer B. */
441 static struct Lisp_Overlay
*
442 copy_overlays (b
, list
)
444 struct Lisp_Overlay
*list
;
447 struct Lisp_Overlay
*result
= NULL
, *tail
= NULL
;
449 XSETBUFFER (buffer
, b
);
451 for (; list
; list
= list
->next
)
453 Lisp_Object overlay
, start
, end
, old_overlay
;
456 XSETMISC (old_overlay
, list
);
457 charpos
= marker_position (OVERLAY_START (old_overlay
));
458 start
= Fmake_marker ();
459 Fset_marker (start
, make_number (charpos
), buffer
);
460 XMARKER (start
)->insertion_type
461 = XMARKER (OVERLAY_START (old_overlay
))->insertion_type
;
463 charpos
= marker_position (OVERLAY_END (old_overlay
));
464 end
= Fmake_marker ();
465 Fset_marker (end
, make_number (charpos
), buffer
);
466 XMARKER (end
)->insertion_type
467 = XMARKER (OVERLAY_END (old_overlay
))->insertion_type
;
469 overlay
= allocate_misc ();
470 XMISCTYPE (overlay
) = Lisp_Misc_Overlay
;
471 OVERLAY_START (overlay
) = start
;
472 OVERLAY_END (overlay
) = end
;
473 OVERLAY_PLIST (overlay
) = Fcopy_sequence (OVERLAY_PLIST (old_overlay
));
474 XOVERLAY (overlay
)->next
= NULL
;
477 tail
= tail
->next
= XOVERLAY (overlay
);
479 result
= tail
= XOVERLAY (overlay
);
486 /* Clone per-buffer values of buffer FROM.
488 Buffer TO gets the same per-buffer values as FROM, with the
489 following exceptions: (1) TO's name is left untouched, (2) markers
490 are copied and made to refer to TO, and (3) overlay lists are
494 clone_per_buffer_values (from
, to
)
495 struct buffer
*from
, *to
;
497 Lisp_Object to_buffer
;
500 XSETBUFFER (to_buffer
, to
);
502 /* buffer-local Lisp variables start at `undo_list',
503 tho only the ones from `name' on are GC'd normally. */
504 for (offset
= PER_BUFFER_VAR_OFFSET (undo_list
);
506 offset
+= sizeof (Lisp_Object
))
510 /* Don't touch the `name' which should be unique for every buffer. */
511 if (offset
== PER_BUFFER_VAR_OFFSET (name
))
514 obj
= PER_BUFFER_VALUE (from
, offset
);
517 struct Lisp_Marker
*m
= XMARKER (obj
);
518 obj
= Fmake_marker ();
519 XMARKER (obj
)->insertion_type
= m
->insertion_type
;
520 set_marker_both (obj
, to_buffer
, m
->charpos
, m
->bytepos
);
523 PER_BUFFER_VALUE (to
, offset
) = obj
;
526 bcopy (from
->local_flags
, to
->local_flags
, sizeof to
->local_flags
);
528 to
->overlays_before
= copy_overlays (to
, from
->overlays_before
);
529 to
->overlays_after
= copy_overlays (to
, from
->overlays_after
);
531 /* Get (a copy of) the alist of Lisp-level local variables of FROM
532 and install that in TO. */
533 to
->local_var_alist
= buffer_lisp_local_variables (from
);
536 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer
, Smake_indirect_buffer
,
538 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ",
539 doc
: /* Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.
540 BASE-BUFFER should be a live buffer, or the name of an existing buffer.
541 NAME should be a string which is not the name of an existing buffer.
542 Optional argument CLONE non-nil means preserve BASE-BUFFER's state,
543 such as major and minor modes, in the indirect buffer.
544 CLONE nil means the indirect buffer's state is reset to default values. */)
545 (base_buffer
, name
, clone
)
546 Lisp_Object base_buffer
, name
, clone
;
548 Lisp_Object buf
, tem
;
552 buf
= Fget_buffer (name
);
554 error ("Buffer name `%s' is in use", SDATA (name
));
557 base_buffer
= Fget_buffer (base_buffer
);
558 if (NILP (base_buffer
))
559 error ("No such buffer: `%s'", SDATA (tem
));
560 if (NILP (XBUFFER (base_buffer
)->name
))
561 error ("Base buffer has been killed");
563 if (SCHARS (name
) == 0)
564 error ("Empty string for buffer name is not allowed");
566 b
= allocate_buffer ();
568 b
->base_buffer
= (XBUFFER (base_buffer
)->base_buffer
569 ? XBUFFER (base_buffer
)->base_buffer
570 : XBUFFER (base_buffer
));
572 /* Use the base buffer's text object. */
573 b
->text
= b
->base_buffer
->text
;
575 BUF_BEGV (b
) = BUF_BEGV (b
->base_buffer
);
576 BUF_ZV (b
) = BUF_ZV (b
->base_buffer
);
577 BUF_PT (b
) = BUF_PT (b
->base_buffer
);
578 BUF_BEGV_BYTE (b
) = BUF_BEGV_BYTE (b
->base_buffer
);
579 BUF_ZV_BYTE (b
) = BUF_ZV_BYTE (b
->base_buffer
);
580 BUF_PT_BYTE (b
) = BUF_PT_BYTE (b
->base_buffer
);
582 b
->newline_cache
= 0;
583 b
->width_run_cache
= 0;
584 b
->width_table
= Qnil
;
586 /* Put this on the chain of all buffers including killed ones. */
587 b
->next
= all_buffers
;
590 name
= Fcopy_sequence (name
);
591 STRING_SET_INTERVALS (name
, NULL_INTERVAL
);
595 reset_buffer_local_variables (b
, 1);
597 /* Put this in the alist of all live buffers. */
599 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buf
), Qnil
));
601 b
->mark
= Fmake_marker ();
604 /* The multibyte status belongs to the base buffer. */
605 b
->enable_multibyte_characters
= b
->base_buffer
->enable_multibyte_characters
;
607 /* Make sure the base buffer has markers for its narrowing. */
608 if (NILP (b
->base_buffer
->pt_marker
))
610 b
->base_buffer
->pt_marker
= Fmake_marker ();
611 set_marker_both (b
->base_buffer
->pt_marker
, base_buffer
,
612 BUF_PT (b
->base_buffer
),
613 BUF_PT_BYTE (b
->base_buffer
));
615 if (NILP (b
->base_buffer
->begv_marker
))
617 b
->base_buffer
->begv_marker
= Fmake_marker ();
618 set_marker_both (b
->base_buffer
->begv_marker
, base_buffer
,
619 BUF_BEGV (b
->base_buffer
),
620 BUF_BEGV_BYTE (b
->base_buffer
));
622 if (NILP (b
->base_buffer
->zv_marker
))
624 b
->base_buffer
->zv_marker
= Fmake_marker ();
625 set_marker_both (b
->base_buffer
->zv_marker
, base_buffer
,
626 BUF_ZV (b
->base_buffer
),
627 BUF_ZV_BYTE (b
->base_buffer
));
628 XMARKER (b
->base_buffer
->zv_marker
)->insertion_type
= 1;
633 /* Give the indirect buffer markers for its narrowing. */
634 b
->pt_marker
= Fmake_marker ();
635 set_marker_both (b
->pt_marker
, buf
, BUF_PT (b
), BUF_PT_BYTE (b
));
636 b
->begv_marker
= Fmake_marker ();
637 set_marker_both (b
->begv_marker
, buf
, BUF_BEGV (b
), BUF_BEGV_BYTE (b
));
638 b
->zv_marker
= Fmake_marker ();
639 set_marker_both (b
->zv_marker
, buf
, BUF_ZV (b
), BUF_ZV_BYTE (b
));
640 XMARKER (b
->zv_marker
)->insertion_type
= 1;
644 struct buffer
*old_b
= current_buffer
;
646 clone_per_buffer_values (b
->base_buffer
, b
);
648 b
->file_truename
= Qnil
;
649 b
->display_count
= make_number (0);
651 b
->auto_save_file_name
= Qnil
;
652 set_buffer_internal_1 (b
);
653 Fset (intern ("buffer-save-without-query"), Qnil
);
654 Fset (intern ("buffer-file-number"), Qnil
);
655 Fset (intern ("buffer-stale-function"), Qnil
);
656 set_buffer_internal_1 (old_b
);
663 delete_all_overlays (b
)
668 /* `reset_buffer' blindly sets the list of overlays to NULL, so we
669 have to empty the list, otherwise we end up with overlays that
670 think they belong to this buffer while the buffer doesn't know about
672 while (b
->overlays_before
)
674 XSETMISC (overlay
, b
->overlays_before
);
675 Fdelete_overlay (overlay
);
677 while (b
->overlays_after
)
679 XSETMISC (overlay
, b
->overlays_after
);
680 Fdelete_overlay (overlay
);
682 eassert (b
->overlays_before
== NULL
);
683 eassert (b
->overlays_after
== NULL
);
686 /* Reinitialize everything about a buffer except its name and contents
688 If called on an already-initialized buffer, the list of overlays
689 should be deleted before calling this function, otherwise we end up
690 with overlays that claim to belong to the buffer but the buffer
691 claims it doesn't belong to it. */
695 register struct buffer
*b
;
698 b
->file_truename
= Qnil
;
699 b
->directory
= (current_buffer
) ? current_buffer
->directory
: Qnil
;
701 XSETFASTINT (b
->save_length
, 0);
702 b
->last_window_start
= 1;
703 /* It is more conservative to start out "changed" than "unchanged". */
705 b
->prevent_redisplay_optimizations_p
= 1;
707 b
->auto_save_modified
= 0;
708 b
->auto_save_failure_time
= -1;
709 b
->auto_save_file_name
= Qnil
;
711 b
->overlays_before
= NULL
;
712 b
->overlays_after
= NULL
;
713 b
->overlay_center
= BEG
;
714 b
->mark_active
= Qnil
;
715 b
->point_before_scroll
= Qnil
;
716 b
->file_format
= Qnil
;
717 b
->auto_save_file_format
= Qt
;
718 b
->last_selected_window
= Qnil
;
719 XSETINT (b
->display_count
, 0);
720 b
->display_time
= Qnil
;
721 b
->enable_multibyte_characters
= buffer_defaults
.enable_multibyte_characters
;
722 b
->cursor_type
= buffer_defaults
.cursor_type
;
723 b
->extra_line_spacing
= buffer_defaults
.extra_line_spacing
;
725 b
->display_error_modiff
= 0;
728 /* Reset buffer B's local variables info.
729 Don't use this on a buffer that has already been in use;
730 it does not treat permanent locals consistently.
731 Instead, use Fkill_all_local_variables.
733 If PERMANENT_TOO is 1, then we reset permanent
734 buffer-local variables. If PERMANENT_TOO is 0,
735 we preserve those. */
738 reset_buffer_local_variables (b
, permanent_too
)
739 register struct buffer
*b
;
745 /* Reset the major mode to Fundamental, together with all the
746 things that depend on the major mode.
747 default-major-mode is handled at a higher level.
748 We ignore it here. */
749 b
->major_mode
= Qfundamental_mode
;
751 b
->mode_name
= QSFundamental
;
752 b
->minor_modes
= Qnil
;
754 /* If the standard case table has been altered and invalidated,
755 fix up its insides first. */
756 if (! (CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[0])
757 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[1])
758 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[2])))
759 Fset_standard_case_table (Vascii_downcase_table
);
761 b
->downcase_table
= Vascii_downcase_table
;
762 b
->upcase_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[0];
763 b
->case_canon_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[1];
764 b
->case_eqv_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[2];
765 b
->invisibility_spec
= Qt
;
767 b
->buffer_file_type
= Qnil
;
770 /* Reset all (or most) per-buffer variables to their defaults. */
772 b
->local_var_alist
= Qnil
;
775 Lisp_Object tmp
, prop
, last
= Qnil
;
776 for (tmp
= b
->local_var_alist
; CONSP (tmp
); tmp
= XCDR (tmp
))
777 if (CONSP (XCAR (tmp
))
778 && SYMBOLP (XCAR (XCAR (tmp
)))
779 && !NILP (prop
= Fget (XCAR (XCAR (tmp
)), Qpermanent_local
)))
781 /* If permanent-local, keep it. */
783 if (EQ (prop
, Qpermanent_local_hook
))
785 /* This is a partially permanent hook variable.
786 Preserve only the elements that want to be preserved. */
787 Lisp_Object list
, newlist
;
788 list
= XCDR (XCAR (tmp
));
792 for (newlist
= Qnil
; CONSP (list
); list
= XCDR (list
))
794 Lisp_Object elt
= XCAR (list
);
795 /* Preserve element ELT if it's t,
796 if it is a function with a `permanent-local-hook' property,
797 or if it's not a symbol. */
800 || !NILP (Fget (elt
, Qpermanent_local_hook
)))
801 newlist
= Fcons (elt
, newlist
);
803 XSETCDR (XCAR (tmp
), Fnreverse (newlist
));
806 /* Delete this local variable. */
807 else if (NILP (last
))
808 b
->local_var_alist
= XCDR (tmp
);
810 XSETCDR (last
, XCDR (tmp
));
813 for (i
= 0; i
< last_per_buffer_idx
; ++i
)
814 if (permanent_too
|| buffer_permanent_local_flags
[i
] == 0)
815 SET_PER_BUFFER_VALUE_P (b
, i
, 0);
817 /* For each slot that has a default value,
818 copy that into the slot. */
820 /* buffer-local Lisp variables start at `undo_list',
821 tho only the ones from `name' on are GC'd normally. */
822 for (offset
= PER_BUFFER_VAR_OFFSET (undo_list
);
824 offset
+= sizeof (Lisp_Object
))
826 int idx
= PER_BUFFER_IDX (offset
);
829 || buffer_permanent_local_flags
[idx
] == 0))
830 /* Is -2 used anywhere? */
832 PER_BUFFER_VALUE (b
, offset
) = PER_BUFFER_DEFAULT (offset
);
836 /* We split this away from generate-new-buffer, because rename-buffer
837 and set-visited-file-name ought to be able to use this to really
838 rename the buffer properly. */
840 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name
, Sgenerate_new_buffer_name
,
842 doc
: /* Return a string that is the name of no existing buffer based on NAME.
843 If there is no live buffer named NAME, then return NAME.
844 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
845 \(starting at 2) until an unused name is found, and then return that name.
846 Optional second argument IGNORE specifies a name that is okay to use (if
847 it is in the sequence to be tried) even if a buffer with that name exists. */)
849 register Lisp_Object name
, ignore
;
851 register Lisp_Object gentemp
, tem
;
857 tem
= Fstring_equal (name
, ignore
);
860 tem
= Fget_buffer (name
);
867 sprintf (number
, "<%d>", ++count
);
868 gentemp
= concat2 (name
, build_string (number
));
869 tem
= Fstring_equal (gentemp
, ignore
);
872 tem
= Fget_buffer (gentemp
);
879 DEFUN ("buffer-name", Fbuffer_name
, Sbuffer_name
, 0, 1, 0,
880 doc
: /* Return the name of BUFFER, as a string.
881 BUFFER defaults to the current buffer.
882 Return nil if BUFFER has been killed. */)
884 register Lisp_Object buffer
;
887 return current_buffer
->name
;
888 CHECK_BUFFER (buffer
);
889 return XBUFFER (buffer
)->name
;
892 DEFUN ("buffer-file-name", Fbuffer_file_name
, Sbuffer_file_name
, 0, 1, 0,
893 doc
: /* Return name of file BUFFER is visiting, or nil if none.
894 No argument or nil as argument means use the current buffer. */)
896 register Lisp_Object buffer
;
899 return current_buffer
->filename
;
900 CHECK_BUFFER (buffer
);
901 return XBUFFER (buffer
)->filename
;
904 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer
, Sbuffer_base_buffer
,
906 doc
: /* Return the base buffer of indirect buffer BUFFER.
907 If BUFFER is not indirect, return nil.
908 BUFFER defaults to the current buffer. */)
910 register Lisp_Object buffer
;
913 Lisp_Object base_buffer
;
916 base
= current_buffer
->base_buffer
;
919 CHECK_BUFFER (buffer
);
920 base
= XBUFFER (buffer
)->base_buffer
;
925 XSETBUFFER (base_buffer
, base
);
929 DEFUN ("buffer-local-value", Fbuffer_local_value
,
930 Sbuffer_local_value
, 2, 2, 0,
931 doc
: /* Return the value of VARIABLE in BUFFER.
932 If VARIABLE does not have a buffer-local binding in BUFFER, the value
933 is the default binding of the variable. */)
935 register Lisp_Object variable
;
936 register Lisp_Object buffer
;
938 register struct buffer
*buf
;
939 register Lisp_Object result
;
940 struct Lisp_Symbol
*sym
;
942 CHECK_SYMBOL (variable
);
943 CHECK_BUFFER (buffer
);
944 buf
= XBUFFER (buffer
);
946 sym
= indirect_variable (XSYMBOL (variable
));
947 XSETSYMBOL (variable
, sym
);
949 /* Look in local_var_list */
950 result
= Fassoc (variable
, buf
->local_var_alist
);
956 /* Look in special slots */
957 /* buffer-local Lisp variables start at `undo_list',
958 tho only the ones from `name' on are GC'd normally. */
959 for (offset
= PER_BUFFER_VAR_OFFSET (undo_list
);
960 offset
< sizeof (struct buffer
);
961 /* sizeof EMACS_INT == sizeof Lisp_Object */
962 offset
+= (sizeof (EMACS_INT
)))
964 idx
= PER_BUFFER_IDX (offset
);
965 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
966 && SYMBOLP (PER_BUFFER_SYMBOL (offset
))
967 && EQ (PER_BUFFER_SYMBOL (offset
), variable
))
969 result
= PER_BUFFER_VALUE (buf
, offset
);
976 result
= Fdefault_value (variable
);
980 Lisp_Object valcontents
;
981 Lisp_Object current_alist_element
;
983 /* What binding is loaded right now? */
984 valcontents
= sym
->value
;
985 current_alist_element
986 = XCAR (XBUFFER_LOCAL_VALUE (valcontents
)->cdr
);
988 /* The value of the currently loaded binding is not
989 stored in it, but rather in the realvalue slot.
990 Store that value into the binding it belongs to
991 in case that is the one we are about to use. */
993 Fsetcdr (current_alist_element
,
994 do_symval_forwarding (XBUFFER_LOCAL_VALUE (valcontents
)->realvalue
));
996 /* Now get the (perhaps updated) value out of the binding. */
997 result
= XCDR (result
);
1000 if (!EQ (result
, Qunbound
))
1003 xsignal1 (Qvoid_variable
, variable
);
1006 /* Return an alist of the Lisp-level buffer-local bindings of
1007 buffer BUF. That is, don't include the variables maintained
1008 in special slots in the buffer object. */
1011 buffer_lisp_local_variables (buf
)
1014 Lisp_Object result
= Qnil
;
1015 register Lisp_Object tail
;
1016 for (tail
= buf
->local_var_alist
; CONSP (tail
); tail
= XCDR (tail
))
1018 Lisp_Object val
, elt
;
1022 /* Reference each variable in the alist in buf.
1023 If inquiring about the current buffer, this gets the current values,
1024 so store them into the alist so the alist is up to date.
1025 If inquiring about some other buffer, this swaps out any values
1026 for that buffer, making the alist up to date automatically. */
1027 val
= find_symbol_value (XCAR (elt
));
1028 /* Use the current buffer value only if buf is the current buffer. */
1029 if (buf
!= current_buffer
)
1032 /* If symbol is unbound, put just the symbol in the list. */
1033 if (EQ (val
, Qunbound
))
1034 result
= Fcons (XCAR (elt
), result
);
1035 /* Otherwise, put (symbol . value) in the list. */
1037 result
= Fcons (Fcons (XCAR (elt
), val
), result
);
1043 DEFUN ("buffer-local-variables", Fbuffer_local_variables
,
1044 Sbuffer_local_variables
, 0, 1, 0,
1045 doc
: /* Return an alist of variables that are buffer-local in BUFFER.
1046 Most elements look like (SYMBOL . VALUE), describing one variable.
1047 For a symbol that is locally unbound, just the symbol appears in the value.
1048 Note that storing new VALUEs in these elements doesn't change the variables.
1049 No argument or nil as argument means use current buffer as BUFFER. */)
1051 register Lisp_Object buffer
;
1053 register struct buffer
*buf
;
1054 register Lisp_Object result
;
1057 buf
= current_buffer
;
1060 CHECK_BUFFER (buffer
);
1061 buf
= XBUFFER (buffer
);
1064 result
= buffer_lisp_local_variables (buf
);
1066 /* Add on all the variables stored in special slots. */
1070 /* buffer-local Lisp variables start at `undo_list',
1071 tho only the ones from `name' on are GC'd normally. */
1072 for (offset
= PER_BUFFER_VAR_OFFSET (undo_list
);
1073 offset
< sizeof (struct buffer
);
1074 /* sizeof EMACS_INT == sizeof Lisp_Object */
1075 offset
+= (sizeof (EMACS_INT
)))
1077 idx
= PER_BUFFER_IDX (offset
);
1078 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
1079 && SYMBOLP (PER_BUFFER_SYMBOL (offset
)))
1080 result
= Fcons (Fcons (PER_BUFFER_SYMBOL (offset
),
1081 PER_BUFFER_VALUE (buf
, offset
)),
1089 DEFUN ("buffer-modified-p", Fbuffer_modified_p
, Sbuffer_modified_p
,
1091 doc
: /* Return t if BUFFER was modified since its file was last read or saved.
1092 No argument or nil as argument means use current buffer as BUFFER. */)
1094 register Lisp_Object buffer
;
1096 register struct buffer
*buf
;
1098 buf
= current_buffer
;
1101 CHECK_BUFFER (buffer
);
1102 buf
= XBUFFER (buffer
);
1105 return BUF_SAVE_MODIFF (buf
) < BUF_MODIFF (buf
) ? Qt
: Qnil
;
1108 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p
, Sset_buffer_modified_p
,
1110 doc
: /* Mark current buffer as modified or unmodified according to FLAG.
1111 A non-nil FLAG means mark the buffer modified. */)
1113 register Lisp_Object flag
;
1115 register int already
;
1116 register Lisp_Object fn
;
1117 Lisp_Object buffer
, window
;
1119 #ifdef CLASH_DETECTION
1120 /* If buffer becoming modified, lock the file.
1121 If buffer becoming unmodified, unlock the file. */
1123 fn
= current_buffer
->file_truename
;
1124 /* Test buffer-file-name so that binding it to nil is effective. */
1125 if (!NILP (fn
) && ! NILP (current_buffer
->filename
))
1127 already
= SAVE_MODIFF
< MODIFF
;
1128 if (!already
&& !NILP (flag
))
1130 else if (already
&& NILP (flag
))
1133 #endif /* CLASH_DETECTION */
1135 SAVE_MODIFF
= NILP (flag
) ? MODIFF
: 0;
1137 /* Set update_mode_lines only if buffer is displayed in some window.
1138 Packages like jit-lock or lazy-lock preserve a buffer's modified
1139 state by recording/restoring the state around blocks of code.
1140 Setting update_mode_lines makes redisplay consider all windows
1141 (on all frames). Stealth fontification of buffers not displayed
1142 would incur additional redisplay costs if we'd set
1143 update_modes_lines unconditionally.
1145 Ideally, I think there should be another mechanism for fontifying
1146 buffers without "modifying" buffers, or redisplay should be
1147 smarter about updating the `*' in mode lines. --gerd */
1148 XSETBUFFER (buffer
, current_buffer
);
1149 window
= Fget_buffer_window (buffer
, Qt
);
1150 if (WINDOWP (window
))
1152 ++update_mode_lines
;
1153 current_buffer
->prevent_redisplay_optimizations_p
= 1;
1159 DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p
,
1160 Srestore_buffer_modified_p
, 1, 1, 0,
1161 doc
: /* Like `set-buffer-modified-p', with a difference concerning redisplay.
1162 It is not ensured that mode lines will be updated to show the modified
1163 state of the current buffer. Use with care. */)
1167 #ifdef CLASH_DETECTION
1170 /* If buffer becoming modified, lock the file.
1171 If buffer becoming unmodified, unlock the file. */
1173 fn
= current_buffer
->file_truename
;
1174 /* Test buffer-file-name so that binding it to nil is effective. */
1175 if (!NILP (fn
) && ! NILP (current_buffer
->filename
))
1177 int already
= SAVE_MODIFF
< MODIFF
;
1178 if (!already
&& !NILP (flag
))
1180 else if (already
&& NILP (flag
))
1183 #endif /* CLASH_DETECTION */
1185 SAVE_MODIFF
= NILP (flag
) ? MODIFF
: 0;
1189 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick
, Sbuffer_modified_tick
,
1191 doc
: /* Return BUFFER's tick counter, incremented for each change in text.
1192 Each buffer has a tick counter which is incremented each time the
1193 text in that buffer is changed. It wraps around occasionally.
1194 No argument or nil as argument means use current buffer as BUFFER. */)
1196 register Lisp_Object buffer
;
1198 register struct buffer
*buf
;
1200 buf
= current_buffer
;
1203 CHECK_BUFFER (buffer
);
1204 buf
= XBUFFER (buffer
);
1207 return make_number (BUF_MODIFF (buf
));
1210 DEFUN ("buffer-chars-modified-tick", Fbuffer_chars_modified_tick
,
1211 Sbuffer_chars_modified_tick
, 0, 1, 0,
1212 doc
: /* Return BUFFER's character-change tick counter.
1213 Each buffer has a character-change tick counter, which is set to the
1214 value of the buffer's tick counter \(see `buffer-modified-tick'), each
1215 time text in that buffer is inserted or deleted. By comparing the
1216 values returned by two individual calls of `buffer-chars-modified-tick',
1217 you can tell whether a character change occurred in that buffer in
1218 between these calls. No argument or nil as argument means use current
1219 buffer as BUFFER. */)
1221 register Lisp_Object buffer
;
1223 register struct buffer
*buf
;
1225 buf
= current_buffer
;
1228 CHECK_BUFFER (buffer
);
1229 buf
= XBUFFER (buffer
);
1232 return make_number (BUF_CHARS_MODIFF (buf
));
1235 DEFUN ("rename-buffer", Frename_buffer
, Srename_buffer
, 1, 2,
1236 "(list (read-string \"Rename buffer (to new name): \" \
1237 nil 'buffer-name-history (buffer-name (current-buffer))) \
1238 current-prefix-arg)",
1239 doc
: /* Change current buffer's name to NEWNAME (a string).
1240 If second arg UNIQUE is nil or omitted, it is an error if a
1241 buffer named NEWNAME already exists.
1242 If UNIQUE is non-nil, come up with a new name using
1243 `generate-new-buffer-name'.
1244 Interactively, you can set UNIQUE with a prefix argument.
1245 We return the name we actually gave the buffer.
1246 This does not change the name of the visited file (if any). */)
1248 register Lisp_Object newname
, unique
;
1250 register Lisp_Object tem
, buf
;
1252 CHECK_STRING (newname
);
1254 if (SCHARS (newname
) == 0)
1255 error ("Empty string is invalid as a buffer name");
1257 tem
= Fget_buffer (newname
);
1260 /* Don't short-circuit if UNIQUE is t. That is a useful way to
1261 rename the buffer automatically so you can create another
1262 with the original name. It makes UNIQUE equivalent to
1263 (rename-buffer (generate-new-buffer-name NEWNAME)). */
1264 if (NILP (unique
) && XBUFFER (tem
) == current_buffer
)
1265 return current_buffer
->name
;
1267 newname
= Fgenerate_new_buffer_name (newname
, current_buffer
->name
);
1269 error ("Buffer name `%s' is in use", SDATA (newname
));
1272 current_buffer
->name
= newname
;
1274 /* Catch redisplay's attention. Unless we do this, the mode lines for
1275 any windows displaying current_buffer will stay unchanged. */
1276 update_mode_lines
++;
1278 XSETBUFFER (buf
, current_buffer
);
1279 Fsetcar (Frassq (buf
, Vbuffer_alist
), newname
);
1280 if (NILP (current_buffer
->filename
)
1281 && !NILP (current_buffer
->auto_save_file_name
))
1282 call0 (intern ("rename-auto-save-file"));
1283 /* Refetch since that last call may have done GC. */
1284 return current_buffer
->name
;
1287 DEFUN ("other-buffer", Fother_buffer
, Sother_buffer
, 0, 3, 0,
1288 doc
: /* Return most recently selected buffer other than BUFFER.
1289 Buffers not visible in windows are preferred to visible buffers,
1290 unless optional second argument VISIBLE-OK is non-nil.
1291 If the optional third argument FRAME is non-nil, use that frame's
1292 buffer list instead of the selected frame's buffer list.
1293 If no other buffer exists, the buffer `*scratch*' is returned.
1294 If BUFFER is omitted or nil, some interesting buffer is returned. */)
1295 (buffer
, visible_ok
, frame
)
1296 register Lisp_Object buffer
, visible_ok
, frame
;
1298 Lisp_Object
Fset_buffer_major_mode ();
1299 register Lisp_Object tail
, buf
, notsogood
, tem
, pred
, add_ons
;
1303 frame
= selected_frame
;
1305 tail
= Vbuffer_alist
;
1306 pred
= frame_buffer_predicate (frame
);
1308 /* Consider buffers that have been seen in the selected frame
1309 before other buffers. */
1311 tem
= frame_buffer_list (frame
);
1315 if (BUFFERP (XCAR (tem
)))
1316 add_ons
= Fcons (Fcons (Qnil
, XCAR (tem
)), add_ons
);
1319 tail
= nconc2 (Fnreverse (add_ons
), tail
);
1321 for (; CONSP (tail
); tail
= XCDR (tail
))
1323 buf
= Fcdr (XCAR (tail
));
1324 if (EQ (buf
, buffer
))
1328 if (NILP (XBUFFER (buf
)->name
))
1330 if (SREF (XBUFFER (buf
)->name
, 0) == ' ')
1332 /* If the selected frame has a buffer_predicate,
1333 disregard buffers that don't fit the predicate. */
1336 tem
= call1 (pred
, buf
);
1341 if (NILP (visible_ok
))
1342 tem
= Fget_buffer_window (buf
, Qvisible
);
1347 if (NILP (notsogood
))
1350 if (!NILP (notsogood
))
1352 buf
= Fget_buffer (build_string ("*scratch*"));
1355 buf
= Fget_buffer_create (build_string ("*scratch*"));
1356 Fset_buffer_major_mode (buf
);
1361 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo
, Sbuffer_enable_undo
,
1363 doc
: /* Start keeping undo information for buffer BUFFER.
1364 No argument or nil as argument means do this for the current buffer. */)
1366 register Lisp_Object buffer
;
1368 Lisp_Object real_buffer
;
1371 XSETBUFFER (real_buffer
, current_buffer
);
1374 real_buffer
= Fget_buffer (buffer
);
1375 if (NILP (real_buffer
))
1379 if (EQ (XBUFFER (real_buffer
)->undo_list
, Qt
))
1380 XBUFFER (real_buffer
)->undo_list
= Qnil
;
1386 DEFVAR_LISP ("kill-buffer-hook", no_cell, "\
1387 Hook to be run (by `run-hooks', which see) when a buffer is killed.\n\
1388 The buffer being killed will be current while the hook is running.\n\
1391 DEFUN ("kill-buffer", Fkill_buffer
, Skill_buffer
, 0, 1, "bKill buffer: ",
1392 doc
: /* Kill buffer BUFFER-OR-NAME.
1393 The argument may be a buffer or the name of an existing buffer.
1394 Argument nil or omitted means kill the current buffer. Return t if the
1395 buffer is actually killed, nil otherwise.
1397 This function calls `replace-buffer-in-windows' for cleaning up all
1398 windows currently displaying the buffer to be killed. The functions in
1399 `kill-buffer-query-functions' are called with the buffer to be killed as
1400 the current buffer. If any of them returns nil, the buffer is not
1401 killed. The hook `kill-buffer-hook' is run before the buffer is
1402 actually killed. The buffer being killed will be current while the hook
1405 Any processes that have this buffer as the `process-buffer' are killed
1408 Lisp_Object buffer_or_name
;
1411 register struct buffer
*b
;
1412 register Lisp_Object tem
;
1413 register struct Lisp_Marker
*m
;
1414 struct gcpro gcpro1
;
1416 if (NILP (buffer_or_name
))
1417 buffer
= Fcurrent_buffer ();
1419 buffer
= Fget_buffer (buffer_or_name
);
1421 nsberror (buffer_or_name
);
1423 b
= XBUFFER (buffer
);
1425 /* Avoid trouble for buffer already dead. */
1429 /* Query if the buffer is still modified. */
1430 if (INTERACTIVE
&& !NILP (b
->filename
)
1431 && BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
1434 tem
= do_yes_or_no_p (format2 ("Buffer %s modified; kill anyway? ",
1435 b
->name
, make_number (0)));
1441 /* Run hooks with the buffer to be killed the current buffer. */
1443 int count
= SPECPDL_INDEX ();
1444 Lisp_Object arglist
[1];
1446 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1447 set_buffer_internal (b
);
1449 /* First run the query functions; if any query is answered no,
1450 don't kill the buffer. */
1451 arglist
[0] = Qkill_buffer_query_functions
;
1452 tem
= Frun_hook_with_args_until_failure (1, arglist
);
1454 return unbind_to (count
, Qnil
);
1456 /* Then run the hooks. */
1457 Frun_hooks (1, &Qkill_buffer_hook
);
1458 unbind_to (count
, Qnil
);
1461 /* We have no more questions to ask. Verify that it is valid
1462 to kill the buffer. This must be done after the questions
1463 since anything can happen within do_yes_or_no_p. */
1465 /* Don't kill the minibuffer now current. */
1466 if (EQ (buffer
, XWINDOW (minibuf_window
)->buffer
))
1472 /* When we kill a base buffer, kill all its indirect buffers.
1473 We do it at this stage so nothing terrible happens if they
1474 ask questions or their hooks get errors. */
1475 if (! b
->base_buffer
)
1477 struct buffer
*other
;
1481 for (other
= all_buffers
; other
; other
= other
->next
)
1482 /* all_buffers contains dead buffers too;
1483 don't re-kill them. */
1484 if (other
->base_buffer
== b
&& !NILP (other
->name
))
1487 XSETBUFFER (buffer
, other
);
1488 Fkill_buffer (buffer
);
1494 /* Make this buffer not be current.
1495 In the process, notice if this is the sole visible buffer
1496 and give up if so. */
1497 if (b
== current_buffer
)
1499 tem
= Fother_buffer (buffer
, Qnil
, Qnil
);
1501 if (b
== current_buffer
)
1505 /* Notice if the buffer to kill is the sole visible buffer
1506 when we're currently in the mini-buffer, and give up if so. */
1507 XSETBUFFER (tem
, current_buffer
);
1508 if (EQ (tem
, XWINDOW (minibuf_window
)->buffer
))
1510 tem
= Fother_buffer (buffer
, Qnil
, Qnil
);
1511 if (EQ (buffer
, tem
))
1515 /* Now there is no question: we can kill the buffer. */
1517 #ifdef CLASH_DETECTION
1518 /* Unlock this buffer's file, if it is locked. */
1520 #endif /* CLASH_DETECTION */
1523 kill_buffer_processes (buffer
);
1526 /* Killing buffer processes may run sentinels which may
1527 have called kill-buffer. */
1532 clear_charpos_cache (b
);
1534 tem
= Vinhibit_quit
;
1536 replace_buffer_in_all_windows (buffer
);
1537 Vbuffer_alist
= Fdelq (Frassq (buffer
, Vbuffer_alist
), Vbuffer_alist
);
1538 frames_discard_buffer (buffer
);
1539 Vinhibit_quit
= tem
;
1541 /* Delete any auto-save file, if we saved it in this session.
1542 But not if the buffer is modified. */
1543 if (STRINGP (b
->auto_save_file_name
)
1544 && b
->auto_save_modified
!= 0
1545 && BUF_SAVE_MODIFF (b
) < b
->auto_save_modified
1546 && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
)
1547 && NILP (Fsymbol_value (intern ("auto-save-visited-file-name"))))
1550 tem
= Fsymbol_value (intern ("delete-auto-save-files"));
1552 internal_delete_file (b
->auto_save_file_name
);
1557 /* Unchain all markers that belong to this indirect buffer.
1558 Don't unchain the markers that belong to the base buffer
1559 or its other indirect buffers. */
1560 for (m
= BUF_MARKERS (b
); m
; )
1562 struct Lisp_Marker
*next
= m
->next
;
1570 /* Unchain all markers of this buffer and its indirect buffers.
1571 and leave them pointing nowhere. */
1572 for (m
= BUF_MARKERS (b
); m
; )
1574 struct Lisp_Marker
*next
= m
->next
;
1579 BUF_MARKERS (b
) = NULL
;
1580 BUF_INTERVALS (b
) = NULL_INTERVAL
;
1582 /* Perhaps we should explicitly free the interval tree here... */
1585 /* Reset the local variables, so that this buffer's local values
1586 won't be protected from GC. They would be protected
1587 if they happened to remain encached in their symbols.
1588 This gets rid of them for certain. */
1589 swap_out_buffer_local_variables (b
);
1590 reset_buffer_local_variables (b
, 1);
1595 if (! b
->base_buffer
)
1596 free_buffer_text (b
);
1598 if (b
->newline_cache
)
1600 free_region_cache (b
->newline_cache
);
1601 b
->newline_cache
= 0;
1603 if (b
->width_run_cache
)
1605 free_region_cache (b
->width_run_cache
);
1606 b
->width_run_cache
= 0;
1608 b
->width_table
= Qnil
;
1610 b
->undo_list
= Qnil
;
1615 /* Move the assoc for buffer BUF to the front of buffer-alist. Since
1616 we do this each time BUF is selected visibly, the more recently
1617 selected buffers are always closer to the front of the list. This
1618 means that other_buffer is more likely to choose a relevant buffer. */
1624 register Lisp_Object link
, prev
;
1626 frame
= selected_frame
;
1629 for (link
= Vbuffer_alist
; CONSP (link
); link
= XCDR (link
))
1631 if (EQ (XCDR (XCAR (link
)), buf
))
1636 /* Effectively do Vbuffer_alist = Fdelq (link, Vbuffer_alist);
1637 we cannot use Fdelq itself here because it allows quitting. */
1640 Vbuffer_alist
= XCDR (Vbuffer_alist
);
1642 XSETCDR (prev
, XCDR (XCDR (prev
)));
1644 XSETCDR (link
, Vbuffer_alist
);
1645 Vbuffer_alist
= link
;
1647 /* Effectively do a delq on buried_buffer_list. */
1650 for (link
= XFRAME (frame
)->buried_buffer_list
; CONSP (link
);
1653 if (EQ (XCAR (link
), buf
))
1656 XFRAME (frame
)->buried_buffer_list
= XCDR (link
);
1658 XSETCDR (prev
, XCDR (XCDR (prev
)));
1664 /* Now move this buffer to the front of frame_buffer_list also. */
1667 for (link
= frame_buffer_list (frame
); CONSP (link
);
1670 if (EQ (XCAR (link
), buf
))
1675 /* Effectively do delq. */
1680 set_frame_buffer_list (frame
,
1681 XCDR (frame_buffer_list (frame
)));
1683 XSETCDR (prev
, XCDR (XCDR (prev
)));
1685 XSETCDR (link
, frame_buffer_list (frame
));
1686 set_frame_buffer_list (frame
, link
);
1689 set_frame_buffer_list (frame
, Fcons (buf
, frame_buffer_list (frame
)));
1692 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode
, Sset_buffer_major_mode
, 1, 1, 0,
1693 doc
: /* Set an appropriate major mode for BUFFER.
1694 For the *scratch* buffer, use `initial-major-mode', otherwise choose a mode
1695 according to `default-major-mode'.
1696 Use this function before selecting the buffer, since it may need to inspect
1697 the current buffer's major mode. */)
1702 Lisp_Object function
;
1704 CHECK_BUFFER (buffer
);
1706 if (STRINGP (XBUFFER (buffer
)->name
)
1707 && strcmp (SDATA (XBUFFER (buffer
)->name
), "*scratch*") == 0)
1708 function
= find_symbol_value (intern ("initial-major-mode"));
1711 function
= buffer_defaults
.major_mode
;
1713 && NILP (Fget (current_buffer
->major_mode
, Qmode_class
)))
1714 function
= current_buffer
->major_mode
;
1717 if (NILP (function
) || EQ (function
, Qfundamental_mode
))
1720 count
= SPECPDL_INDEX ();
1722 /* To select a nonfundamental mode,
1723 select the buffer temporarily and then call the mode function. */
1725 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1727 Fset_buffer (buffer
);
1730 return unbind_to (count
, Qnil
);
1733 /* Switch to buffer BUFFER in the selected window.
1734 If NORECORD is non-nil, don't call record_buffer. */
1737 switch_to_buffer_1 (buffer_or_name
, norecord
)
1738 Lisp_Object buffer_or_name
, norecord
;
1740 register Lisp_Object buffer
;
1742 if (NILP (buffer_or_name
))
1743 buffer
= Fother_buffer (Fcurrent_buffer (), Qnil
, Qnil
);
1746 buffer
= Fget_buffer (buffer_or_name
);
1749 buffer
= Fget_buffer_create (buffer_or_name
);
1750 Fset_buffer_major_mode (buffer
);
1753 Fset_buffer (buffer
);
1754 if (NILP (norecord
))
1755 record_buffer (buffer
);
1757 Fset_window_buffer (EQ (selected_window
, minibuf_window
)
1758 ? Fnext_window (minibuf_window
, Qnil
, Qnil
)
1765 DEFUN ("switch-to-buffer", Fswitch_to_buffer
, Sswitch_to_buffer
, 1, 2,
1766 "(list (read-buffer-to-switch \"Switch to buffer: \"))",
1767 doc
: /* Make BUFFER-OR-NAME current and display it in selected window.
1768 BUFFER-OR-NAME may be a buffer, a string \(a buffer name), or
1769 nil. Return the buffer switched to.
1771 If BUFFER-OR-NAME is a string and does not identify an existing
1772 buffer, create a new buffer with that name. Interactively, if
1773 `confirm-nonexistent-file-or-buffer' is non-nil, request
1774 confirmation before creating a new buffer. If BUFFER-OR-NAME is
1775 nil, switch to buffer returned by `other-buffer'.
1777 Optional second arg NORECORD non-nil means do not put this buffer
1778 at the front of the list of recently selected ones. This
1779 function returns the buffer it switched to as a Lisp object.
1781 If the selected window is the minibuffer window or dedicated to
1782 its buffer, use `pop-to-buffer' for displaying the buffer.
1784 WARNING: This is NOT the way to work on another buffer temporarily
1785 within a Lisp program! Use `set-buffer' instead. That avoids
1786 messing with the window-buffer correspondences. */)
1787 (buffer_or_name
, norecord
)
1788 Lisp_Object buffer_or_name
, norecord
;
1792 if (EQ (buffer_or_name
, Fwindow_buffer (selected_window
)))
1794 /* Basically a NOP. Avoid signalling an error in the case where
1795 the selected window is dedicated, or a minibuffer. */
1797 /* But do put this buffer at the front of the buffer list, unless
1798 that has been inhibited. Note that even if BUFFER-OR-NAME is
1799 at the front of the main buffer-list already, we still want to
1800 move it to the front of the frame's buffer list. */
1801 if (NILP (norecord
))
1802 record_buffer (buffer_or_name
);
1803 return Fset_buffer (buffer_or_name
);
1805 else if (EQ (minibuf_window
, selected_window
)
1806 /* If `dedicated' is neither nil nor t, it means it's
1807 dedicatedness can be overridden by an explicit request
1808 such as a call to switch-to-buffer. */
1809 || EQ (Fwindow_dedicated_p (selected_window
), Qt
))
1810 /* We can't use the selected window so let `pop-to-buffer' try some
1812 return call3 (intern ("pop-to-buffer"), buffer_or_name
, Qnil
, norecord
);
1814 return switch_to_buffer_1 (buffer_or_name
, norecord
);
1817 DEFUN ("current-buffer", Fcurrent_buffer
, Scurrent_buffer
, 0, 0, 0,
1818 doc
: /* Return the current buffer as a Lisp object. */)
1821 register Lisp_Object buf
;
1822 XSETBUFFER (buf
, current_buffer
);
1826 /* Set the current buffer to B.
1828 We previously set windows_or_buffers_changed here to invalidate
1829 global unchanged information in beg_unchanged and end_unchanged.
1830 This is no longer necessary because we now compute unchanged
1831 information on a buffer-basis. Every action affecting other
1832 windows than the selected one requires a select_window at some
1833 time, and that increments windows_or_buffers_changed. */
1836 set_buffer_internal (b
)
1837 register struct buffer
*b
;
1839 if (current_buffer
!= b
)
1840 set_buffer_internal_1 (b
);
1843 /* Set the current buffer to B, and do not set windows_or_buffers_changed.
1844 This is used by redisplay. */
1847 set_buffer_internal_1 (b
)
1848 register struct buffer
*b
;
1850 register struct buffer
*old_buf
;
1851 register Lisp_Object tail
, valcontents
;
1854 #ifdef USE_MMAP_FOR_BUFFERS
1855 if (b
->text
->beg
== NULL
)
1856 enlarge_buffer_text (b
, 0);
1857 #endif /* USE_MMAP_FOR_BUFFERS */
1859 if (current_buffer
== b
)
1862 old_buf
= current_buffer
;
1864 last_known_column_point
= -1; /* invalidate indentation cache */
1868 /* Put the undo list back in the base buffer, so that it appears
1869 that an indirect buffer shares the undo list of its base. */
1870 if (old_buf
->base_buffer
)
1871 old_buf
->base_buffer
->undo_list
= old_buf
->undo_list
;
1873 /* If the old current buffer has markers to record PT, BEGV and ZV
1874 when it is not current, update them now. */
1875 if (! NILP (old_buf
->pt_marker
))
1878 XSETBUFFER (obuf
, old_buf
);
1879 set_marker_both (old_buf
->pt_marker
, obuf
,
1880 BUF_PT (old_buf
), BUF_PT_BYTE (old_buf
));
1882 if (! NILP (old_buf
->begv_marker
))
1885 XSETBUFFER (obuf
, old_buf
);
1886 set_marker_both (old_buf
->begv_marker
, obuf
,
1887 BUF_BEGV (old_buf
), BUF_BEGV_BYTE (old_buf
));
1889 if (! NILP (old_buf
->zv_marker
))
1892 XSETBUFFER (obuf
, old_buf
);
1893 set_marker_both (old_buf
->zv_marker
, obuf
,
1894 BUF_ZV (old_buf
), BUF_ZV_BYTE (old_buf
));
1898 /* Get the undo list from the base buffer, so that it appears
1899 that an indirect buffer shares the undo list of its base. */
1901 b
->undo_list
= b
->base_buffer
->undo_list
;
1903 /* If the new current buffer has markers to record PT, BEGV and ZV
1904 when it is not current, fetch them now. */
1905 if (! NILP (b
->pt_marker
))
1907 BUF_PT (b
) = marker_position (b
->pt_marker
);
1908 BUF_PT_BYTE (b
) = marker_byte_position (b
->pt_marker
);
1910 if (! NILP (b
->begv_marker
))
1912 BUF_BEGV (b
) = marker_position (b
->begv_marker
);
1913 BUF_BEGV_BYTE (b
) = marker_byte_position (b
->begv_marker
);
1915 if (! NILP (b
->zv_marker
))
1917 BUF_ZV (b
) = marker_position (b
->zv_marker
);
1918 BUF_ZV_BYTE (b
) = marker_byte_position (b
->zv_marker
);
1921 /* Look down buffer's list of local Lisp variables
1922 to find and update any that forward into C variables. */
1924 for (tail
= b
->local_var_alist
; CONSP (tail
); tail
= XCDR (tail
))
1926 if (CONSP (XCAR (tail
))
1927 && SYMBOLP (XCAR (XCAR (tail
)))
1928 && (valcontents
= SYMBOL_VALUE (XCAR (XCAR (tail
))),
1929 (BUFFER_LOCAL_VALUEP (valcontents
)))
1930 && (tem
= XBUFFER_LOCAL_VALUE (valcontents
)->realvalue
,
1931 (BOOLFWDP (tem
) || INTFWDP (tem
) || OBJFWDP (tem
))))
1932 /* Just reference the variable to cause it to become set for
1934 Fsymbol_value (XCAR (XCAR (tail
)));
1937 /* Do the same with any others that were local to the previous buffer */
1940 for (tail
= old_buf
->local_var_alist
; CONSP (tail
); tail
= XCDR (tail
))
1943 && SYMBOLP (XCAR (XCAR (tail
)))
1944 && (valcontents
= SYMBOL_VALUE (XCAR (XCAR (tail
))),
1945 (BUFFER_LOCAL_VALUEP (valcontents
)))
1946 && (tem
= XBUFFER_LOCAL_VALUE (valcontents
)->realvalue
,
1947 (BOOLFWDP (tem
) || INTFWDP (tem
) || OBJFWDP (tem
))))
1948 /* Just reference the variable to cause it to become set for
1950 Fsymbol_value (XCAR (XCAR (tail
)));
1954 /* Switch to buffer B temporarily for redisplay purposes.
1955 This avoids certain things that don't need to be done within redisplay. */
1961 register struct buffer
*old_buf
;
1963 if (current_buffer
== b
)
1966 old_buf
= current_buffer
;
1971 /* If the old current buffer has markers to record PT, BEGV and ZV
1972 when it is not current, update them now. */
1973 if (! NILP (old_buf
->pt_marker
))
1976 XSETBUFFER (obuf
, old_buf
);
1977 set_marker_both (old_buf
->pt_marker
, obuf
,
1978 BUF_PT (old_buf
), BUF_PT_BYTE (old_buf
));
1980 if (! NILP (old_buf
->begv_marker
))
1983 XSETBUFFER (obuf
, old_buf
);
1984 set_marker_both (old_buf
->begv_marker
, obuf
,
1985 BUF_BEGV (old_buf
), BUF_BEGV_BYTE (old_buf
));
1987 if (! NILP (old_buf
->zv_marker
))
1990 XSETBUFFER (obuf
, old_buf
);
1991 set_marker_both (old_buf
->zv_marker
, obuf
,
1992 BUF_ZV (old_buf
), BUF_ZV_BYTE (old_buf
));
1996 /* If the new current buffer has markers to record PT, BEGV and ZV
1997 when it is not current, fetch them now. */
1998 if (! NILP (b
->pt_marker
))
2000 BUF_PT (b
) = marker_position (b
->pt_marker
);
2001 BUF_PT_BYTE (b
) = marker_byte_position (b
->pt_marker
);
2003 if (! NILP (b
->begv_marker
))
2005 BUF_BEGV (b
) = marker_position (b
->begv_marker
);
2006 BUF_BEGV_BYTE (b
) = marker_byte_position (b
->begv_marker
);
2008 if (! NILP (b
->zv_marker
))
2010 BUF_ZV (b
) = marker_position (b
->zv_marker
);
2011 BUF_ZV_BYTE (b
) = marker_byte_position (b
->zv_marker
);
2015 DEFUN ("set-buffer", Fset_buffer
, Sset_buffer
, 1, 1, 0,
2016 doc
: /* Make buffer BUFFER-OR-NAME current for editing operations.
2017 BUFFER-OR-NAME may be a buffer or the name of an existing buffer. See
2018 also `save-excursion' when you want to make a buffer current
2019 temporarily. This function does not display the buffer, so its effect
2020 ends when the current command terminates. Use `switch-to-buffer' or
2021 `pop-to-buffer' to switch buffers permanently. */)
2023 register Lisp_Object buffer_or_name
;
2025 register Lisp_Object buffer
;
2026 buffer
= Fget_buffer (buffer_or_name
);
2028 nsberror (buffer_or_name
);
2029 if (NILP (XBUFFER (buffer
)->name
))
2030 error ("Selecting deleted buffer");
2031 set_buffer_internal (XBUFFER (buffer
));
2035 /* Set the current buffer to BUFFER provided it is alive. */
2038 set_buffer_if_live (buffer
)
2041 if (! NILP (XBUFFER (buffer
)->name
))
2042 Fset_buffer (buffer
);
2046 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only
,
2047 Sbarf_if_buffer_read_only
, 0, 0, 0,
2048 doc
: /* Signal a `buffer-read-only' error if the current buffer is read-only. */)
2051 if (!NILP (current_buffer
->read_only
)
2052 && NILP (Vinhibit_read_only
))
2053 xsignal1 (Qbuffer_read_only
, Fcurrent_buffer ());
2057 DEFUN ("bury-buffer", Fbury_buffer
, Sbury_buffer
, 0, 1, "",
2058 doc
: /* Put BUFFER-OR-NAME at the end of the list of all buffers.
2059 There it is the least likely candidate for `other-buffer' to return;
2060 thus, the least likely buffer for \\[switch-to-buffer] to select by
2063 The argument may be a buffer name or an actual buffer object. If
2064 BUFFER-OR-NAME is nil or omitted, bury the current buffer and remove it
2065 from the selected window if it is displayed there. If the selected
2066 window is dedicated to its buffer, delete that window if there are other
2067 windows on the same frame. If the selected window is the only window on
2068 its frame, iconify that frame. */)
2070 register Lisp_Object buffer_or_name
;
2074 /* Figure out what buffer we're going to bury. */
2075 if (NILP (buffer_or_name
))
2078 XSETBUFFER (buffer
, current_buffer
);
2080 tem
= Fwindow_buffer (selected_window
);
2081 /* If we're burying the current buffer, unshow it. */
2082 if (EQ (buffer
, tem
))
2084 if (NILP (Fwindow_dedicated_p (selected_window
)))
2085 Fswitch_to_buffer (Fother_buffer (buffer
, Qnil
, Qnil
), Qnil
);
2086 else if (NILP (XWINDOW (selected_window
)->parent
))
2087 Ficonify_frame (Fwindow_frame (selected_window
));
2089 Fdelete_window (selected_window
);
2094 buffer
= Fget_buffer (buffer_or_name
);
2096 nsberror (buffer_or_name
);
2099 /* Move buffer to the end of the buffer list. Do nothing if the
2100 buffer is killed. */
2101 if (!NILP (XBUFFER (buffer
)->name
))
2103 Lisp_Object aelt
, link
;
2105 aelt
= Frassq (buffer
, Vbuffer_alist
);
2106 link
= Fmemq (aelt
, Vbuffer_alist
);
2107 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
2108 XSETCDR (link
, Qnil
);
2109 Vbuffer_alist
= nconc2 (Vbuffer_alist
, link
);
2111 XFRAME (selected_frame
)->buffer_list
2112 = Fdelq (buffer
, XFRAME (selected_frame
)->buffer_list
);
2113 XFRAME (selected_frame
)->buried_buffer_list
2114 = Fcons (buffer
, Fdelq (buffer
, XFRAME (selected_frame
)->buried_buffer_list
));
2120 DEFUN ("erase-buffer", Ferase_buffer
, Serase_buffer
, 0, 0, "*",
2121 doc
: /* Delete the entire contents of the current buffer.
2122 Any narrowing restriction in effect (see `narrow-to-region') is removed,
2123 so the buffer is truly empty after this. */)
2130 current_buffer
->last_window_start
= 1;
2131 /* Prevent warnings, or suspension of auto saving, that would happen
2132 if future size is less than past size. Use of erase-buffer
2133 implies that the future text is not really related to the past text. */
2134 XSETFASTINT (current_buffer
->save_length
, 0);
2139 validate_region (b
, e
)
2140 register Lisp_Object
*b
, *e
;
2142 CHECK_NUMBER_COERCE_MARKER (*b
);
2143 CHECK_NUMBER_COERCE_MARKER (*e
);
2145 if (XINT (*b
) > XINT (*e
))
2148 tem
= *b
; *b
= *e
; *e
= tem
;
2151 if (!(BEGV
<= XINT (*b
) && XINT (*b
) <= XINT (*e
)
2152 && XINT (*e
) <= ZV
))
2153 args_out_of_range (*b
, *e
);
2156 /* Advance BYTE_POS up to a character boundary
2157 and return the adjusted position. */
2160 advance_to_char_boundary (byte_pos
)
2165 if (byte_pos
== BEG
)
2166 /* Beginning of buffer is always a character boundary. */
2169 c
= FETCH_BYTE (byte_pos
);
2170 if (! CHAR_HEAD_P (c
))
2172 /* We should advance BYTE_POS only when C is a constituent of a
2173 multibyte sequence. */
2174 int orig_byte_pos
= byte_pos
;
2179 c
= FETCH_BYTE (byte_pos
);
2181 while (! CHAR_HEAD_P (c
) && byte_pos
> BEG
);
2183 if (byte_pos
< orig_byte_pos
)
2184 byte_pos
= orig_byte_pos
;
2185 /* If C is a constituent of a multibyte sequence, BYTE_POS was
2186 surely advance to the correct character boundary. If C is
2187 not, BYTE_POS was unchanged. */
2194 extern void r_alloc_reset_variable
P_ ((POINTER_TYPE
*, POINTER_TYPE
*));
2195 #endif /* REL_ALLOC */
2197 DEFUN ("buffer-swap-text", Fbuffer_swap_text
, Sbuffer_swap_text
,
2199 doc
: /* Swap the text between current buffer and BUFFER. */)
2203 struct buffer
*other_buffer
;
2204 CHECK_BUFFER (buffer
);
2205 other_buffer
= XBUFFER (buffer
);
2207 if (NILP (other_buffer
->name
))
2208 error ("Cannot swap a dead buffer's text");
2210 /* Actually, it probably works just fine.
2211 * if (other_buffer == current_buffer)
2212 * error ("Cannot swap a buffer's text with itself"); */
2214 /* Actually, this may be workable as well, tho probably only if they're
2216 if (other_buffer
->base_buffer
2217 || current_buffer
->base_buffer
)
2218 error ("Cannot swap indirect buffers's text");
2220 { /* This is probably harder to make work. */
2221 struct buffer
*other
;
2222 for (other
= all_buffers
; other
; other
= other
->next
)
2223 if (other
->base_buffer
== other_buffer
2224 || other
->base_buffer
== current_buffer
)
2225 error ("One of the buffers to swap has indirect buffers");
2228 #define swapfield(field, type) \
2230 type tmp##field = other_buffer->field; \
2231 other_buffer->field = current_buffer->field; \
2232 current_buffer->field = tmp##field; \
2235 swapfield (own_text
, struct buffer_text
);
2236 eassert (current_buffer
->text
== ¤t_buffer
->own_text
);
2237 eassert (other_buffer
->text
== &other_buffer
->own_text
);
2239 r_alloc_reset_variable ((POINTER_TYPE
**) ¤t_buffer
->own_text
.beg
,
2240 (POINTER_TYPE
**) &other_buffer
->own_text
.beg
);
2241 r_alloc_reset_variable ((POINTER_TYPE
**) &other_buffer
->own_text
.beg
,
2242 (POINTER_TYPE
**) ¤t_buffer
->own_text
.beg
);
2243 #endif /* REL_ALLOC */
2245 swapfield (pt
, EMACS_INT
);
2246 swapfield (pt_byte
, EMACS_INT
);
2247 swapfield (begv
, EMACS_INT
);
2248 swapfield (begv_byte
, EMACS_INT
);
2249 swapfield (zv
, EMACS_INT
);
2250 swapfield (zv_byte
, EMACS_INT
);
2251 eassert (!current_buffer
->base_buffer
);
2252 eassert (!other_buffer
->base_buffer
);
2253 current_buffer
->clip_changed
= 1; other_buffer
->clip_changed
= 1;
2254 swapfield (newline_cache
, struct region_cache
*);
2255 swapfield (width_run_cache
, struct region_cache
*);
2256 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2257 other_buffer
->prevent_redisplay_optimizations_p
= 1;
2258 swapfield (overlays_before
, struct Lisp_Overlay
*);
2259 swapfield (overlays_after
, struct Lisp_Overlay
*);
2260 swapfield (overlay_center
, EMACS_INT
);
2261 swapfield (undo_list
, Lisp_Object
);
2262 swapfield (mark
, Lisp_Object
);
2263 swapfield (enable_multibyte_characters
, Lisp_Object
);
2264 swapfield (bidi_display_reordering
, Lisp_Object
);
2265 swapfield (bidi_paragraph_direction
, Lisp_Object
);
2266 /* FIXME: Not sure what we should do with these *_marker fields.
2267 Hopefully they're just nil anyway. */
2268 swapfield (pt_marker
, Lisp_Object
);
2269 swapfield (begv_marker
, Lisp_Object
);
2270 swapfield (zv_marker
, Lisp_Object
);
2271 current_buffer
->point_before_scroll
= Qnil
;
2272 other_buffer
->point_before_scroll
= Qnil
;
2274 current_buffer
->text
->modiff
++; other_buffer
->text
->modiff
++;
2275 current_buffer
->text
->chars_modiff
++; other_buffer
->text
->chars_modiff
++;
2276 current_buffer
->text
->overlay_modiff
++; other_buffer
->text
->overlay_modiff
++;
2277 current_buffer
->text
->beg_unchanged
= current_buffer
->text
->gpt
;
2278 current_buffer
->text
->end_unchanged
= current_buffer
->text
->gpt
;
2279 other_buffer
->text
->beg_unchanged
= other_buffer
->text
->gpt
;
2280 other_buffer
->text
->end_unchanged
= other_buffer
->text
->gpt
;
2282 struct Lisp_Marker
*m
;
2283 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
2284 if (m
->buffer
== other_buffer
)
2285 m
->buffer
= current_buffer
;
2287 /* Since there's no indirect buffer in sight, markers on
2288 BUF_MARKERS(buf) should either be for `buf' or dead. */
2289 eassert (!m
->buffer
);
2290 for (m
= BUF_MARKERS (other_buffer
); m
; m
= m
->next
)
2291 if (m
->buffer
== current_buffer
)
2292 m
->buffer
= other_buffer
;
2294 /* Since there's no indirect buffer in sight, markers on
2295 BUF_MARKERS(buf) should either be for `buf' or dead. */
2296 eassert (!m
->buffer
);
2298 { /* Some of the C code expects that w->buffer == w->pointm->buffer.
2299 So since we just swapped the markers between the two buffers, we need
2300 to undo the effect of this swap for window markers. */
2301 Lisp_Object w
= Fselected_window (), ws
= Qnil
;
2302 Lisp_Object buf1
, buf2
;
2303 XSETBUFFER (buf1
, current_buffer
); XSETBUFFER (buf2
, other_buffer
);
2305 while (NILP (Fmemq (w
, ws
)))
2308 if (MARKERP (XWINDOW (w
)->pointm
)
2309 && (EQ (XWINDOW (w
)->buffer
, buf1
)
2310 || EQ (XWINDOW (w
)->buffer
, buf2
)))
2311 Fset_marker (XWINDOW (w
)->pointm
,
2312 make_number (BUF_BEGV (XBUFFER (XWINDOW (w
)->buffer
))),
2313 XWINDOW (w
)->buffer
);
2314 w
= Fnext_window (w
, Qt
, Qt
);
2318 if (current_buffer
->text
->intervals
)
2319 (eassert (EQ (current_buffer
->text
->intervals
->up
.obj
, buffer
)),
2320 XSETBUFFER (current_buffer
->text
->intervals
->up
.obj
, current_buffer
));
2321 if (other_buffer
->text
->intervals
)
2322 (eassert (EQ (other_buffer
->text
->intervals
->up
.obj
, Fcurrent_buffer ())),
2323 XSETBUFFER (other_buffer
->text
->intervals
->up
.obj
, other_buffer
));
2328 DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte
, Sset_buffer_multibyte
,
2330 doc
: /* Set the multibyte flag of the current buffer to FLAG.
2331 If FLAG is t, this makes the buffer a multibyte buffer.
2332 If FLAG is nil, this makes the buffer a single-byte buffer.
2333 In these cases, the buffer contents remain unchanged as a sequence of
2334 bytes but the contents viewed as characters do change.
2335 If FLAG is `to', this makes the buffer a multibyte buffer by changing
2336 all eight-bit bytes to eight-bit characters.
2337 If the multibyte flag was really changed, undo information of the
2338 current buffer is cleared. */)
2342 struct Lisp_Marker
*tail
, *markers
;
2343 struct buffer
*other
;
2345 int narrowed
= (BEG
!= BEGV
|| Z
!= ZV
);
2346 int modified_p
= !NILP (Fbuffer_modified_p (Qnil
));
2347 Lisp_Object old_undo
= current_buffer
->undo_list
;
2348 struct gcpro gcpro1
;
2350 if (current_buffer
->base_buffer
)
2351 error ("Cannot do `set-buffer-multibyte' on an indirect buffer");
2353 /* Do nothing if nothing actually changes. */
2354 if (NILP (flag
) == NILP (current_buffer
->enable_multibyte_characters
))
2359 /* Don't record these buffer changes. We will put a special undo entry
2361 current_buffer
->undo_list
= Qt
;
2363 /* If the cached position is for this buffer, clear it out. */
2364 clear_charpos_cache (current_buffer
);
2367 begv
= BEGV_BYTE
, zv
= ZV_BYTE
;
2369 begv
= BEGV
, zv
= ZV
;
2379 /* Do this first, so it can use CHAR_TO_BYTE
2380 to calculate the old correspondences. */
2381 set_intervals_multibyte (0);
2383 current_buffer
->enable_multibyte_characters
= Qnil
;
2389 TEMP_SET_PT_BOTH (PT_BYTE
, PT_BYTE
);
2392 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
2393 tail
->charpos
= tail
->bytepos
;
2395 /* Convert multibyte form of 8-bit characters to unibyte. */
2410 if (ASCII_BYTE_P (*p
))
2412 else if (CHAR_BYTE8_HEAD_P (*p
))
2414 c
= STRING_CHAR_AND_LENGTH (p
, bytes
);
2415 /* Delete all bytes for this 8-bit character but the
2416 last one, and change the last one to the charcter
2419 del_range_2 (pos
, pos
, pos
+ bytes
, pos
+ bytes
, 0);
2431 bytes
= BYTES_BY_CHAR_HEAD (*p
);
2432 p
+= bytes
, pos
+= bytes
;
2436 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2442 unsigned char *p
, *pend
;
2444 /* Be sure not to have a multibyte sequence striding over the GAP.
2445 Ex: We change this: "...abc\302 _GAP_ \241def..."
2446 to: "...abc _GAP_ \302\241def..." */
2449 && GPT_BYTE
> 1 && GPT_BYTE
< Z_BYTE
2450 && ! CHAR_HEAD_P (*(GAP_END_ADDR
)))
2452 unsigned char *p
= GPT_ADDR
- 1;
2454 while (! CHAR_HEAD_P (*p
) && p
> BEG_ADDR
) p
--;
2455 if (BASE_LEADING_CODE_P (*p
))
2457 int new_gpt
= GPT_BYTE
- (GPT_ADDR
- p
);
2459 move_gap_both (new_gpt
, new_gpt
);
2463 /* Make the buffer contents valid as multibyte by converting
2464 8-bit characters to multibyte form. */
2482 if (ASCII_BYTE_P (*p
))
2484 else if (EQ (flag
, Qt
) && (bytes
= MULTIBYTE_LENGTH (p
, pend
)) > 0)
2485 p
+= bytes
, pos
+= bytes
;
2488 unsigned char tmp
[MAX_MULTIBYTE_LENGTH
];
2491 c
= BYTE8_TO_CHAR (*p
);
2492 bytes
= CHAR_STRING (c
, tmp
);
2494 TEMP_SET_PT_BOTH (pos
+ 1, pos
+ 1);
2496 insert_1_both (tmp
+ 1, bytes
, bytes
, 1, 0, 0);
2497 /* Now the gap is after the just inserted data. */
2515 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2517 /* Do this first, so that chars_in_text asks the right question.
2518 set_intervals_multibyte needs it too. */
2519 current_buffer
->enable_multibyte_characters
= Qt
;
2521 GPT_BYTE
= advance_to_char_boundary (GPT_BYTE
);
2522 GPT
= chars_in_text (BEG_ADDR
, GPT_BYTE
- BEG_BYTE
) + BEG
;
2524 Z
= chars_in_text (GAP_END_ADDR
, Z_BYTE
- GPT_BYTE
) + GPT
;
2526 BEGV_BYTE
= advance_to_char_boundary (BEGV_BYTE
);
2527 if (BEGV_BYTE
> GPT_BYTE
)
2528 BEGV
= chars_in_text (GAP_END_ADDR
, BEGV_BYTE
- GPT_BYTE
) + GPT
;
2530 BEGV
= chars_in_text (BEG_ADDR
, BEGV_BYTE
- BEG_BYTE
) + BEG
;
2532 ZV_BYTE
= advance_to_char_boundary (ZV_BYTE
);
2533 if (ZV_BYTE
> GPT_BYTE
)
2534 ZV
= chars_in_text (GAP_END_ADDR
, ZV_BYTE
- GPT_BYTE
) + GPT
;
2536 ZV
= chars_in_text (BEG_ADDR
, ZV_BYTE
- BEG_BYTE
) + BEG
;
2539 int pt_byte
= advance_to_char_boundary (PT_BYTE
);
2542 if (pt_byte
> GPT_BYTE
)
2543 pt
= chars_in_text (GAP_END_ADDR
, pt_byte
- GPT_BYTE
) + GPT
;
2545 pt
= chars_in_text (BEG_ADDR
, pt_byte
- BEG_BYTE
) + BEG
;
2546 TEMP_SET_PT_BOTH (pt
, pt_byte
);
2549 tail
= markers
= BUF_MARKERS (current_buffer
);
2551 /* This prevents BYTE_TO_CHAR (that is, buf_bytepos_to_charpos) from
2552 getting confused by the markers that have not yet been updated.
2553 It is also a signal that it should never create a marker. */
2554 BUF_MARKERS (current_buffer
) = NULL
;
2556 for (; tail
; tail
= tail
->next
)
2558 tail
->bytepos
= advance_to_char_boundary (tail
->bytepos
);
2559 tail
->charpos
= BYTE_TO_CHAR (tail
->bytepos
);
2562 /* Make sure no markers were put on the chain
2563 while the chain value was incorrect. */
2564 if (BUF_MARKERS (current_buffer
))
2567 BUF_MARKERS (current_buffer
) = markers
;
2569 /* Do this last, so it can calculate the new correspondences
2570 between chars and bytes. */
2571 set_intervals_multibyte (1);
2574 if (!EQ (old_undo
, Qt
))
2576 /* Represent all the above changes by a special undo entry. */
2577 extern Lisp_Object Qapply
;
2578 current_buffer
->undo_list
= Fcons (list3 (Qapply
,
2579 intern ("set-buffer-multibyte"),
2580 NILP (flag
) ? Qt
: Qnil
),
2586 /* Changing the multibyteness of a buffer means that all windows
2587 showing that buffer must be updated thoroughly. */
2588 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2589 ++windows_or_buffers_changed
;
2591 /* Copy this buffer's new multibyte status
2592 into all of its indirect buffers. */
2593 for (other
= all_buffers
; other
; other
= other
->next
)
2594 if (other
->base_buffer
== current_buffer
&& !NILP (other
->name
))
2596 other
->enable_multibyte_characters
2597 = current_buffer
->enable_multibyte_characters
;
2598 other
->prevent_redisplay_optimizations_p
= 1;
2601 /* Restore the modifiedness of the buffer. */
2602 if (!modified_p
&& !NILP (Fbuffer_modified_p (Qnil
)))
2603 Fset_buffer_modified_p (Qnil
);
2606 /* Update coding systems of this buffer's process (if any). */
2608 Lisp_Object process
;
2610 process
= Fget_buffer_process (Fcurrent_buffer ());
2611 if (PROCESSP (process
))
2612 setup_process_coding_systems (process
);
2614 #endif /* subprocesses */
2619 DEFUN ("kill-all-local-variables", Fkill_all_local_variables
, Skill_all_local_variables
,
2621 doc
: /* Switch to Fundamental mode by killing current buffer's local variables.
2622 Most local variable bindings are eliminated so that the default values
2623 become effective once more. Also, the syntax table is set from
2624 `standard-syntax-table', the local keymap is set to nil,
2625 and the abbrev table from `fundamental-mode-abbrev-table'.
2626 This function also forces redisplay of the mode line.
2628 Every function to select a new major mode starts by
2629 calling this function.
2631 As a special exception, local variables whose names have
2632 a non-nil `permanent-local' property are not eliminated by this function.
2634 The first thing this function does is run
2635 the normal hook `change-major-mode-hook'. */)
2638 if (!NILP (Vrun_hooks
))
2639 call1 (Vrun_hooks
, Qchange_major_mode_hook
);
2641 /* Make sure none of the bindings in local_var_alist
2642 remain swapped in, in their symbols. */
2644 swap_out_buffer_local_variables (current_buffer
);
2646 /* Actually eliminate all local bindings of this buffer. */
2648 reset_buffer_local_variables (current_buffer
, 0);
2650 /* Force mode-line redisplay. Useful here because all major mode
2651 commands call this function. */
2652 update_mode_lines
++;
2657 /* Make sure no local variables remain set up with buffer B
2658 for their current values. */
2661 swap_out_buffer_local_variables (b
)
2664 Lisp_Object oalist
, alist
, sym
, buffer
;
2666 XSETBUFFER (buffer
, b
);
2667 oalist
= b
->local_var_alist
;
2669 for (alist
= oalist
; CONSP (alist
); alist
= XCDR (alist
))
2671 if (CONSP (XCAR (alist
))
2672 && (sym
= XCAR (XCAR (alist
)), SYMBOLP (sym
))
2673 /* Need not do anything if some other buffer's binding is
2675 && EQ (XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->buffer
,
2678 /* Symbol is set up for this buffer's old local value:
2680 swap_in_global_binding (sym
);
2685 /* Find all the overlays in the current buffer that contain position POS.
2686 Return the number found, and store them in a vector in *VEC_PTR.
2687 Store in *LEN_PTR the size allocated for the vector.
2688 Store in *NEXT_PTR the next position after POS where an overlay starts,
2689 or ZV if there are no more overlays between POS and ZV.
2690 Store in *PREV_PTR the previous position before POS where an overlay ends,
2691 or where an overlay starts which ends at or after POS;
2692 or BEGV if there are no such overlays from BEGV to POS.
2693 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2695 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2696 when this function is called.
2698 If EXTEND is non-zero, we make the vector bigger if necessary.
2699 If EXTEND is zero, we never extend the vector,
2700 and we store only as many overlays as will fit.
2701 But we still return the total number of overlays.
2703 If CHANGE_REQ is true, then any position written into *PREV_PTR or
2704 *NEXT_PTR is guaranteed to be not equal to POS, unless it is the
2705 default (BEGV or ZV). */
2708 overlays_at (pos
, extend
, vec_ptr
, len_ptr
, next_ptr
, prev_ptr
, change_req
)
2711 Lisp_Object
**vec_ptr
;
2713 EMACS_INT
*next_ptr
;
2714 EMACS_INT
*prev_ptr
;
2717 Lisp_Object overlay
, start
, end
;
2718 struct Lisp_Overlay
*tail
;
2721 Lisp_Object
*vec
= *vec_ptr
;
2724 int inhibit_storing
= 0;
2726 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2728 int startpos
, endpos
;
2730 XSETMISC (overlay
, tail
);
2732 start
= OVERLAY_START (overlay
);
2733 end
= OVERLAY_END (overlay
);
2734 endpos
= OVERLAY_POSITION (end
);
2741 startpos
= OVERLAY_POSITION (start
);
2742 /* This one ends at or after POS
2743 so its start counts for PREV_PTR if it's before POS. */
2744 if (prev
< startpos
&& startpos
< pos
)
2748 if (startpos
<= pos
)
2752 /* The supplied vector is full.
2753 Either make it bigger, or don't store any more in it. */
2756 /* Make it work with an initial len == 0. */
2761 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2765 inhibit_storing
= 1;
2768 if (!inhibit_storing
)
2770 /* Keep counting overlays even if we can't return them all. */
2773 else if (startpos
< next
)
2777 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2779 int startpos
, endpos
;
2781 XSETMISC (overlay
, tail
);
2783 start
= OVERLAY_START (overlay
);
2784 end
= OVERLAY_END (overlay
);
2785 startpos
= OVERLAY_POSITION (start
);
2788 if (startpos
< next
)
2792 endpos
= OVERLAY_POSITION (end
);
2799 /* Make it work with an initial len == 0. */
2804 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2808 inhibit_storing
= 1;
2811 if (!inhibit_storing
)
2815 if (startpos
< pos
&& startpos
> prev
)
2818 else if (endpos
< pos
&& endpos
> prev
)
2820 else if (endpos
== pos
&& startpos
> prev
2821 && (!change_req
|| startpos
< pos
))
2832 /* Find all the overlays in the current buffer that overlap the range
2833 BEG-END, or are empty at BEG, or are empty at END provided END
2834 denotes the position at the end of the current buffer.
2836 Return the number found, and store them in a vector in *VEC_PTR.
2837 Store in *LEN_PTR the size allocated for the vector.
2838 Store in *NEXT_PTR the next position after POS where an overlay starts,
2839 or ZV if there are no more overlays.
2840 Store in *PREV_PTR the previous position before POS where an overlay ends,
2841 or BEGV if there are no previous overlays.
2842 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2844 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2845 when this function is called.
2847 If EXTEND is non-zero, we make the vector bigger if necessary.
2848 If EXTEND is zero, we never extend the vector,
2849 and we store only as many overlays as will fit.
2850 But we still return the total number of overlays. */
2853 overlays_in (beg
, end
, extend
, vec_ptr
, len_ptr
, next_ptr
, prev_ptr
)
2856 Lisp_Object
**vec_ptr
;
2861 Lisp_Object overlay
, ostart
, oend
;
2862 struct Lisp_Overlay
*tail
;
2865 Lisp_Object
*vec
= *vec_ptr
;
2868 int inhibit_storing
= 0;
2869 int end_is_Z
= end
== Z
;
2871 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2873 int startpos
, endpos
;
2875 XSETMISC (overlay
, tail
);
2877 ostart
= OVERLAY_START (overlay
);
2878 oend
= OVERLAY_END (overlay
);
2879 endpos
= OVERLAY_POSITION (oend
);
2886 startpos
= OVERLAY_POSITION (ostart
);
2887 /* Count an interval if it overlaps the range, is empty at the
2888 start of the range, or is empty at END provided END denotes the
2889 end of the buffer. */
2890 if ((beg
< endpos
&& startpos
< end
)
2891 || (startpos
== endpos
2892 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
2896 /* The supplied vector is full.
2897 Either make it bigger, or don't store any more in it. */
2900 /* Make it work with an initial len == 0. */
2905 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2909 inhibit_storing
= 1;
2912 if (!inhibit_storing
)
2914 /* Keep counting overlays even if we can't return them all. */
2917 else if (startpos
< next
)
2921 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2923 int startpos
, endpos
;
2925 XSETMISC (overlay
, tail
);
2927 ostart
= OVERLAY_START (overlay
);
2928 oend
= OVERLAY_END (overlay
);
2929 startpos
= OVERLAY_POSITION (ostart
);
2932 if (startpos
< next
)
2936 endpos
= OVERLAY_POSITION (oend
);
2937 /* Count an interval if it overlaps the range, is empty at the
2938 start of the range, or is empty at END provided END denotes the
2939 end of the buffer. */
2940 if ((beg
< endpos
&& startpos
< end
)
2941 || (startpos
== endpos
2942 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
2948 /* Make it work with an initial len == 0. */
2953 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2957 inhibit_storing
= 1;
2960 if (!inhibit_storing
)
2964 else if (endpos
< beg
&& endpos
> prev
)
2976 /* Return non-zero if there exists an overlay with a non-nil
2977 `mouse-face' property overlapping OVERLAY. */
2980 mouse_face_overlay_overlaps (overlay
)
2981 Lisp_Object overlay
;
2983 int start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2984 int end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2986 Lisp_Object
*v
, tem
;
2989 v
= (Lisp_Object
*) alloca (size
* sizeof *v
);
2990 n
= overlays_in (start
, end
, 0, &v
, &size
, NULL
, NULL
);
2993 v
= (Lisp_Object
*) alloca (n
* sizeof *v
);
2994 overlays_in (start
, end
, 0, &v
, &n
, NULL
, NULL
);
2997 for (i
= 0; i
< n
; ++i
)
2998 if (!EQ (v
[i
], overlay
)
2999 && (tem
= Foverlay_get (overlay
, Qmouse_face
),
3008 /* Fast function to just test if we're at an overlay boundary. */
3010 overlay_touches_p (pos
)
3013 Lisp_Object overlay
;
3014 struct Lisp_Overlay
*tail
;
3016 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
3020 XSETMISC (overlay
,tail
);
3021 if (!OVERLAYP (overlay
))
3024 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3027 if (endpos
== pos
|| OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
)
3031 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
3035 XSETMISC (overlay
, tail
);
3036 if (!OVERLAYP (overlay
))
3039 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3042 if (startpos
== pos
|| OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
)
3050 Lisp_Object overlay
;
3056 compare_overlays (v1
, v2
)
3057 const void *v1
, *v2
;
3059 const struct sortvec
*s1
= (const struct sortvec
*) v1
;
3060 const struct sortvec
*s2
= (const struct sortvec
*) v2
;
3061 if (s1
->priority
!= s2
->priority
)
3062 return s1
->priority
- s2
->priority
;
3063 if (s1
->beg
!= s2
->beg
)
3064 return s1
->beg
- s2
->beg
;
3065 if (s1
->end
!= s2
->end
)
3066 return s2
->end
- s1
->end
;
3070 /* Sort an array of overlays by priority. The array is modified in place.
3071 The return value is the new size; this may be smaller than the original
3072 size if some of the overlays were invalid or were window-specific. */
3074 sort_overlays (overlay_vec
, noverlays
, w
)
3075 Lisp_Object
*overlay_vec
;
3080 struct sortvec
*sortvec
;
3081 sortvec
= (struct sortvec
*) alloca (noverlays
* sizeof (struct sortvec
));
3083 /* Put the valid and relevant overlays into sortvec. */
3085 for (i
= 0, j
= 0; i
< noverlays
; i
++)
3088 Lisp_Object overlay
;
3090 overlay
= overlay_vec
[i
];
3091 if (OVERLAY_VALID (overlay
)
3092 && OVERLAY_POSITION (OVERLAY_START (overlay
)) > 0
3093 && OVERLAY_POSITION (OVERLAY_END (overlay
)) > 0)
3095 /* If we're interested in a specific window, then ignore
3096 overlays that are limited to some other window. */
3101 window
= Foverlay_get (overlay
, Qwindow
);
3102 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3106 /* This overlay is good and counts: put it into sortvec. */
3107 sortvec
[j
].overlay
= overlay
;
3108 sortvec
[j
].beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3109 sortvec
[j
].end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3110 tem
= Foverlay_get (overlay
, Qpriority
);
3112 sortvec
[j
].priority
= XINT (tem
);
3114 sortvec
[j
].priority
= 0;
3120 /* Sort the overlays into the proper order: increasing priority. */
3123 qsort (sortvec
, noverlays
, sizeof (struct sortvec
), compare_overlays
);
3125 for (i
= 0; i
< noverlays
; i
++)
3126 overlay_vec
[i
] = sortvec
[i
].overlay
;
3132 Lisp_Object string
, string2
;
3139 struct sortstr
*buf
; /* An array that expands as needed; never freed. */
3140 int size
; /* Allocated length of that array. */
3141 int used
; /* How much of the array is currently in use. */
3142 int bytes
; /* Total length of the strings in buf. */
3145 /* Buffers for storing information about the overlays touching a given
3146 position. These could be automatic variables in overlay_strings, but
3147 it's more efficient to hold onto the memory instead of repeatedly
3148 allocating and freeing it. */
3149 static struct sortstrlist overlay_heads
, overlay_tails
;
3150 static unsigned char *overlay_str_buf
;
3152 /* Allocated length of overlay_str_buf. */
3153 static int overlay_str_len
;
3155 /* A comparison function suitable for passing to qsort. */
3157 cmp_for_strings (as1
, as2
)
3160 struct sortstr
*s1
= (struct sortstr
*)as1
;
3161 struct sortstr
*s2
= (struct sortstr
*)as2
;
3162 if (s1
->size
!= s2
->size
)
3163 return s2
->size
- s1
->size
;
3164 if (s1
->priority
!= s2
->priority
)
3165 return s1
->priority
- s2
->priority
;
3170 record_overlay_string (ssl
, str
, str2
, pri
, size
)
3171 struct sortstrlist
*ssl
;
3172 Lisp_Object str
, str2
, pri
;
3177 if (ssl
->used
== ssl
->size
)
3183 ssl
->buf
= ((struct sortstr
*)
3184 xrealloc (ssl
->buf
, ssl
->size
* sizeof (struct sortstr
)));
3186 ssl
->buf
[ssl
->used
].string
= str
;
3187 ssl
->buf
[ssl
->used
].string2
= str2
;
3188 ssl
->buf
[ssl
->used
].size
= size
;
3189 ssl
->buf
[ssl
->used
].priority
= (INTEGERP (pri
) ? XINT (pri
) : 0);
3192 if (NILP (current_buffer
->enable_multibyte_characters
))
3193 nbytes
= SCHARS (str
);
3194 else if (! STRING_MULTIBYTE (str
))
3195 nbytes
= count_size_as_multibyte (SDATA (str
),
3198 nbytes
= SBYTES (str
);
3200 ssl
->bytes
+= nbytes
;
3204 if (NILP (current_buffer
->enable_multibyte_characters
))
3205 nbytes
= SCHARS (str2
);
3206 else if (! STRING_MULTIBYTE (str2
))
3207 nbytes
= count_size_as_multibyte (SDATA (str2
),
3210 nbytes
= SBYTES (str2
);
3212 ssl
->bytes
+= nbytes
;
3216 /* Return the concatenation of the strings associated with overlays that
3217 begin or end at POS, ignoring overlays that are specific to a window
3218 other than W. The strings are concatenated in the appropriate order:
3219 shorter overlays nest inside longer ones, and higher priority inside
3220 lower. Normally all of the after-strings come first, but zero-sized
3221 overlays have their after-strings ride along with the before-strings
3222 because it would look strange to print them inside-out.
3224 Returns the string length, and stores the contents indirectly through
3225 PSTR, if that variable is non-null. The string may be overwritten by
3226 subsequent calls. */
3229 overlay_strings (pos
, w
, pstr
)
3232 unsigned char **pstr
;
3234 Lisp_Object overlay
, window
, str
;
3235 struct Lisp_Overlay
*ov
;
3236 int startpos
, endpos
;
3237 int multibyte
= ! NILP (current_buffer
->enable_multibyte_characters
);
3239 overlay_heads
.used
= overlay_heads
.bytes
= 0;
3240 overlay_tails
.used
= overlay_tails
.bytes
= 0;
3241 for (ov
= current_buffer
->overlays_before
; ov
; ov
= ov
->next
)
3243 XSETMISC (overlay
, ov
);
3244 eassert (OVERLAYP (overlay
));
3246 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3247 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3250 if (endpos
!= pos
&& startpos
!= pos
)
3252 window
= Foverlay_get (overlay
, Qwindow
);
3253 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3256 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3257 record_overlay_string (&overlay_heads
, str
,
3259 ? Foverlay_get (overlay
, Qafter_string
)
3261 Foverlay_get (overlay
, Qpriority
),
3263 else if (endpos
== pos
3264 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3265 record_overlay_string (&overlay_tails
, str
, Qnil
,
3266 Foverlay_get (overlay
, Qpriority
),
3269 for (ov
= current_buffer
->overlays_after
; ov
; ov
= ov
->next
)
3271 XSETMISC (overlay
, ov
);
3272 eassert (OVERLAYP (overlay
));
3274 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3275 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3278 if (endpos
!= pos
&& startpos
!= pos
)
3280 window
= Foverlay_get (overlay
, Qwindow
);
3281 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3284 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3285 record_overlay_string (&overlay_heads
, str
,
3287 ? Foverlay_get (overlay
, Qafter_string
)
3289 Foverlay_get (overlay
, Qpriority
),
3291 else if (endpos
== pos
3292 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3293 record_overlay_string (&overlay_tails
, str
, Qnil
,
3294 Foverlay_get (overlay
, Qpriority
),
3297 if (overlay_tails
.used
> 1)
3298 qsort (overlay_tails
.buf
, overlay_tails
.used
, sizeof (struct sortstr
),
3300 if (overlay_heads
.used
> 1)
3301 qsort (overlay_heads
.buf
, overlay_heads
.used
, sizeof (struct sortstr
),
3303 if (overlay_heads
.bytes
|| overlay_tails
.bytes
)
3308 int total
= overlay_heads
.bytes
+ overlay_tails
.bytes
;
3310 if (total
> overlay_str_len
)
3312 overlay_str_len
= total
;
3313 overlay_str_buf
= (unsigned char *)xrealloc (overlay_str_buf
,
3316 p
= overlay_str_buf
;
3317 for (i
= overlay_tails
.used
; --i
>= 0;)
3320 tem
= overlay_tails
.buf
[i
].string
;
3321 nbytes
= copy_text (SDATA (tem
), p
,
3323 STRING_MULTIBYTE (tem
), multibyte
);
3326 for (i
= 0; i
< overlay_heads
.used
; ++i
)
3329 tem
= overlay_heads
.buf
[i
].string
;
3330 nbytes
= copy_text (SDATA (tem
), p
,
3332 STRING_MULTIBYTE (tem
), multibyte
);
3334 tem
= overlay_heads
.buf
[i
].string2
;
3337 nbytes
= copy_text (SDATA (tem
), p
,
3339 STRING_MULTIBYTE (tem
), multibyte
);
3343 if (p
!= overlay_str_buf
+ total
)
3346 *pstr
= overlay_str_buf
;
3352 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
3355 recenter_overlay_lists (buf
, pos
)
3359 Lisp_Object overlay
, beg
, end
;
3360 struct Lisp_Overlay
*prev
, *tail
, *next
;
3362 /* See if anything in overlays_before should move to overlays_after. */
3364 /* We don't strictly need prev in this loop; it should always be nil.
3365 But we use it for symmetry and in case that should cease to be true
3366 with some future change. */
3368 for (tail
= buf
->overlays_before
; tail
; prev
= tail
, tail
= next
)
3371 XSETMISC (overlay
, tail
);
3373 /* If the overlay is not valid, get rid of it. */
3374 if (!OVERLAY_VALID (overlay
))
3379 /* Splice the cons cell TAIL out of overlays_before. */
3383 buf
->overlays_before
= next
;
3389 beg
= OVERLAY_START (overlay
);
3390 end
= OVERLAY_END (overlay
);
3392 if (OVERLAY_POSITION (end
) > pos
)
3394 /* OVERLAY needs to be moved. */
3395 int where
= OVERLAY_POSITION (beg
);
3396 struct Lisp_Overlay
*other
, *other_prev
;
3398 /* Splice the cons cell TAIL out of overlays_before. */
3402 buf
->overlays_before
= next
;
3404 /* Search thru overlays_after for where to put it. */
3406 for (other
= buf
->overlays_after
; other
;
3407 other_prev
= other
, other
= other
->next
)
3409 Lisp_Object otherbeg
, otheroverlay
;
3411 XSETMISC (otheroverlay
, other
);
3412 eassert (OVERLAY_VALID (otheroverlay
));
3414 otherbeg
= OVERLAY_START (otheroverlay
);
3415 if (OVERLAY_POSITION (otherbeg
) >= where
)
3419 /* Add TAIL to overlays_after before OTHER. */
3422 other_prev
->next
= tail
;
3424 buf
->overlays_after
= tail
;
3428 /* We've reached the things that should stay in overlays_before.
3429 All the rest of overlays_before must end even earlier,
3434 /* See if anything in overlays_after should be in overlays_before. */
3436 for (tail
= buf
->overlays_after
; tail
; prev
= tail
, tail
= next
)
3439 XSETMISC (overlay
, tail
);
3441 /* If the overlay is not valid, get rid of it. */
3442 if (!OVERLAY_VALID (overlay
))
3447 /* Splice the cons cell TAIL out of overlays_after. */
3451 buf
->overlays_after
= next
;
3457 beg
= OVERLAY_START (overlay
);
3458 end
= OVERLAY_END (overlay
);
3460 /* Stop looking, when we know that nothing further
3461 can possibly end before POS. */
3462 if (OVERLAY_POSITION (beg
) > pos
)
3465 if (OVERLAY_POSITION (end
) <= pos
)
3467 /* OVERLAY needs to be moved. */
3468 int where
= OVERLAY_POSITION (end
);
3469 struct Lisp_Overlay
*other
, *other_prev
;
3471 /* Splice the cons cell TAIL out of overlays_after. */
3475 buf
->overlays_after
= next
;
3477 /* Search thru overlays_before for where to put it. */
3479 for (other
= buf
->overlays_before
; other
;
3480 other_prev
= other
, other
= other
->next
)
3482 Lisp_Object otherend
, otheroverlay
;
3484 XSETMISC (otheroverlay
, other
);
3485 eassert (OVERLAY_VALID (otheroverlay
));
3487 otherend
= OVERLAY_END (otheroverlay
);
3488 if (OVERLAY_POSITION (otherend
) <= where
)
3492 /* Add TAIL to overlays_before before OTHER. */
3495 other_prev
->next
= tail
;
3497 buf
->overlays_before
= tail
;
3502 buf
->overlay_center
= pos
;
3506 adjust_overlays_for_insert (pos
, length
)
3510 /* After an insertion, the lists are still sorted properly,
3511 but we may need to update the value of the overlay center. */
3512 if (current_buffer
->overlay_center
>= pos
)
3513 current_buffer
->overlay_center
+= length
;
3517 adjust_overlays_for_delete (pos
, length
)
3521 if (current_buffer
->overlay_center
< pos
)
3522 /* The deletion was to our right. No change needed; the before- and
3523 after-lists are still consistent. */
3525 else if (current_buffer
->overlay_center
> pos
+ length
)
3526 /* The deletion was to our left. We need to adjust the center value
3527 to account for the change in position, but the lists are consistent
3528 given the new value. */
3529 current_buffer
->overlay_center
-= length
;
3531 /* We're right in the middle. There might be things on the after-list
3532 that now belong on the before-list. Recentering will move them,
3533 and also update the center point. */
3534 recenter_overlay_lists (current_buffer
, pos
);
3537 /* Fix up overlays that were garbled as a result of permuting markers
3538 in the range START through END. Any overlay with at least one
3539 endpoint in this range will need to be unlinked from the overlay
3540 list and reinserted in its proper place.
3541 Such an overlay might even have negative size at this point.
3542 If so, we'll make the overlay empty. */
3544 fix_start_end_in_overlays (start
, end
)
3545 register int start
, end
;
3547 Lisp_Object overlay
;
3548 struct Lisp_Overlay
*before_list
, *after_list
;
3549 /* These are either nil, indicating that before_list or after_list
3550 should be assigned, or the cons cell the cdr of which should be
3552 struct Lisp_Overlay
*beforep
= NULL
, *afterp
= NULL
;
3553 /* 'Parent', likewise, indicates a cons cell or
3554 current_buffer->overlays_before or overlays_after, depending
3555 which loop we're in. */
3556 struct Lisp_Overlay
*tail
, *parent
;
3557 int startpos
, endpos
;
3559 /* This algorithm shifts links around instead of consing and GCing.
3560 The loop invariant is that before_list (resp. after_list) is a
3561 well-formed list except that its last element, the CDR of beforep
3562 (resp. afterp) if beforep (afterp) isn't nil or before_list
3563 (after_list) if it is, is still uninitialized. So it's not a bug
3564 that before_list isn't initialized, although it may look
3566 for (parent
= NULL
, tail
= current_buffer
->overlays_before
; tail
;)
3568 XSETMISC (overlay
, tail
);
3570 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3571 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3573 /* If the overlay is backwards, make it empty. */
3574 if (endpos
< startpos
)
3577 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3585 || (startpos
>= start
&& startpos
< end
))
3587 /* Add it to the end of the wrong list. Later on,
3588 recenter_overlay_lists will move it to the right place. */
3589 if (endpos
< current_buffer
->overlay_center
)
3594 afterp
->next
= tail
;
3602 beforep
->next
= tail
;
3606 current_buffer
->overlays_before
= tail
->next
;
3608 parent
->next
= tail
->next
;
3612 parent
= tail
, tail
= parent
->next
;
3614 for (parent
= NULL
, tail
= current_buffer
->overlays_after
; tail
;)
3616 XSETMISC (overlay
, tail
);
3618 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3619 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3621 /* If the overlay is backwards, make it empty. */
3622 if (endpos
< startpos
)
3625 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3629 if (startpos
>= end
)
3632 if (startpos
>= start
3633 || (endpos
>= start
&& endpos
< end
))
3635 if (endpos
< current_buffer
->overlay_center
)
3640 afterp
->next
= tail
;
3648 beforep
->next
= tail
;
3652 current_buffer
->overlays_after
= tail
->next
;
3654 parent
->next
= tail
->next
;
3658 parent
= tail
, tail
= parent
->next
;
3661 /* Splice the constructed (wrong) lists into the buffer's lists,
3662 and let the recenter function make it sane again. */
3665 beforep
->next
= current_buffer
->overlays_before
;
3666 current_buffer
->overlays_before
= before_list
;
3668 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3672 afterp
->next
= current_buffer
->overlays_after
;
3673 current_buffer
->overlays_after
= after_list
;
3675 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3678 /* We have two types of overlay: the one whose ending marker is
3679 after-insertion-marker (this is the usual case) and the one whose
3680 ending marker is before-insertion-marker. When `overlays_before'
3681 contains overlays of the latter type and the former type in this
3682 order and both overlays end at inserting position, inserting a text
3683 increases only the ending marker of the latter type, which results
3684 in incorrect ordering of `overlays_before'.
3686 This function fixes ordering of overlays in the slot
3687 `overlays_before' of the buffer *BP. Before the insertion, `point'
3688 was at PREV, and now is at POS. */
3691 fix_overlays_before (bp
, prev
, pos
)
3693 EMACS_INT prev
, pos
;
3695 /* If parent is nil, replace overlays_before; otherwise, parent->next. */
3696 struct Lisp_Overlay
*tail
= bp
->overlays_before
, *parent
= NULL
, *right_pair
;
3700 /* After the insertion, the several overlays may be in incorrect
3701 order. The possibility is that, in the list `overlays_before',
3702 an overlay which ends at POS appears after an overlay which ends
3703 at PREV. Since POS is greater than PREV, we must fix the
3704 ordering of these overlays, by moving overlays ends at POS before
3705 the overlays ends at PREV. */
3707 /* At first, find a place where disordered overlays should be linked
3708 in. It is where an overlay which end before POS exists. (i.e. an
3709 overlay whose ending marker is after-insertion-marker if disorder
3712 && (XSETMISC (tem
, tail
),
3713 (end
= OVERLAY_POSITION (OVERLAY_END (tem
))) >= pos
))
3719 /* If we don't find such an overlay,
3720 or the found one ends before PREV,
3721 or the found one is the last one in the list,
3722 we don't have to fix anything. */
3723 if (!tail
|| end
< prev
|| !tail
->next
)
3726 right_pair
= parent
;
3730 /* Now, end position of overlays in the list TAIL should be before
3731 or equal to PREV. In the loop, an overlay which ends at POS is
3732 moved ahead to the place indicated by the CDR of RIGHT_PAIR. If
3733 we found an overlay which ends before PREV, the remaining
3734 overlays are in correct order. */
3737 XSETMISC (tem
, tail
);
3738 end
= OVERLAY_POSITION (OVERLAY_END (tem
));
3741 { /* This overlay is disordered. */
3742 struct Lisp_Overlay
*found
= tail
;
3744 /* Unlink the found overlay. */
3746 parent
->next
= tail
;
3747 /* Move an overlay at RIGHT_PLACE to the next of the found one,
3748 and link it into the right place. */
3751 found
->next
= bp
->overlays_before
;
3752 bp
->overlays_before
= found
;
3756 found
->next
= right_pair
->next
;
3757 right_pair
->next
= found
;
3760 else if (end
== prev
)
3765 else /* No more disordered overlay. */
3770 DEFUN ("overlayp", Foverlayp
, Soverlayp
, 1, 1, 0,
3771 doc
: /* Return t if OBJECT is an overlay. */)
3775 return (OVERLAYP (object
) ? Qt
: Qnil
);
3778 DEFUN ("make-overlay", Fmake_overlay
, Smake_overlay
, 2, 5, 0,
3779 doc
: /* Create a new overlay with range BEG to END in BUFFER.
3780 If omitted, BUFFER defaults to the current buffer.
3781 BEG and END may be integers or markers.
3782 The fourth arg FRONT-ADVANCE, if non-nil, makes the marker
3783 for the front of the overlay advance when text is inserted there
3784 \(which means the text *is not* included in the overlay).
3785 The fifth arg REAR-ADVANCE, if non-nil, makes the marker
3786 for the rear of the overlay advance when text is inserted there
3787 \(which means the text *is* included in the overlay). */)
3788 (beg
, end
, buffer
, front_advance
, rear_advance
)
3789 Lisp_Object beg
, end
, buffer
;
3790 Lisp_Object front_advance
, rear_advance
;
3792 Lisp_Object overlay
;
3796 XSETBUFFER (buffer
, current_buffer
);
3798 CHECK_BUFFER (buffer
);
3800 && ! EQ (Fmarker_buffer (beg
), buffer
))
3801 error ("Marker points into wrong buffer");
3803 && ! EQ (Fmarker_buffer (end
), buffer
))
3804 error ("Marker points into wrong buffer");
3806 CHECK_NUMBER_COERCE_MARKER (beg
);
3807 CHECK_NUMBER_COERCE_MARKER (end
);
3809 if (XINT (beg
) > XINT (end
))
3812 temp
= beg
; beg
= end
; end
= temp
;
3815 b
= XBUFFER (buffer
);
3817 beg
= Fset_marker (Fmake_marker (), beg
, buffer
);
3818 end
= Fset_marker (Fmake_marker (), end
, buffer
);
3820 if (!NILP (front_advance
))
3821 XMARKER (beg
)->insertion_type
= 1;
3822 if (!NILP (rear_advance
))
3823 XMARKER (end
)->insertion_type
= 1;
3825 overlay
= allocate_misc ();
3826 XMISCTYPE (overlay
) = Lisp_Misc_Overlay
;
3827 XOVERLAY (overlay
)->start
= beg
;
3828 XOVERLAY (overlay
)->end
= end
;
3829 XOVERLAY (overlay
)->plist
= Qnil
;
3830 XOVERLAY (overlay
)->next
= NULL
;
3832 /* Put the new overlay on the wrong list. */
3833 end
= OVERLAY_END (overlay
);
3834 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
3836 if (b
->overlays_after
)
3837 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3838 b
->overlays_after
= XOVERLAY (overlay
);
3842 if (b
->overlays_before
)
3843 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3844 b
->overlays_before
= XOVERLAY (overlay
);
3847 /* This puts it in the right list, and in the right order. */
3848 recenter_overlay_lists (b
, b
->overlay_center
);
3850 /* We don't need to redisplay the region covered by the overlay, because
3851 the overlay has no properties at the moment. */
3856 /* Mark a section of BUF as needing redisplay because of overlays changes. */
3859 modify_overlay (buf
, start
, end
)
3861 EMACS_INT start
, end
;
3870 BUF_COMPUTE_UNCHANGED (buf
, start
, end
);
3872 /* If this is a buffer not in the selected window,
3873 we must do other windows. */
3874 if (buf
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
3875 windows_or_buffers_changed
= 1;
3876 /* If multiple windows show this buffer, we must do other windows. */
3877 else if (buffer_shared
> 1)
3878 windows_or_buffers_changed
= 1;
3879 /* If we modify an overlay at the end of the buffer, we cannot
3880 be sure that window end is still valid. */
3881 else if (end
>= ZV
&& start
<= ZV
)
3882 windows_or_buffers_changed
= 1;
3884 ++BUF_OVERLAY_MODIFF (buf
);
3888 Lisp_Object
Fdelete_overlay ();
3890 static struct Lisp_Overlay
*
3891 unchain_overlay (list
, overlay
)
3892 struct Lisp_Overlay
*list
, *overlay
;
3894 struct Lisp_Overlay
*tmp
, *prev
;
3895 for (tmp
= list
, prev
= NULL
; tmp
; prev
= tmp
, tmp
= tmp
->next
)
3899 prev
->next
= tmp
->next
;
3902 overlay
->next
= NULL
;
3908 DEFUN ("move-overlay", Fmove_overlay
, Smove_overlay
, 3, 4, 0,
3909 doc
: /* Set the endpoints of OVERLAY to BEG and END in BUFFER.
3910 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.
3911 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current
3913 (overlay
, beg
, end
, buffer
)
3914 Lisp_Object overlay
, beg
, end
, buffer
;
3916 struct buffer
*b
, *ob
;
3917 Lisp_Object obuffer
;
3918 int count
= SPECPDL_INDEX ();
3920 CHECK_OVERLAY (overlay
);
3922 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3924 XSETBUFFER (buffer
, current_buffer
);
3925 CHECK_BUFFER (buffer
);
3928 && ! EQ (Fmarker_buffer (beg
), buffer
))
3929 error ("Marker points into wrong buffer");
3931 && ! EQ (Fmarker_buffer (end
), buffer
))
3932 error ("Marker points into wrong buffer");
3934 CHECK_NUMBER_COERCE_MARKER (beg
);
3935 CHECK_NUMBER_COERCE_MARKER (end
);
3937 if (XINT (beg
) == XINT (end
) && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
3938 return Fdelete_overlay (overlay
);
3940 if (XINT (beg
) > XINT (end
))
3943 temp
= beg
; beg
= end
; end
= temp
;
3946 specbind (Qinhibit_quit
, Qt
);
3948 obuffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3949 b
= XBUFFER (buffer
);
3950 ob
= BUFFERP (obuffer
) ? XBUFFER (obuffer
) : (struct buffer
*) 0;
3952 /* If the overlay has changed buffers, do a thorough redisplay. */
3953 if (!EQ (buffer
, obuffer
))
3955 /* Redisplay where the overlay was. */
3956 if (!NILP (obuffer
))
3961 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3962 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3964 modify_overlay (ob
, o_beg
, o_end
);
3967 /* Redisplay where the overlay is going to be. */
3968 modify_overlay (b
, XINT (beg
), XINT (end
));
3971 /* Redisplay the area the overlay has just left, or just enclosed. */
3975 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3976 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3978 if (o_beg
== XINT (beg
))
3979 modify_overlay (b
, o_end
, XINT (end
));
3980 else if (o_end
== XINT (end
))
3981 modify_overlay (b
, o_beg
, XINT (beg
));
3984 if (XINT (beg
) < o_beg
) o_beg
= XINT (beg
);
3985 if (XINT (end
) > o_end
) o_end
= XINT (end
);
3986 modify_overlay (b
, o_beg
, o_end
);
3990 if (!NILP (obuffer
))
3993 = unchain_overlay (ob
->overlays_before
, XOVERLAY (overlay
));
3995 = unchain_overlay (ob
->overlays_after
, XOVERLAY (overlay
));
3996 eassert (XOVERLAY (overlay
)->next
== NULL
);
3999 Fset_marker (OVERLAY_START (overlay
), beg
, buffer
);
4000 Fset_marker (OVERLAY_END (overlay
), end
, buffer
);
4002 /* Put the overlay on the wrong list. */
4003 end
= OVERLAY_END (overlay
);
4004 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
4006 XOVERLAY (overlay
)->next
= b
->overlays_after
;
4007 b
->overlays_after
= XOVERLAY (overlay
);
4011 XOVERLAY (overlay
)->next
= b
->overlays_before
;
4012 b
->overlays_before
= XOVERLAY (overlay
);
4015 /* This puts it in the right list, and in the right order. */
4016 recenter_overlay_lists (b
, b
->overlay_center
);
4018 return unbind_to (count
, overlay
);
4021 DEFUN ("delete-overlay", Fdelete_overlay
, Sdelete_overlay
, 1, 1, 0,
4022 doc
: /* Delete the overlay OVERLAY from its buffer. */)
4024 Lisp_Object overlay
;
4028 int count
= SPECPDL_INDEX ();
4030 CHECK_OVERLAY (overlay
);
4032 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4036 b
= XBUFFER (buffer
);
4037 specbind (Qinhibit_quit
, Qt
);
4039 b
->overlays_before
= unchain_overlay (b
->overlays_before
,XOVERLAY (overlay
));
4040 b
->overlays_after
= unchain_overlay (b
->overlays_after
, XOVERLAY (overlay
));
4041 eassert (XOVERLAY (overlay
)->next
== NULL
);
4043 marker_position (OVERLAY_START (overlay
)),
4044 marker_position (OVERLAY_END (overlay
)));
4045 Fset_marker (OVERLAY_START (overlay
), Qnil
, Qnil
);
4046 Fset_marker (OVERLAY_END (overlay
), Qnil
, Qnil
);
4048 /* When deleting an overlay with before or after strings, turn off
4049 display optimizations for the affected buffer, on the basis that
4050 these strings may contain newlines. This is easier to do than to
4051 check for that situation during redisplay. */
4052 if (!windows_or_buffers_changed
4053 && (!NILP (Foverlay_get (overlay
, Qbefore_string
))
4054 || !NILP (Foverlay_get (overlay
, Qafter_string
))))
4055 b
->prevent_redisplay_optimizations_p
= 1;
4057 return unbind_to (count
, Qnil
);
4060 /* Overlay dissection functions. */
4062 DEFUN ("overlay-start", Foverlay_start
, Soverlay_start
, 1, 1, 0,
4063 doc
: /* Return the position at which OVERLAY starts. */)
4065 Lisp_Object overlay
;
4067 CHECK_OVERLAY (overlay
);
4069 return (Fmarker_position (OVERLAY_START (overlay
)));
4072 DEFUN ("overlay-end", Foverlay_end
, Soverlay_end
, 1, 1, 0,
4073 doc
: /* Return the position at which OVERLAY ends. */)
4075 Lisp_Object overlay
;
4077 CHECK_OVERLAY (overlay
);
4079 return (Fmarker_position (OVERLAY_END (overlay
)));
4082 DEFUN ("overlay-buffer", Foverlay_buffer
, Soverlay_buffer
, 1, 1, 0,
4083 doc
: /* Return the buffer OVERLAY belongs to.
4084 Return nil if OVERLAY has been deleted. */)
4086 Lisp_Object overlay
;
4088 CHECK_OVERLAY (overlay
);
4090 return Fmarker_buffer (OVERLAY_START (overlay
));
4093 DEFUN ("overlay-properties", Foverlay_properties
, Soverlay_properties
, 1, 1, 0,
4094 doc
: /* Return a list of the properties on OVERLAY.
4095 This is a copy of OVERLAY's plist; modifying its conses has no effect on
4098 Lisp_Object overlay
;
4100 CHECK_OVERLAY (overlay
);
4102 return Fcopy_sequence (XOVERLAY (overlay
)->plist
);
4106 DEFUN ("overlays-at", Foverlays_at
, Soverlays_at
, 1, 1, 0,
4107 doc
: /* Return a list of the overlays that contain the character at POS. */)
4112 Lisp_Object
*overlay_vec
;
4116 CHECK_NUMBER_COERCE_MARKER (pos
);
4119 /* We can't use alloca here because overlays_at can call xrealloc. */
4120 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
4122 /* Put all the overlays we want in a vector in overlay_vec.
4123 Store the length in len. */
4124 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4125 (EMACS_INT
*) 0, (EMACS_INT
*) 0, 0);
4127 /* Make a list of them all. */
4128 result
= Flist (noverlays
, overlay_vec
);
4130 xfree (overlay_vec
);
4134 DEFUN ("overlays-in", Foverlays_in
, Soverlays_in
, 2, 2, 0,
4135 doc
: /* Return a list of the overlays that overlap the region BEG ... END.
4136 Overlap means that at least one character is contained within the overlay
4137 and also contained within the specified region.
4138 Empty overlays are included in the result if they are located at BEG,
4139 between BEG and END, or at END provided END denotes the position at the
4140 end of the buffer. */)
4142 Lisp_Object beg
, end
;
4145 Lisp_Object
*overlay_vec
;
4149 CHECK_NUMBER_COERCE_MARKER (beg
);
4150 CHECK_NUMBER_COERCE_MARKER (end
);
4153 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
4155 /* Put all the overlays we want in a vector in overlay_vec.
4156 Store the length in len. */
4157 noverlays
= overlays_in (XINT (beg
), XINT (end
), 1, &overlay_vec
, &len
,
4158 (int *) 0, (int *) 0);
4160 /* Make a list of them all. */
4161 result
= Flist (noverlays
, overlay_vec
);
4163 xfree (overlay_vec
);
4167 DEFUN ("next-overlay-change", Fnext_overlay_change
, Snext_overlay_change
,
4169 doc
: /* Return the next position after POS where an overlay starts or ends.
4170 If there are no overlay boundaries from POS to (point-max),
4171 the value is (point-max). */)
4177 Lisp_Object
*overlay_vec
;
4181 CHECK_NUMBER_COERCE_MARKER (pos
);
4184 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
4186 /* Put all the overlays we want in a vector in overlay_vec.
4187 Store the length in len.
4188 endpos gets the position where the next overlay starts. */
4189 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4190 &endpos
, (EMACS_INT
*) 0, 1);
4192 /* If any of these overlays ends before endpos,
4193 use its ending point instead. */
4194 for (i
= 0; i
< noverlays
; i
++)
4199 oend
= OVERLAY_END (overlay_vec
[i
]);
4200 oendpos
= OVERLAY_POSITION (oend
);
4201 if (oendpos
< endpos
)
4205 xfree (overlay_vec
);
4206 return make_number (endpos
);
4209 DEFUN ("previous-overlay-change", Fprevious_overlay_change
,
4210 Sprevious_overlay_change
, 1, 1, 0,
4211 doc
: /* Return the previous position before POS where an overlay starts or ends.
4212 If there are no overlay boundaries from (point-min) to POS,
4213 the value is (point-min). */)
4219 Lisp_Object
*overlay_vec
;
4222 CHECK_NUMBER_COERCE_MARKER (pos
);
4224 /* At beginning of buffer, we know the answer;
4225 avoid bug subtracting 1 below. */
4226 if (XINT (pos
) == BEGV
)
4230 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
4232 /* Put all the overlays we want in a vector in overlay_vec.
4233 Store the length in len.
4234 prevpos gets the position of the previous change. */
4235 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4236 (EMACS_INT
*) 0, &prevpos
, 1);
4238 xfree (overlay_vec
);
4239 return make_number (prevpos
);
4242 /* These functions are for debugging overlays. */
4244 DEFUN ("overlay-lists", Foverlay_lists
, Soverlay_lists
, 0, 0, 0,
4245 doc
: /* Return a pair of lists giving all the overlays of the current buffer.
4246 The car has all the overlays before the overlay center;
4247 the cdr has all the overlays after the overlay center.
4248 Recentering overlays moves overlays between these lists.
4249 The lists you get are copies, so that changing them has no effect.
4250 However, the overlays you get are the real objects that the buffer uses. */)
4253 struct Lisp_Overlay
*ol
;
4254 Lisp_Object before
= Qnil
, after
= Qnil
, tmp
;
4255 for (ol
= current_buffer
->overlays_before
; ol
; ol
= ol
->next
)
4258 before
= Fcons (tmp
, before
);
4260 for (ol
= current_buffer
->overlays_after
; ol
; ol
= ol
->next
)
4263 after
= Fcons (tmp
, after
);
4265 return Fcons (Fnreverse (before
), Fnreverse (after
));
4268 DEFUN ("overlay-recenter", Foverlay_recenter
, Soverlay_recenter
, 1, 1, 0,
4269 doc
: /* Recenter the overlays of the current buffer around position POS.
4270 That makes overlay lookup faster for positions near POS (but perhaps slower
4271 for positions far away from POS). */)
4275 CHECK_NUMBER_COERCE_MARKER (pos
);
4277 recenter_overlay_lists (current_buffer
, XINT (pos
));
4281 DEFUN ("overlay-get", Foverlay_get
, Soverlay_get
, 2, 2, 0,
4282 doc
: /* Get the property of overlay OVERLAY with property name PROP. */)
4284 Lisp_Object overlay
, prop
;
4286 CHECK_OVERLAY (overlay
);
4287 return lookup_char_property (XOVERLAY (overlay
)->plist
, prop
, 0);
4290 DEFUN ("overlay-put", Foverlay_put
, Soverlay_put
, 3, 3, 0,
4291 doc
: /* Set one property of overlay OVERLAY: give property PROP value VALUE. */)
4292 (overlay
, prop
, value
)
4293 Lisp_Object overlay
, prop
, value
;
4295 Lisp_Object tail
, buffer
;
4298 CHECK_OVERLAY (overlay
);
4300 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4302 for (tail
= XOVERLAY (overlay
)->plist
;
4303 CONSP (tail
) && CONSP (XCDR (tail
));
4304 tail
= XCDR (XCDR (tail
)))
4305 if (EQ (XCAR (tail
), prop
))
4307 changed
= !EQ (XCAR (XCDR (tail
)), value
);
4308 XSETCAR (XCDR (tail
), value
);
4311 /* It wasn't in the list, so add it to the front. */
4312 changed
= !NILP (value
);
4313 XOVERLAY (overlay
)->plist
4314 = Fcons (prop
, Fcons (value
, XOVERLAY (overlay
)->plist
));
4316 if (! NILP (buffer
))
4319 modify_overlay (XBUFFER (buffer
),
4320 marker_position (OVERLAY_START (overlay
)),
4321 marker_position (OVERLAY_END (overlay
)));
4322 if (EQ (prop
, Qevaporate
) && ! NILP (value
)
4323 && (OVERLAY_POSITION (OVERLAY_START (overlay
))
4324 == OVERLAY_POSITION (OVERLAY_END (overlay
))))
4325 Fdelete_overlay (overlay
);
4331 /* Subroutine of report_overlay_modification. */
4333 /* Lisp vector holding overlay hook functions to call.
4334 Vector elements come in pairs.
4335 Each even-index element is a list of hook functions.
4336 The following odd-index element is the overlay they came from.
4338 Before the buffer change, we fill in this vector
4339 as we call overlay hook functions.
4340 After the buffer change, we get the functions to call from this vector.
4341 This way we always call the same functions before and after the change. */
4342 static Lisp_Object last_overlay_modification_hooks
;
4344 /* Number of elements actually used in last_overlay_modification_hooks. */
4345 static int last_overlay_modification_hooks_used
;
4347 /* Add one functionlist/overlay pair
4348 to the end of last_overlay_modification_hooks. */
4351 add_overlay_mod_hooklist (functionlist
, overlay
)
4352 Lisp_Object functionlist
, overlay
;
4354 int oldsize
= XVECTOR (last_overlay_modification_hooks
)->size
;
4356 if (last_overlay_modification_hooks_used
== oldsize
)
4357 last_overlay_modification_hooks
= larger_vector
4358 (last_overlay_modification_hooks
, oldsize
* 2, Qnil
);
4359 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4360 functionlist
); last_overlay_modification_hooks_used
++;
4361 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4362 overlay
); last_overlay_modification_hooks_used
++;
4365 /* Run the modification-hooks of overlays that include
4366 any part of the text in START to END.
4367 If this change is an insertion, also
4368 run the insert-before-hooks of overlay starting at END,
4369 and the insert-after-hooks of overlay ending at START.
4371 This is called both before and after the modification.
4372 AFTER is nonzero when we call after the modification.
4374 ARG1, ARG2, ARG3 are arguments to pass to the hook functions.
4375 When AFTER is nonzero, they are the start position,
4376 the position after the inserted new text,
4377 and the length of deleted or replaced old text. */
4380 report_overlay_modification (start
, end
, after
, arg1
, arg2
, arg3
)
4381 Lisp_Object start
, end
;
4383 Lisp_Object arg1
, arg2
, arg3
;
4385 Lisp_Object prop
, overlay
;
4386 struct Lisp_Overlay
*tail
;
4387 /* 1 if this change is an insertion. */
4388 int insertion
= (after
? XFASTINT (arg3
) == 0 : EQ (start
, end
));
4389 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4394 /* We used to run the functions as soon as we found them and only register
4395 them in last_overlay_modification_hooks for the purpose of the `after'
4396 case. But running elisp code as we traverse the list of overlays is
4397 painful because the list can be modified by the elisp code so we had to
4398 copy at several places. We now simply do a read-only traversal that
4399 only collects the functions to run and we run them afterwards. It's
4400 simpler, especially since all the code was already there. -stef */
4404 /* We are being called before a change.
4405 Scan the overlays to find the functions to call. */
4406 last_overlay_modification_hooks_used
= 0;
4407 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4409 int startpos
, endpos
;
4410 Lisp_Object ostart
, oend
;
4412 XSETMISC (overlay
, tail
);
4414 ostart
= OVERLAY_START (overlay
);
4415 oend
= OVERLAY_END (overlay
);
4416 endpos
= OVERLAY_POSITION (oend
);
4417 if (XFASTINT (start
) > endpos
)
4419 startpos
= OVERLAY_POSITION (ostart
);
4420 if (insertion
&& (XFASTINT (start
) == startpos
4421 || XFASTINT (end
) == startpos
))
4423 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4425 add_overlay_mod_hooklist (prop
, overlay
);
4427 if (insertion
&& (XFASTINT (start
) == endpos
4428 || XFASTINT (end
) == endpos
))
4430 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4432 add_overlay_mod_hooklist (prop
, overlay
);
4434 /* Test for intersecting intervals. This does the right thing
4435 for both insertion and deletion. */
4436 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4438 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4440 add_overlay_mod_hooklist (prop
, overlay
);
4444 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4446 int startpos
, endpos
;
4447 Lisp_Object ostart
, oend
;
4449 XSETMISC (overlay
, tail
);
4451 ostart
= OVERLAY_START (overlay
);
4452 oend
= OVERLAY_END (overlay
);
4453 startpos
= OVERLAY_POSITION (ostart
);
4454 endpos
= OVERLAY_POSITION (oend
);
4455 if (XFASTINT (end
) < startpos
)
4457 if (insertion
&& (XFASTINT (start
) == startpos
4458 || XFASTINT (end
) == startpos
))
4460 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4462 add_overlay_mod_hooklist (prop
, overlay
);
4464 if (insertion
&& (XFASTINT (start
) == endpos
4465 || XFASTINT (end
) == endpos
))
4467 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4469 add_overlay_mod_hooklist (prop
, overlay
);
4471 /* Test for intersecting intervals. This does the right thing
4472 for both insertion and deletion. */
4473 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4475 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4477 add_overlay_mod_hooklist (prop
, overlay
);
4482 GCPRO4 (overlay
, arg1
, arg2
, arg3
);
4484 /* Call the functions recorded in last_overlay_modification_hooks.
4485 First copy the vector contents, in case some of these hooks
4486 do subsequent modification of the buffer. */
4487 int size
= last_overlay_modification_hooks_used
;
4488 Lisp_Object
*copy
= (Lisp_Object
*) alloca (size
* sizeof (Lisp_Object
));
4491 bcopy (XVECTOR (last_overlay_modification_hooks
)->contents
,
4492 copy
, size
* sizeof (Lisp_Object
));
4494 gcpro1
.nvars
= size
;
4496 for (i
= 0; i
< size
;)
4498 Lisp_Object prop
, overlay
;
4500 overlay
= copy
[i
++];
4501 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
4508 call_overlay_mod_hooks (list
, overlay
, after
, arg1
, arg2
, arg3
)
4509 Lisp_Object list
, overlay
;
4511 Lisp_Object arg1
, arg2
, arg3
;
4513 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4515 GCPRO4 (list
, arg1
, arg2
, arg3
);
4517 while (CONSP (list
))
4520 call4 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
);
4522 call5 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
, arg3
);
4528 /* Delete any zero-sized overlays at position POS, if the `evaporate'
4531 evaporate_overlays (pos
)
4534 Lisp_Object overlay
, hit_list
;
4535 struct Lisp_Overlay
*tail
;
4538 if (pos
<= current_buffer
->overlay_center
)
4539 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4542 XSETMISC (overlay
, tail
);
4543 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4546 if (endpos
== pos
&& OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
4547 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4548 hit_list
= Fcons (overlay
, hit_list
);
4551 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4554 XSETMISC (overlay
, tail
);
4555 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4558 if (startpos
== pos
&& OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
4559 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4560 hit_list
= Fcons (overlay
, hit_list
);
4562 for (; CONSP (hit_list
); hit_list
= XCDR (hit_list
))
4563 Fdelete_overlay (XCAR (hit_list
));
4566 /* Somebody has tried to store a value with an unacceptable type
4567 in the slot with offset OFFSET. */
4570 buffer_slot_type_mismatch (newval
, type
)
4574 Lisp_Object predicate
;
4578 case_Lisp_Int
: predicate
= Qintegerp
; break;
4579 case Lisp_String
: predicate
= Qstringp
; break;
4580 case Lisp_Symbol
: predicate
= Qsymbolp
; break;
4584 wrong_type_argument (predicate
, newval
);
4588 /***********************************************************************
4589 Allocation with mmap
4590 ***********************************************************************/
4592 #ifdef USE_MMAP_FOR_BUFFERS
4594 #include <sys/types.h>
4595 #include <sys/mman.h>
4598 #ifdef MAP_ANONYMOUS
4599 #define MAP_ANON MAP_ANONYMOUS
4606 #define MAP_FAILED ((void *) -1)
4619 /* Memory is allocated in regions which are mapped using mmap(2).
4620 The current implementation lets the system select mapped
4621 addresses; we're not using MAP_FIXED in general, except when
4622 trying to enlarge regions.
4624 Each mapped region starts with a mmap_region structure, the user
4625 area starts after that structure, aligned to MEM_ALIGN.
4627 +-----------------------+
4628 | struct mmap_info + |
4630 +-----------------------+
4634 +-----------------------+ */
4638 /* User-specified size. */
4639 size_t nbytes_specified
;
4641 /* Number of bytes mapped */
4642 size_t nbytes_mapped
;
4644 /* Pointer to the location holding the address of the memory
4645 allocated with the mmap'd block. The variable actually points
4646 after this structure. */
4649 /* Next and previous in list of all mmap'd regions. */
4650 struct mmap_region
*next
, *prev
;
4653 /* Doubly-linked list of mmap'd regions. */
4655 static struct mmap_region
*mmap_regions
;
4657 /* File descriptor for mmap. If we don't have anonymous mapping,
4658 /dev/zero will be opened on it. */
4662 /* Temporary storage for mmap_set_vars, see there. */
4664 static struct mmap_region
*mmap_regions_1
;
4665 static int mmap_fd_1
;
4667 /* Page size on this system. */
4669 static int mmap_page_size
;
4671 /* 1 means mmap has been intialized. */
4673 static int mmap_initialized_p
;
4675 /* Value is X rounded up to the next multiple of N. */
4677 #define ROUND(X, N) (((X) + (N) - 1) / (N) * (N))
4679 /* Size of mmap_region structure plus padding. */
4681 #define MMAP_REGION_STRUCT_SIZE \
4682 ROUND (sizeof (struct mmap_region), MEM_ALIGN)
4684 /* Given a pointer P to the start of the user-visible part of a mapped
4685 region, return a pointer to the start of the region. */
4687 #define MMAP_REGION(P) \
4688 ((struct mmap_region *) ((char *) (P) - MMAP_REGION_STRUCT_SIZE))
4690 /* Given a pointer P to the start of a mapped region, return a pointer
4691 to the start of the user-visible part of the region. */
4693 #define MMAP_USER_AREA(P) \
4694 ((POINTER_TYPE *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
4696 #define MEM_ALIGN sizeof (double)
4698 /* Predicate returning true if part of the address range [START .. END]
4699 is currently mapped. Used to prevent overwriting an existing
4702 Default is to conservativly assume the address range is occupied by
4703 something else. This can be overridden by system configuration
4704 files if system-specific means to determine this exists. */
4706 #ifndef MMAP_ALLOCATED_P
4707 #define MMAP_ALLOCATED_P(start, end) 1
4710 /* Function prototypes. */
4712 static int mmap_free_1
P_ ((struct mmap_region
*));
4713 static int mmap_enlarge
P_ ((struct mmap_region
*, int));
4714 static struct mmap_region
*mmap_find
P_ ((POINTER_TYPE
*, POINTER_TYPE
*));
4715 static POINTER_TYPE
*mmap_alloc
P_ ((POINTER_TYPE
**, size_t));
4716 static POINTER_TYPE
*mmap_realloc
P_ ((POINTER_TYPE
**, size_t));
4717 static void mmap_free
P_ ((POINTER_TYPE
**ptr
));
4718 static void mmap_init
P_ ((void));
4721 /* Return a region overlapping address range START...END, or null if
4722 none. END is not including, i.e. the last byte in the range
4725 static struct mmap_region
*
4726 mmap_find (start
, end
)
4727 POINTER_TYPE
*start
, *end
;
4729 struct mmap_region
*r
;
4730 char *s
= (char *) start
, *e
= (char *) end
;
4732 for (r
= mmap_regions
; r
; r
= r
->next
)
4734 char *rstart
= (char *) r
;
4735 char *rend
= rstart
+ r
->nbytes_mapped
;
4737 if (/* First byte of range, i.e. START, in this region? */
4738 (s
>= rstart
&& s
< rend
)
4739 /* Last byte of range, i.e. END - 1, in this region? */
4740 || (e
> rstart
&& e
<= rend
)
4741 /* First byte of this region in the range? */
4742 || (rstart
>= s
&& rstart
< e
)
4743 /* Last byte of this region in the range? */
4744 || (rend
> s
&& rend
<= e
))
4752 /* Unmap a region. P is a pointer to the start of the user-araa of
4753 the region. Value is non-zero if successful. */
4757 struct mmap_region
*r
;
4760 r
->next
->prev
= r
->prev
;
4762 r
->prev
->next
= r
->next
;
4764 mmap_regions
= r
->next
;
4766 if (munmap ((POINTER_TYPE
*) r
, r
->nbytes_mapped
) == -1)
4768 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4776 /* Enlarge region R by NPAGES pages. NPAGES < 0 means shrink R.
4777 Value is non-zero if successful. */
4780 mmap_enlarge (r
, npages
)
4781 struct mmap_region
*r
;
4784 char *region_end
= (char *) r
+ r
->nbytes_mapped
;
4790 /* Unmap pages at the end of the region. */
4791 nbytes
= - npages
* mmap_page_size
;
4792 if (munmap (region_end
- nbytes
, nbytes
) == -1)
4793 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4796 r
->nbytes_mapped
-= nbytes
;
4800 else if (npages
> 0)
4802 nbytes
= npages
* mmap_page_size
;
4804 /* Try to map additional pages at the end of the region. We
4805 cannot do this if the address range is already occupied by
4806 something else because mmap deletes any previous mapping.
4807 I'm not sure this is worth doing, let's see. */
4808 if (!MMAP_ALLOCATED_P (region_end
, region_end
+ nbytes
))
4812 p
= mmap (region_end
, nbytes
, PROT_READ
| PROT_WRITE
,
4813 MAP_ANON
| MAP_PRIVATE
| MAP_FIXED
, mmap_fd
, 0);
4814 if (p
== MAP_FAILED
)
4815 ; /* fprintf (stderr, "mmap: %s\n", emacs_strerror (errno)); */
4816 else if (p
!= (POINTER_TYPE
*) region_end
)
4818 /* Kernels are free to choose a different address. In
4819 that case, unmap what we've mapped above; we have
4821 if (munmap (p
, nbytes
) == -1)
4822 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4826 r
->nbytes_mapped
+= nbytes
;
4836 /* Set or reset variables holding references to mapped regions. If
4837 RESTORE_P is zero, set all variables to null. If RESTORE_P is
4838 non-zero, set all variables to the start of the user-areas
4841 This function is called from Fdump_emacs to ensure that the dumped
4842 Emacs doesn't contain references to memory that won't be mapped
4843 when Emacs starts. */
4846 mmap_set_vars (restore_p
)
4849 struct mmap_region
*r
;
4853 mmap_regions
= mmap_regions_1
;
4854 mmap_fd
= mmap_fd_1
;
4855 for (r
= mmap_regions
; r
; r
= r
->next
)
4856 *r
->var
= MMAP_USER_AREA (r
);
4860 for (r
= mmap_regions
; r
; r
= r
->next
)
4862 mmap_regions_1
= mmap_regions
;
4863 mmap_regions
= NULL
;
4864 mmap_fd_1
= mmap_fd
;
4870 /* Allocate a block of storage large enough to hold NBYTES bytes of
4871 data. A pointer to the data is returned in *VAR. VAR is thus the
4872 address of some variable which will use the data area.
4874 The allocation of 0 bytes is valid.
4876 If we can't allocate the necessary memory, set *VAR to null, and
4879 static POINTER_TYPE
*
4880 mmap_alloc (var
, nbytes
)
4889 map
= ROUND (nbytes
+ MMAP_REGION_STRUCT_SIZE
, mmap_page_size
);
4890 p
= mmap (NULL
, map
, PROT_READ
| PROT_WRITE
, MAP_ANON
| MAP_PRIVATE
,
4893 if (p
== MAP_FAILED
)
4895 if (errno
!= ENOMEM
)
4896 fprintf (stderr
, "mmap: %s\n", emacs_strerror (errno
));
4901 struct mmap_region
*r
= (struct mmap_region
*) p
;
4903 r
->nbytes_specified
= nbytes
;
4904 r
->nbytes_mapped
= map
;
4907 r
->next
= mmap_regions
;
4912 p
= MMAP_USER_AREA (p
);
4919 /* Given a pointer at address VAR to data allocated with mmap_alloc,
4920 resize it to size NBYTES. Change *VAR to reflect the new block,
4921 and return this value. If more memory cannot be allocated, then
4922 leave *VAR unchanged, and return null. */
4924 static POINTER_TYPE
*
4925 mmap_realloc (var
, nbytes
)
4929 POINTER_TYPE
*result
;
4934 result
= mmap_alloc (var
, nbytes
);
4935 else if (nbytes
== 0)
4938 result
= mmap_alloc (var
, nbytes
);
4942 struct mmap_region
*r
= MMAP_REGION (*var
);
4943 size_t room
= r
->nbytes_mapped
- MMAP_REGION_STRUCT_SIZE
;
4948 POINTER_TYPE
*old_ptr
= *var
;
4950 /* Try to map additional pages at the end of the region.
4951 If that fails, allocate a new region, copy data
4952 from the old region, then free it. */
4953 if (mmap_enlarge (r
, (ROUND (nbytes
- room
, mmap_page_size
)
4956 r
->nbytes_specified
= nbytes
;
4957 *var
= result
= old_ptr
;
4959 else if (mmap_alloc (var
, nbytes
))
4961 bcopy (old_ptr
, *var
, r
->nbytes_specified
);
4962 mmap_free_1 (MMAP_REGION (old_ptr
));
4964 r
= MMAP_REGION (result
);
4965 r
->nbytes_specified
= nbytes
;
4973 else if (room
- nbytes
>= mmap_page_size
)
4975 /* Shrinking by at least a page. Let's give some
4976 memory back to the system.
4978 The extra parens are to make the division happens first,
4979 on positive values, so we know it will round towards
4981 mmap_enlarge (r
, - ((room
- nbytes
) / mmap_page_size
));
4983 r
->nbytes_specified
= nbytes
;
4987 /* Leave it alone. */
4989 r
->nbytes_specified
= nbytes
;
4997 /* Free a block of relocatable storage whose data is pointed to by
4998 PTR. Store 0 in *PTR to show there's no block allocated. */
5008 mmap_free_1 (MMAP_REGION (*var
));
5014 /* Perform necessary intializations for the use of mmap. */
5020 /* The value of mmap_fd is initially 0 in temacs, and -1
5021 in a dumped Emacs. */
5024 /* No anonymous mmap -- we need the file descriptor. */
5025 mmap_fd
= open ("/dev/zero", O_RDONLY
);
5027 fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno
));
5029 #endif /* MAP_ANON == 0 */
5031 if (mmap_initialized_p
)
5033 mmap_initialized_p
= 1;
5039 mmap_page_size
= getpagesize ();
5042 #endif /* USE_MMAP_FOR_BUFFERS */
5046 /***********************************************************************
5047 Buffer-text Allocation
5048 ***********************************************************************/
5051 extern POINTER_TYPE
*r_alloc
P_ ((POINTER_TYPE
**, size_t));
5052 extern POINTER_TYPE
*r_re_alloc
P_ ((POINTER_TYPE
**, size_t));
5053 extern void r_alloc_free
P_ ((POINTER_TYPE
**ptr
));
5054 #endif /* REL_ALLOC */
5057 /* Allocate NBYTES bytes for buffer B's text buffer. */
5060 alloc_buffer_text (b
, nbytes
)
5067 #if defined USE_MMAP_FOR_BUFFERS
5068 p
= mmap_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
5069 #elif defined REL_ALLOC
5070 p
= r_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
5072 p
= xmalloc (nbytes
);
5081 b
->text
->beg
= (unsigned char *) p
;
5085 /* Enlarge buffer B's text buffer by DELTA bytes. DELTA < 0 means
5089 enlarge_buffer_text (struct buffer
*b
, EMACS_INT delta
)
5092 size_t nbytes
= (BUF_Z_BYTE (b
) - BUF_BEG_BYTE (b
) + BUF_GAP_SIZE (b
) + 1
5095 #if defined USE_MMAP_FOR_BUFFERS
5096 p
= mmap_realloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
5097 #elif defined REL_ALLOC
5098 p
= r_re_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
5100 p
= xrealloc (b
->text
->beg
, nbytes
);
5109 BUF_BEG_ADDR (b
) = (unsigned char *) p
;
5114 /* Free buffer B's text buffer. */
5117 free_buffer_text (b
)
5122 #if defined USE_MMAP_FOR_BUFFERS
5123 mmap_free ((POINTER_TYPE
**) &b
->text
->beg
);
5124 #elif defined REL_ALLOC
5125 r_alloc_free ((POINTER_TYPE
**) &b
->text
->beg
);
5127 xfree (b
->text
->beg
);
5130 BUF_BEG_ADDR (b
) = NULL
;
5136 /***********************************************************************
5138 ***********************************************************************/
5145 bzero (buffer_permanent_local_flags
, sizeof buffer_permanent_local_flags
);
5147 /* Make sure all markable slots in buffer_defaults
5148 are initialized reasonably, so mark_buffer won't choke. */
5149 reset_buffer (&buffer_defaults
);
5150 reset_buffer_local_variables (&buffer_defaults
, 1);
5151 reset_buffer (&buffer_local_symbols
);
5152 reset_buffer_local_variables (&buffer_local_symbols
, 1);
5153 /* Prevent GC from getting confused. */
5154 buffer_defaults
.text
= &buffer_defaults
.own_text
;
5155 buffer_local_symbols
.text
= &buffer_local_symbols
.own_text
;
5156 BUF_INTERVALS (&buffer_defaults
) = 0;
5157 BUF_INTERVALS (&buffer_local_symbols
) = 0;
5158 XSETPVECTYPE (&buffer_defaults
, PVEC_BUFFER
);
5159 XSETBUFFER (Vbuffer_defaults
, &buffer_defaults
);
5160 XSETPVECTYPE (&buffer_local_symbols
, PVEC_BUFFER
);
5161 XSETBUFFER (Vbuffer_local_symbols
, &buffer_local_symbols
);
5163 /* Set up the default values of various buffer slots. */
5164 /* Must do these before making the first buffer! */
5166 /* real setup is done in bindings.el */
5167 buffer_defaults
.mode_line_format
= make_pure_c_string ("%-");
5168 buffer_defaults
.header_line_format
= Qnil
;
5169 buffer_defaults
.abbrev_mode
= Qnil
;
5170 buffer_defaults
.overwrite_mode
= Qnil
;
5171 buffer_defaults
.case_fold_search
= Qt
;
5172 buffer_defaults
.auto_fill_function
= Qnil
;
5173 buffer_defaults
.selective_display
= Qnil
;
5175 buffer_defaults
.selective_display_ellipses
= Qt
;
5177 buffer_defaults
.abbrev_table
= Qnil
;
5178 buffer_defaults
.display_table
= Qnil
;
5179 buffer_defaults
.undo_list
= Qnil
;
5180 buffer_defaults
.mark_active
= Qnil
;
5181 buffer_defaults
.file_format
= Qnil
;
5182 buffer_defaults
.auto_save_file_format
= Qt
;
5183 buffer_defaults
.overlays_before
= NULL
;
5184 buffer_defaults
.overlays_after
= NULL
;
5185 buffer_defaults
.overlay_center
= BEG
;
5187 XSETFASTINT (buffer_defaults
.tab_width
, 8);
5188 buffer_defaults
.truncate_lines
= Qnil
;
5189 buffer_defaults
.word_wrap
= Qnil
;
5190 buffer_defaults
.ctl_arrow
= Qt
;
5191 buffer_defaults
.bidi_display_reordering
= Qnil
;
5192 buffer_defaults
.direction_reversed
= Qnil
;
5193 buffer_defaults
.bidi_paragraph_direction
= Qnil
;
5194 buffer_defaults
.cursor_type
= Qt
;
5195 buffer_defaults
.extra_line_spacing
= Qnil
;
5196 buffer_defaults
.cursor_in_non_selected_windows
= Qt
;
5199 buffer_defaults
.buffer_file_type
= Qnil
; /* TEXT */
5201 buffer_defaults
.enable_multibyte_characters
= Qt
;
5202 buffer_defaults
.buffer_file_coding_system
= Qnil
;
5203 XSETFASTINT (buffer_defaults
.fill_column
, 70);
5204 XSETFASTINT (buffer_defaults
.left_margin
, 0);
5205 buffer_defaults
.cache_long_line_scans
= Qnil
;
5206 buffer_defaults
.file_truename
= Qnil
;
5207 XSETFASTINT (buffer_defaults
.display_count
, 0);
5208 XSETFASTINT (buffer_defaults
.left_margin_cols
, 0);
5209 XSETFASTINT (buffer_defaults
.right_margin_cols
, 0);
5210 buffer_defaults
.left_fringe_width
= Qnil
;
5211 buffer_defaults
.right_fringe_width
= Qnil
;
5212 buffer_defaults
.fringes_outside_margins
= Qnil
;
5213 buffer_defaults
.scroll_bar_width
= Qnil
;
5214 buffer_defaults
.vertical_scroll_bar_type
= Qt
;
5215 buffer_defaults
.indicate_empty_lines
= Qnil
;
5216 buffer_defaults
.indicate_buffer_boundaries
= Qnil
;
5217 buffer_defaults
.fringe_indicator_alist
= Qnil
;
5218 buffer_defaults
.fringe_cursor_alist
= Qnil
;
5219 buffer_defaults
.scroll_up_aggressively
= Qnil
;
5220 buffer_defaults
.scroll_down_aggressively
= Qnil
;
5221 buffer_defaults
.display_time
= Qnil
;
5223 /* Assign the local-flags to the slots that have default values.
5224 The local flag is a bit that is used in the buffer
5225 to say that it has its own local value for the slot.
5226 The local flag bits are in the local_var_flags slot of the buffer. */
5228 /* Nothing can work if this isn't true */
5229 if (sizeof (EMACS_INT
) != sizeof (Lisp_Object
)) abort ();
5231 /* 0 means not a lisp var, -1 means always local, else mask */
5232 bzero (&buffer_local_flags
, sizeof buffer_local_flags
);
5233 XSETINT (buffer_local_flags
.filename
, -1);
5234 XSETINT (buffer_local_flags
.directory
, -1);
5235 XSETINT (buffer_local_flags
.backed_up
, -1);
5236 XSETINT (buffer_local_flags
.save_length
, -1);
5237 XSETINT (buffer_local_flags
.auto_save_file_name
, -1);
5238 XSETINT (buffer_local_flags
.read_only
, -1);
5239 XSETINT (buffer_local_flags
.major_mode
, -1);
5240 XSETINT (buffer_local_flags
.mode_name
, -1);
5241 XSETINT (buffer_local_flags
.undo_list
, -1);
5242 XSETINT (buffer_local_flags
.mark_active
, -1);
5243 XSETINT (buffer_local_flags
.point_before_scroll
, -1);
5244 XSETINT (buffer_local_flags
.file_truename
, -1);
5245 XSETINT (buffer_local_flags
.invisibility_spec
, -1);
5246 XSETINT (buffer_local_flags
.file_format
, -1);
5247 XSETINT (buffer_local_flags
.auto_save_file_format
, -1);
5248 XSETINT (buffer_local_flags
.display_count
, -1);
5249 XSETINT (buffer_local_flags
.display_time
, -1);
5250 XSETINT (buffer_local_flags
.enable_multibyte_characters
, -1);
5253 XSETFASTINT (buffer_local_flags
.mode_line_format
, idx
); ++idx
;
5254 XSETFASTINT (buffer_local_flags
.abbrev_mode
, idx
); ++idx
;
5255 XSETFASTINT (buffer_local_flags
.overwrite_mode
, idx
); ++idx
;
5256 XSETFASTINT (buffer_local_flags
.case_fold_search
, idx
); ++idx
;
5257 XSETFASTINT (buffer_local_flags
.auto_fill_function
, idx
); ++idx
;
5258 XSETFASTINT (buffer_local_flags
.selective_display
, idx
); ++idx
;
5260 XSETFASTINT (buffer_local_flags
.selective_display_ellipses
, idx
); ++idx
;
5262 XSETFASTINT (buffer_local_flags
.tab_width
, idx
); ++idx
;
5263 XSETFASTINT (buffer_local_flags
.truncate_lines
, idx
); ++idx
;
5264 XSETFASTINT (buffer_local_flags
.word_wrap
, idx
); ++idx
;
5265 XSETFASTINT (buffer_local_flags
.ctl_arrow
, idx
); ++idx
;
5266 XSETFASTINT (buffer_local_flags
.fill_column
, idx
); ++idx
;
5267 XSETFASTINT (buffer_local_flags
.left_margin
, idx
); ++idx
;
5268 XSETFASTINT (buffer_local_flags
.abbrev_table
, idx
); ++idx
;
5269 XSETFASTINT (buffer_local_flags
.display_table
, idx
); ++idx
;
5271 XSETFASTINT (buffer_local_flags
.buffer_file_type
, idx
);
5272 /* Make this one a permanent local. */
5273 buffer_permanent_local_flags
[idx
++] = 1;
5275 XSETFASTINT (buffer_local_flags
.syntax_table
, idx
); ++idx
;
5276 XSETFASTINT (buffer_local_flags
.cache_long_line_scans
, idx
); ++idx
;
5277 XSETFASTINT (buffer_local_flags
.category_table
, idx
); ++idx
;
5278 XSETFASTINT (buffer_local_flags
.bidi_display_reordering
, idx
); ++idx
;
5279 XSETFASTINT (buffer_local_flags
.direction_reversed
, idx
); ++idx
;
5280 XSETFASTINT (buffer_local_flags
.bidi_paragraph_direction
, idx
); ++idx
;
5281 XSETFASTINT (buffer_local_flags
.buffer_file_coding_system
, idx
);
5282 /* Make this one a permanent local. */
5283 buffer_permanent_local_flags
[idx
++] = 1;
5284 XSETFASTINT (buffer_local_flags
.left_margin_cols
, idx
); ++idx
;
5285 XSETFASTINT (buffer_local_flags
.right_margin_cols
, idx
); ++idx
;
5286 XSETFASTINT (buffer_local_flags
.left_fringe_width
, idx
); ++idx
;
5287 XSETFASTINT (buffer_local_flags
.right_fringe_width
, idx
); ++idx
;
5288 XSETFASTINT (buffer_local_flags
.fringes_outside_margins
, idx
); ++idx
;
5289 XSETFASTINT (buffer_local_flags
.scroll_bar_width
, idx
); ++idx
;
5290 XSETFASTINT (buffer_local_flags
.vertical_scroll_bar_type
, idx
); ++idx
;
5291 XSETFASTINT (buffer_local_flags
.indicate_empty_lines
, idx
); ++idx
;
5292 XSETFASTINT (buffer_local_flags
.indicate_buffer_boundaries
, idx
); ++idx
;
5293 XSETFASTINT (buffer_local_flags
.fringe_indicator_alist
, idx
); ++idx
;
5294 XSETFASTINT (buffer_local_flags
.fringe_cursor_alist
, idx
); ++idx
;
5295 XSETFASTINT (buffer_local_flags
.scroll_up_aggressively
, idx
); ++idx
;
5296 XSETFASTINT (buffer_local_flags
.scroll_down_aggressively
, idx
); ++idx
;
5297 XSETFASTINT (buffer_local_flags
.header_line_format
, idx
); ++idx
;
5298 XSETFASTINT (buffer_local_flags
.cursor_type
, idx
); ++idx
;
5299 XSETFASTINT (buffer_local_flags
.extra_line_spacing
, idx
); ++idx
;
5300 XSETFASTINT (buffer_local_flags
.cursor_in_non_selected_windows
, idx
); ++idx
;
5302 /* Need more room? */
5303 if (idx
>= MAX_PER_BUFFER_VARS
)
5305 last_per_buffer_idx
= idx
;
5307 Vbuffer_alist
= Qnil
;
5311 QSFundamental
= make_pure_c_string ("Fundamental");
5313 Qfundamental_mode
= intern_c_string ("fundamental-mode");
5314 buffer_defaults
.major_mode
= Qfundamental_mode
;
5316 Qmode_class
= intern_c_string ("mode-class");
5318 Qprotected_field
= intern_c_string ("protected-field");
5320 Qpermanent_local
= intern_c_string ("permanent-local");
5322 Qkill_buffer_hook
= intern_c_string ("kill-buffer-hook");
5323 Fput (Qkill_buffer_hook
, Qpermanent_local
, Qt
);
5325 Qucs_set_table_for_input
= intern_c_string ("ucs-set-table-for-input");
5327 /* super-magic invisible buffer */
5328 Vprin1_to_string_buffer
= Fget_buffer_create (make_pure_c_string (" prin1"));
5329 Vbuffer_alist
= Qnil
;
5331 Fset_buffer (Fget_buffer_create (make_pure_c_string ("*scratch*")));
5333 inhibit_modification_hooks
= 0;
5343 #ifdef USE_MMAP_FOR_BUFFERS
5345 /* When using the ralloc implementation based on mmap(2), buffer
5346 text pointers will have been set to null in the dumped Emacs.
5350 for (b
= all_buffers
; b
; b
= b
->next
)
5351 if (b
->text
->beg
== NULL
)
5352 enlarge_buffer_text (b
, 0);
5354 #endif /* USE_MMAP_FOR_BUFFERS */
5356 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
5357 if (NILP (buffer_defaults
.enable_multibyte_characters
))
5358 Fset_buffer_multibyte (Qnil
);
5360 pwd
= get_current_dir_name ();
5363 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5365 /* Maybe this should really use some standard subroutine
5366 whose definition is filename syntax dependent. */
5368 if (!(IS_DIRECTORY_SEP (pwd
[len
- 1])))
5370 /* Grow buffer to add directory separator and '\0'. */
5371 pwd
= (char *) realloc (pwd
, len
+ 2);
5373 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5374 pwd
[len
] = DIRECTORY_SEP
;
5375 pwd
[len
+ 1] = '\0';
5378 current_buffer
->directory
= make_unibyte_string (pwd
, strlen (pwd
));
5379 if (! NILP (buffer_defaults
.enable_multibyte_characters
))
5380 /* At this moment, we still don't know how to decode the
5381 directory name. So, we keep the bytes in multibyte form so
5382 that ENCODE_FILE correctly gets the original bytes. */
5383 current_buffer
->directory
5384 = string_to_multibyte (current_buffer
->directory
);
5386 /* Add /: to the front of the name
5387 if it would otherwise be treated as magic. */
5388 temp
= Ffind_file_name_handler (current_buffer
->directory
, Qt
);
5390 /* If the default dir is just /, TEMP is non-nil
5391 because of the ange-ftp completion handler.
5392 However, it is not necessary to turn / into /:/.
5393 So avoid doing that. */
5394 && strcmp ("/", SDATA (current_buffer
->directory
)))
5395 current_buffer
->directory
5396 = concat2 (build_string ("/:"), current_buffer
->directory
);
5398 temp
= get_minibuffer (0);
5399 XBUFFER (temp
)->directory
= current_buffer
->directory
;
5404 /* Similar to defvar_lisp but define a variable whose value is the Lisp
5405 Object stored in the current buffer. address is the address of the slot
5406 in the buffer that is current now. */
5408 /* TYPE is nil for a general Lisp variable.
5409 An integer specifies a type; then only LIsp values
5410 with that type code are allowed (except that nil is allowed too).
5411 LNAME is the LIsp-level variable name.
5412 VNAME is the name of the buffer slot.
5413 DOC is a dummy where you write the doc string as a comment. */
5414 #define DEFVAR_PER_BUFFER(lname, vname, type, doc) \
5415 defvar_per_buffer (lname, vname, type, 0)
5418 defvar_per_buffer (namestring
, address
, type
, doc
)
5420 Lisp_Object
*address
;
5424 Lisp_Object sym
, val
;
5427 sym
= intern (namestring
);
5428 val
= allocate_misc ();
5429 offset
= (char *)address
- (char *)current_buffer
;
5431 XMISCTYPE (val
) = Lisp_Misc_Buffer_Objfwd
;
5432 XBUFFER_OBJFWD (val
)->offset
= offset
;
5433 XBUFFER_OBJFWD (val
)->slottype
= type
;
5434 SET_SYMBOL_VALUE (sym
, val
);
5435 PER_BUFFER_SYMBOL (offset
) = sym
;
5437 if (PER_BUFFER_IDX (offset
) == 0)
5438 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
5439 slot of buffer_local_flags */
5444 /* initialize the buffer routines */
5448 staticpro (&last_overlay_modification_hooks
);
5449 last_overlay_modification_hooks
5450 = Fmake_vector (make_number (10), Qnil
);
5452 staticpro (&Vbuffer_defaults
);
5453 staticpro (&Vbuffer_local_symbols
);
5454 staticpro (&Qfundamental_mode
);
5455 staticpro (&Qmode_class
);
5456 staticpro (&QSFundamental
);
5457 staticpro (&Vbuffer_alist
);
5458 staticpro (&Qprotected_field
);
5459 staticpro (&Qpermanent_local
);
5460 Qpermanent_local_hook
= intern_c_string ("permanent-local-hook");
5461 staticpro (&Qpermanent_local_hook
);
5462 staticpro (&Qkill_buffer_hook
);
5463 Qoverlayp
= intern_c_string ("overlayp");
5464 staticpro (&Qoverlayp
);
5465 Qevaporate
= intern_c_string ("evaporate");
5466 staticpro (&Qevaporate
);
5467 Qmodification_hooks
= intern_c_string ("modification-hooks");
5468 staticpro (&Qmodification_hooks
);
5469 Qinsert_in_front_hooks
= intern_c_string ("insert-in-front-hooks");
5470 staticpro (&Qinsert_in_front_hooks
);
5471 Qinsert_behind_hooks
= intern_c_string ("insert-behind-hooks");
5472 staticpro (&Qinsert_behind_hooks
);
5473 Qget_file_buffer
= intern_c_string ("get-file-buffer");
5474 staticpro (&Qget_file_buffer
);
5475 Qpriority
= intern_c_string ("priority");
5476 staticpro (&Qpriority
);
5477 Qwindow
= intern_c_string ("window");
5478 staticpro (&Qwindow
);
5479 Qbefore_string
= intern_c_string ("before-string");
5480 staticpro (&Qbefore_string
);
5481 Qafter_string
= intern_c_string ("after-string");
5482 staticpro (&Qafter_string
);
5483 Qfirst_change_hook
= intern_c_string ("first-change-hook");
5484 staticpro (&Qfirst_change_hook
);
5485 Qbefore_change_functions
= intern_c_string ("before-change-functions");
5486 staticpro (&Qbefore_change_functions
);
5487 Qafter_change_functions
= intern_c_string ("after-change-functions");
5488 staticpro (&Qafter_change_functions
);
5489 /* The next one is initialized in init_buffer_once. */
5490 staticpro (&Qucs_set_table_for_input
);
5492 Qkill_buffer_query_functions
= intern_c_string ("kill-buffer-query-functions");
5493 staticpro (&Qkill_buffer_query_functions
);
5495 Fput (Qprotected_field
, Qerror_conditions
,
5496 pure_cons (Qprotected_field
, pure_cons (Qerror
, Qnil
)));
5497 Fput (Qprotected_field
, Qerror_message
,
5498 make_pure_c_string ("Attempt to modify a protected field"));
5500 /* All these use DEFVAR_LISP_NOPRO because the slots in
5501 buffer_defaults will all be marked via Vbuffer_defaults. */
5503 DEFVAR_LISP_NOPRO ("default-mode-line-format",
5504 &buffer_defaults
.mode_line_format
,
5505 doc
: /* Default value of `mode-line-format' for buffers that don't override it.
5506 This is the same as (default-value 'mode-line-format). */);
5508 DEFVAR_LISP_NOPRO ("default-header-line-format",
5509 &buffer_defaults
.header_line_format
,
5510 doc
: /* Default value of `header-line-format' for buffers that don't override it.
5511 This is the same as (default-value 'header-line-format). */);
5513 DEFVAR_LISP_NOPRO ("default-cursor-type", &buffer_defaults
.cursor_type
,
5514 doc
: /* Default value of `cursor-type' for buffers that don't override it.
5515 This is the same as (default-value 'cursor-type). */);
5517 DEFVAR_LISP_NOPRO ("default-line-spacing",
5518 &buffer_defaults
.extra_line_spacing
,
5519 doc
: /* Default value of `line-spacing' for buffers that don't override it.
5520 This is the same as (default-value 'line-spacing). */);
5522 DEFVAR_LISP_NOPRO ("default-cursor-in-non-selected-windows",
5523 &buffer_defaults
.cursor_in_non_selected_windows
,
5524 doc
: /* Default value of `cursor-in-non-selected-windows'.
5525 This is the same as (default-value 'cursor-in-non-selected-windows). */);
5527 DEFVAR_LISP_NOPRO ("default-abbrev-mode",
5528 &buffer_defaults
.abbrev_mode
,
5529 doc
: /* Default value of `abbrev-mode' for buffers that do not override it.
5530 This is the same as (default-value 'abbrev-mode). */);
5532 DEFVAR_LISP_NOPRO ("default-ctl-arrow",
5533 &buffer_defaults
.ctl_arrow
,
5534 doc
: /* Default value of `ctl-arrow' for buffers that do not override it.
5535 This is the same as (default-value 'ctl-arrow). */);
5537 DEFVAR_LISP_NOPRO ("default-enable-multibyte-characters",
5538 &buffer_defaults
.enable_multibyte_characters
,
5539 doc
: /* *Default value of `enable-multibyte-characters' for buffers not overriding it.
5540 This is the same as (default-value 'enable-multibyte-characters). */);
5542 DEFVAR_LISP_NOPRO ("default-buffer-file-coding-system",
5543 &buffer_defaults
.buffer_file_coding_system
,
5544 doc
: /* Default value of `buffer-file-coding-system' for buffers not overriding it.
5545 This is the same as (default-value 'buffer-file-coding-system). */);
5547 DEFVAR_LISP_NOPRO ("default-truncate-lines",
5548 &buffer_defaults
.truncate_lines
,
5549 doc
: /* Default value of `truncate-lines' for buffers that do not override it.
5550 This is the same as (default-value 'truncate-lines). */);
5552 DEFVAR_LISP_NOPRO ("default-fill-column",
5553 &buffer_defaults
.fill_column
,
5554 doc
: /* Default value of `fill-column' for buffers that do not override it.
5555 This is the same as (default-value 'fill-column). */);
5557 DEFVAR_LISP_NOPRO ("default-left-margin",
5558 &buffer_defaults
.left_margin
,
5559 doc
: /* Default value of `left-margin' for buffers that do not override it.
5560 This is the same as (default-value 'left-margin). */);
5562 DEFVAR_LISP_NOPRO ("default-tab-width",
5563 &buffer_defaults
.tab_width
,
5564 doc
: /* Default value of `tab-width' for buffers that do not override it.
5565 This is the same as (default-value 'tab-width). */);
5567 DEFVAR_LISP_NOPRO ("default-case-fold-search",
5568 &buffer_defaults
.case_fold_search
,
5569 doc
: /* Default value of `case-fold-search' for buffers that don't override it.
5570 This is the same as (default-value 'case-fold-search). */);
5573 DEFVAR_LISP_NOPRO ("default-buffer-file-type",
5574 &buffer_defaults
.buffer_file_type
,
5575 doc
: /* Default file type for buffers that do not override it.
5576 This is the same as (default-value 'buffer-file-type).
5577 The file type is nil for text, t for binary. */);
5580 DEFVAR_LISP_NOPRO ("default-left-margin-width",
5581 &buffer_defaults
.left_margin_cols
,
5582 doc
: /* Default value of `left-margin-width' for buffers that don't override it.
5583 This is the same as (default-value 'left-margin-width). */);
5585 DEFVAR_LISP_NOPRO ("default-right-margin-width",
5586 &buffer_defaults
.right_margin_cols
,
5587 doc
: /* Default value of `right-margin-width' for buffers that don't override it.
5588 This is the same as (default-value 'right-margin-width). */);
5590 DEFVAR_LISP_NOPRO ("default-left-fringe-width",
5591 &buffer_defaults
.left_fringe_width
,
5592 doc
: /* Default value of `left-fringe-width' for buffers that don't override it.
5593 This is the same as (default-value 'left-fringe-width). */);
5595 DEFVAR_LISP_NOPRO ("default-right-fringe-width",
5596 &buffer_defaults
.right_fringe_width
,
5597 doc
: /* Default value of `right-fringe-width' for buffers that don't override it.
5598 This is the same as (default-value 'right-fringe-width). */);
5600 DEFVAR_LISP_NOPRO ("default-fringes-outside-margins",
5601 &buffer_defaults
.fringes_outside_margins
,
5602 doc
: /* Default value of `fringes-outside-margins' for buffers that don't override it.
5603 This is the same as (default-value 'fringes-outside-margins). */);
5605 DEFVAR_LISP_NOPRO ("default-scroll-bar-width",
5606 &buffer_defaults
.scroll_bar_width
,
5607 doc
: /* Default value of `scroll-bar-width' for buffers that don't override it.
5608 This is the same as (default-value 'scroll-bar-width). */);
5610 DEFVAR_LISP_NOPRO ("default-vertical-scroll-bar",
5611 &buffer_defaults
.vertical_scroll_bar_type
,
5612 doc
: /* Default value of `vertical-scroll-bar' for buffers that don't override it.
5613 This is the same as (default-value 'vertical-scroll-bar). */);
5615 DEFVAR_LISP_NOPRO ("default-indicate-empty-lines",
5616 &buffer_defaults
.indicate_empty_lines
,
5617 doc
: /* Default value of `indicate-empty-lines' for buffers that don't override it.
5618 This is the same as (default-value 'indicate-empty-lines). */);
5620 DEFVAR_LISP_NOPRO ("default-indicate-buffer-boundaries",
5621 &buffer_defaults
.indicate_buffer_boundaries
,
5622 doc
: /* Default value of `indicate-buffer-boundaries' for buffers that don't override it.
5623 This is the same as (default-value 'indicate-buffer-boundaries). */);
5625 DEFVAR_LISP_NOPRO ("default-fringe-indicator-alist",
5626 &buffer_defaults
.fringe_indicator_alist
,
5627 doc
: /* Default value of `fringe-indicator-alist' for buffers that don't override it.
5628 This is the same as (default-value 'fringe-indicator-alist'). */);
5630 DEFVAR_LISP_NOPRO ("default-fringe-cursor-alist",
5631 &buffer_defaults
.fringe_cursor_alist
,
5632 doc
: /* Default value of `fringe-cursor-alist' for buffers that don't override it.
5633 This is the same as (default-value 'fringe-cursor-alist'). */);
5635 DEFVAR_LISP_NOPRO ("default-scroll-up-aggressively",
5636 &buffer_defaults
.scroll_up_aggressively
,
5637 doc
: /* Default value of `scroll-up-aggressively'.
5638 This value applies in buffers that don't have their own local values.
5639 This is the same as (default-value 'scroll-up-aggressively). */);
5641 DEFVAR_LISP_NOPRO ("default-scroll-down-aggressively",
5642 &buffer_defaults
.scroll_down_aggressively
,
5643 doc
: /* Default value of `scroll-down-aggressively'.
5644 This value applies in buffers that don't have their own local values.
5645 This is the same as (default-value 'scroll-down-aggressively). */);
5647 DEFVAR_PER_BUFFER ("header-line-format",
5648 ¤t_buffer
->header_line_format
,
5650 doc
: /* Analogous to `mode-line-format', but controls the header line.
5651 The header line appears, optionally, at the top of a window;
5652 the mode line appears at the bottom. */);
5654 DEFVAR_PER_BUFFER ("mode-line-format", ¤t_buffer
->mode_line_format
,
5656 doc
: /* Template for displaying mode line for current buffer.
5657 Each buffer has its own value of this variable.
5658 Value may be nil, a string, a symbol or a list or cons cell.
5659 A value of nil means don't display a mode line.
5660 For a symbol, its value is used (but it is ignored if t or nil).
5661 A string appearing directly as the value of a symbol is processed verbatim
5662 in that the %-constructs below are not recognized.
5663 Note that unless the symbol is marked as a `risky-local-variable', all
5664 properties in any strings, as well as all :eval and :propertize forms
5665 in the value of that symbol will be ignored.
5666 For a list of the form `(:eval FORM)', FORM is evaluated and the result
5667 is used as a mode line element. Be careful--FORM should not load any files,
5668 because that can cause an infinite recursion.
5669 For a list of the form `(:propertize ELT PROPS...)', ELT is displayed
5670 with the specified properties PROPS applied.
5671 For a list whose car is a symbol, the symbol's value is taken,
5672 and if that is non-nil, the cadr of the list is processed recursively.
5673 Otherwise, the caddr of the list (if there is one) is processed.
5674 For a list whose car is a string or list, each element is processed
5675 recursively and the results are effectively concatenated.
5676 For a list whose car is an integer, the cdr of the list is processed
5677 and padded (if the number is positive) or truncated (if negative)
5678 to the width specified by that number.
5679 A string is printed verbatim in the mode line except for %-constructs:
5680 (%-constructs are allowed when the string is the entire mode-line-format
5681 or when it is found in a cons-cell or a list)
5682 %b -- print buffer name. %f -- print visited file name.
5683 %F -- print frame name.
5684 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
5685 %& is like %*, but ignore read-only-ness.
5686 % means buffer is read-only and * means it is modified.
5687 For a modified read-only buffer, %* gives % and %+ gives *.
5688 %s -- print process status. %l -- print the current line number.
5689 %c -- print the current column number (this makes editing slower).
5690 To make the column number update correctly in all cases,
5691 `column-number-mode' must be non-nil.
5692 %i -- print the size of the buffer.
5693 %I -- like %i, but use k, M, G, etc., to abbreviate.
5694 %p -- print percent of buffer above top of window, or Top, Bot or All.
5695 %P -- print percent of buffer above bottom of window, perhaps plus Top,
5696 or print Bottom or All.
5697 %n -- print Narrow if appropriate.
5698 %t -- visited file is text or binary (if OS supports this distinction).
5699 %z -- print mnemonics of keyboard, terminal, and buffer coding systems.
5700 %Z -- like %z, but including the end-of-line format.
5701 %e -- print error message about full memory.
5702 %@ -- print @ or hyphen. @ means that default-directory is on a
5704 %[ -- print one [ for each recursive editing level. %] similar.
5705 %% -- print %. %- -- print infinitely many dashes.
5706 Decimal digits after the % specify field width to which to pad. */);
5708 DEFVAR_LISP_NOPRO ("default-major-mode", &buffer_defaults
.major_mode
,
5709 doc
: /* *Value of `major-mode' for new buffers. */);
5711 DEFVAR_PER_BUFFER ("major-mode", ¤t_buffer
->major_mode
,
5712 make_number (Lisp_Symbol
),
5713 doc
: /* Symbol for current buffer's major mode.
5714 The default value (normally `fundamental-mode') affects new buffers.
5715 A value of nil means to use the current buffer's major mode, provided
5716 it is not marked as "special".
5718 When a mode is used by default, `find-file' switches to it before it
5719 reads the contents into the buffer and before it finishes setting up
5720 the buffer. Thus, the mode and its hooks should not expect certain
5721 variables such as `buffer-read-only' and `buffer-file-coding-system'
5724 DEFVAR_PER_BUFFER ("mode-name", ¤t_buffer
->mode_name
,
5726 doc
: /* Pretty name of current buffer's major mode.
5727 Usually a string, but can use any of the constructs for `mode-line-format',
5729 Format with `format-mode-line' to produce a string value. */);
5731 DEFVAR_PER_BUFFER ("local-abbrev-table", ¤t_buffer
->abbrev_table
, Qnil
,
5732 doc
: /* Local (mode-specific) abbrev table of current buffer. */);
5734 DEFVAR_PER_BUFFER ("abbrev-mode", ¤t_buffer
->abbrev_mode
, Qnil
,
5735 doc
: /* Non-nil turns on automatic expansion of abbrevs as they are inserted. */);
5737 DEFVAR_PER_BUFFER ("case-fold-search", ¤t_buffer
->case_fold_search
,
5739 doc
: /* *Non-nil if searches and matches should ignore case. */);
5741 DEFVAR_PER_BUFFER ("fill-column", ¤t_buffer
->fill_column
,
5742 make_number (LISP_INT_TAG
),
5743 doc
: /* *Column beyond which automatic line-wrapping should happen.
5744 Interactively, you can set the buffer local value using \\[set-fill-column]. */);
5746 DEFVAR_PER_BUFFER ("left-margin", ¤t_buffer
->left_margin
,
5747 make_number (LISP_INT_TAG
),
5748 doc
: /* *Column for the default `indent-line-function' to indent to.
5749 Linefeed indents to this column in Fundamental mode. */);
5751 DEFVAR_PER_BUFFER ("tab-width", ¤t_buffer
->tab_width
,
5752 make_number (LISP_INT_TAG
),
5753 doc
: /* *Distance between tab stops (for display of tab characters), in columns. */);
5755 DEFVAR_PER_BUFFER ("ctl-arrow", ¤t_buffer
->ctl_arrow
, Qnil
,
5756 doc
: /* *Non-nil means display control chars with uparrow.
5757 A value of nil means use backslash and octal digits.
5758 This variable does not apply to characters whose display is specified
5759 in the current display table (if there is one). */);
5761 DEFVAR_PER_BUFFER ("enable-multibyte-characters",
5762 ¤t_buffer
->enable_multibyte_characters
,
5764 doc
: /* Non-nil means the buffer contents are regarded as multi-byte characters.
5765 Otherwise they are regarded as unibyte. This affects the display,
5766 file I/O and the behavior of various editing commands.
5768 This variable is buffer-local but you cannot set it directly;
5769 use the function `set-buffer-multibyte' to change a buffer's representation.
5770 Changing its default value with `setq-default' is supported.
5771 See also variable `default-enable-multibyte-characters' and Info node
5772 `(elisp)Text Representations'. */);
5773 XSYMBOL (intern_c_string ("enable-multibyte-characters"))->constant
= 1;
5775 DEFVAR_PER_BUFFER ("buffer-file-coding-system",
5776 ¤t_buffer
->buffer_file_coding_system
, Qnil
,
5777 doc
: /* Coding system to be used for encoding the buffer contents on saving.
5778 This variable applies to saving the buffer, and also to `write-region'
5779 and other functions that use `write-region'.
5780 It does not apply to sending output to subprocesses, however.
5782 If this is nil, the buffer is saved without any code conversion
5783 unless some coding system is specified in `file-coding-system-alist'
5784 for the buffer file.
5786 If the text to be saved cannot be encoded as specified by this variable,
5787 an alternative encoding is selected by `select-safe-coding-system', which see.
5789 The variable `coding-system-for-write', if non-nil, overrides this variable.
5791 This variable is never applied to a way of decoding a file while reading it. */);
5793 DEFVAR_PER_BUFFER ("direction-reversed",
5794 ¤t_buffer
->direction_reversed
, Qnil
,
5795 doc
: /* Non-nil means set beginning of lines at the right edge of the window.
5796 See also the variable `bidi-display-reordering'. */);
5798 DEFVAR_PER_BUFFER ("bidi-display-reordering",
5799 ¤t_buffer
->bidi_display_reordering
, Qnil
,
5800 doc
: /* Non-nil means reorder bidirectional text for display in the visual order.
5801 See also the variable `direction-reversed'. */);
5803 DEFVAR_PER_BUFFER ("bidi-paragraph-direction",
5804 ¤t_buffer
->bidi_paragraph_direction
, Qnil
,
5805 doc
: /* *If non-nil, forces directionality of text paragraphs in the buffer.
5807 If this is nil (the default), the direction of each paragraph is
5808 determined by the first strong directional character of its text.
5809 The values of `right-to-left' and `left-to-right' override that.
5810 Any other value is treated as nil.
5812 This variable has no effect unless the buffer's value of
5813 \`bidi-display-reordering' is non-nil. */);
5815 DEFVAR_PER_BUFFER ("truncate-lines", ¤t_buffer
->truncate_lines
, Qnil
,
5816 doc
: /* *Non-nil means do not display continuation lines.
5817 Instead, give each line of text just one screen line.
5819 Note that this is overridden by the variable
5820 `truncate-partial-width-windows' if that variable is non-nil
5821 and this buffer is not full-frame width. */);
5823 DEFVAR_PER_BUFFER ("word-wrap", ¤t_buffer
->word_wrap
, Qnil
,
5824 doc
: /* *Non-nil means to use word-wrapping for continuation lines.
5825 When word-wrapping is on, continuation lines are wrapped at the space
5826 or tab character nearest to the right window edge.
5827 If nil, continuation lines are wrapped at the right screen edge.
5829 This variable has no effect if long lines are truncated (see
5830 `truncate-lines' and `truncate-partial-width-windows'). If you use
5831 word-wrapping, you might want to reduce the value of
5832 `truncate-partial-width-windows', since wrapping can make text readable
5833 in narrower windows. */);
5836 DEFVAR_PER_BUFFER ("buffer-file-type", ¤t_buffer
->buffer_file_type
,
5838 doc
: /* Non-nil if the visited file is a binary file.
5839 This variable is meaningful on MS-DOG and Windows NT.
5840 On those systems, it is automatically local in every buffer.
5841 On other systems, this variable is normally always nil. */);
5844 DEFVAR_PER_BUFFER ("default-directory", ¤t_buffer
->directory
,
5845 make_number (Lisp_String
),
5846 doc
: /* Name of default directory of current buffer. Should end with slash.
5847 To interactively change the default directory, use command `cd'. */);
5849 DEFVAR_PER_BUFFER ("auto-fill-function", ¤t_buffer
->auto_fill_function
,
5851 doc
: /* Function called (if non-nil) to perform auto-fill.
5852 It is called after self-inserting any character specified in
5853 the `auto-fill-chars' table.
5854 NOTE: This variable is not a hook;
5855 its value may not be a list of functions. */);
5857 DEFVAR_PER_BUFFER ("buffer-file-name", ¤t_buffer
->filename
,
5858 make_number (Lisp_String
),
5859 doc
: /* Name of file visited in current buffer, or nil if not visiting a file. */);
5861 DEFVAR_PER_BUFFER ("buffer-file-truename", ¤t_buffer
->file_truename
,
5862 make_number (Lisp_String
),
5863 doc
: /* Abbreviated truename of file visited in current buffer, or nil if none.
5864 The truename of a file is calculated by `file-truename'
5865 and then abbreviated with `abbreviate-file-name'. */);
5867 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
5868 ¤t_buffer
->auto_save_file_name
,
5869 make_number (Lisp_String
),
5870 doc
: /* Name of file for auto-saving current buffer.
5871 If it is nil, that means don't auto-save this buffer. */);
5873 DEFVAR_PER_BUFFER ("buffer-read-only", ¤t_buffer
->read_only
, Qnil
,
5874 doc
: /* Non-nil if this buffer is read-only. */);
5876 DEFVAR_PER_BUFFER ("buffer-backed-up", ¤t_buffer
->backed_up
, Qnil
,
5877 doc
: /* Non-nil if this buffer's file has been backed up.
5878 Backing up is done before the first time the file is saved. */);
5880 DEFVAR_PER_BUFFER ("buffer-saved-size", ¤t_buffer
->save_length
,
5881 make_number (LISP_INT_TAG
),
5882 doc
: /* Length of current buffer when last read in, saved or auto-saved.
5884 -1 means auto-saving turned off until next real save.
5886 If you set this to -2, that means don't turn off auto-saving in this buffer
5887 if its text size shrinks. If you use `buffer-swap-text' on a buffer,
5888 you probably should set this to -2 in that buffer. */);
5890 DEFVAR_PER_BUFFER ("selective-display", ¤t_buffer
->selective_display
,
5892 doc
: /* Non-nil enables selective display.
5893 An integer N as value means display only lines
5894 that start with less than N columns of space.
5895 A value of t means that the character ^M makes itself and
5896 all the rest of the line invisible; also, when saving the buffer
5897 in a file, save the ^M as a newline. */);
5900 DEFVAR_PER_BUFFER ("selective-display-ellipses",
5901 ¤t_buffer
->selective_display_ellipses
,
5903 doc
: /* Non-nil means display ... on previous line when a line is invisible. */);
5906 DEFVAR_PER_BUFFER ("overwrite-mode", ¤t_buffer
->overwrite_mode
, Qnil
,
5907 doc
: /* Non-nil if self-insertion should replace existing text.
5908 The value should be one of `overwrite-mode-textual',
5909 `overwrite-mode-binary', or nil.
5910 If it is `overwrite-mode-textual', self-insertion still
5911 inserts at the end of a line, and inserts when point is before a tab,
5912 until the tab is filled in.
5913 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too. */);
5915 DEFVAR_PER_BUFFER ("buffer-display-table", ¤t_buffer
->display_table
,
5917 doc
: /* Display table that controls display of the contents of current buffer.
5919 If this variable is nil, the value of `standard-display-table' is used.
5920 Each window can have its own, overriding display table, see
5921 `set-window-display-table' and `window-display-table'.
5923 The display table is a char-table created with `make-display-table'.
5924 A char-table is an array indexed by character codes. Normal array
5925 primitives `aref' and `aset' can be used to access elements of a char-table.
5927 Each of the char-table elements control how to display the corresponding
5928 text character: the element at index C in the table says how to display
5929 the character whose code is C. Each element should be a vector of
5930 characters or nil. The value nil means display the character in the
5931 default fashion; otherwise, the characters from the vector are delivered
5932 to the screen instead of the original character.
5934 For example, (aset buffer-display-table ?X [?Y]) tells Emacs
5935 to display a capital Y instead of each X character.
5937 In addition, a char-table has six extra slots to control the display of:
5939 the end of a truncated screen line (extra-slot 0, a single character);
5940 the end of a continued line (extra-slot 1, a single character);
5941 the escape character used to display character codes in octal
5942 (extra-slot 2, a single character);
5943 the character used as an arrow for control characters (extra-slot 3,
5944 a single character);
5945 the decoration indicating the presence of invisible lines (extra-slot 4,
5946 a vector of characters);
5947 the character used to draw the border between side-by-side windows
5948 (extra-slot 5, a single character).
5950 See also the functions `display-table-slot' and `set-display-table-slot'. */);
5952 DEFVAR_PER_BUFFER ("left-margin-width", ¤t_buffer
->left_margin_cols
,
5954 doc
: /* *Width of left marginal area for display of a buffer.
5955 A value of nil means no marginal area. */);
5957 DEFVAR_PER_BUFFER ("right-margin-width", ¤t_buffer
->right_margin_cols
,
5959 doc
: /* *Width of right marginal area for display of a buffer.
5960 A value of nil means no marginal area. */);
5962 DEFVAR_PER_BUFFER ("left-fringe-width", ¤t_buffer
->left_fringe_width
,
5964 doc
: /* *Width of this buffer's left fringe (in pixels).
5965 A value of 0 means no left fringe is shown in this buffer's window.
5966 A value of nil means to use the left fringe width from the window's frame. */);
5968 DEFVAR_PER_BUFFER ("right-fringe-width", ¤t_buffer
->right_fringe_width
,
5970 doc
: /* *Width of this buffer's right fringe (in pixels).
5971 A value of 0 means no right fringe is shown in this buffer's window.
5972 A value of nil means to use the right fringe width from the window's frame. */);
5974 DEFVAR_PER_BUFFER ("fringes-outside-margins", ¤t_buffer
->fringes_outside_margins
,
5976 doc
: /* *Non-nil means to display fringes outside display margins.
5977 A value of nil means to display fringes between margins and buffer text. */);
5979 DEFVAR_PER_BUFFER ("scroll-bar-width", ¤t_buffer
->scroll_bar_width
,
5981 doc
: /* *Width of this buffer's scroll bars in pixels.
5982 A value of nil means to use the scroll bar width from the window's frame. */);
5984 DEFVAR_PER_BUFFER ("vertical-scroll-bar", ¤t_buffer
->vertical_scroll_bar_type
,
5986 doc
: /* *Position of this buffer's vertical scroll bar.
5987 The value takes effect whenever you tell a window to display this buffer;
5988 for instance, with `set-window-buffer' or when `display-buffer' displays it.
5990 A value of `left' or `right' means put the vertical scroll bar at that side
5991 of the window; a value of nil means don't show any vertical scroll bars.
5992 A value of t (the default) means do whatever the window's frame specifies. */);
5994 DEFVAR_PER_BUFFER ("indicate-empty-lines",
5995 ¤t_buffer
->indicate_empty_lines
, Qnil
,
5996 doc
: /* *Visually indicate empty lines after the buffer end.
5997 If non-nil, a bitmap is displayed in the left fringe of a window on
5998 window-systems. */);
6000 DEFVAR_PER_BUFFER ("indicate-buffer-boundaries",
6001 ¤t_buffer
->indicate_buffer_boundaries
, Qnil
,
6002 doc
: /* *Visually indicate buffer boundaries and scrolling.
6003 If non-nil, the first and last line of the buffer are marked in the fringe
6004 of a window on window-systems with angle bitmaps, or if the window can be
6005 scrolled, the top and bottom line of the window are marked with up and down
6008 If value is a symbol `left' or `right', both angle and arrow bitmaps
6009 are displayed in the left or right fringe, resp. Any other value
6010 that doesn't look like an alist means display the angle bitmaps in
6011 the left fringe but no arrows.
6013 You can exercise more precise control by using an alist as the
6014 value. Each alist element (INDICATOR . POSITION) specifies
6015 where to show one of the indicators. INDICATOR is one of `top',
6016 `bottom', `up', `down', or t, which specifies the default position,
6017 and POSITION is one of `left', `right', or nil, meaning do not show
6020 For example, ((top . left) (t . right)) places the top angle bitmap in
6021 left fringe, the bottom angle bitmap in right fringe, and both arrow
6022 bitmaps in right fringe. To show just the angle bitmaps in the left
6023 fringe, but no arrow bitmaps, use ((top . left) (bottom . left)). */);
6025 DEFVAR_PER_BUFFER ("fringe-indicator-alist",
6026 ¤t_buffer
->fringe_indicator_alist
, Qnil
,
6027 doc
: /* *Mapping from logical to physical fringe indicator bitmaps.
6028 The value is an alist where each element (INDICATOR . BITMAPS)
6029 specifies the fringe bitmaps used to display a specific logical
6032 INDICATOR specifies the logical indicator type which is one of the
6033 following symbols: `truncation' , `continuation', `overlay-arrow',
6034 `top', `bottom', `up', `down', `one-line', `empty-line', or `unknown'.
6036 BITMAPS is list of symbols (LEFT RIGHT [LEFT1 RIGHT1]) which specifies
6037 the actual bitmap shown in the left or right fringe for the logical
6038 indicator. LEFT and RIGHT are the bitmaps shown in the left and/or
6039 right fringe for the specific indicator. The LEFT1 or RIGHT1 bitmaps
6040 are used only for the `bottom' and `one-line' indicators when the last
6041 \(only) line in has no final newline. BITMAPS may also be a single
6042 symbol which is used in both left and right fringes. */);
6044 DEFVAR_PER_BUFFER ("fringe-cursor-alist",
6045 ¤t_buffer
->fringe_cursor_alist
, Qnil
,
6046 doc
: /* *Mapping from logical to physical fringe cursor bitmaps.
6047 The value is an alist where each element (CURSOR . BITMAP)
6048 specifies the fringe bitmaps used to display a specific logical
6049 cursor type in the fringe.
6051 CURSOR specifies the logical cursor type which is one of the following
6052 symbols: `box' , `hollow', `bar', `hbar', or `hollow-small'. The last
6053 one is used to show a hollow cursor on narrow lines display lines
6054 where the normal hollow cursor will not fit.
6056 BITMAP is the corresponding fringe bitmap shown for the logical
6059 DEFVAR_PER_BUFFER ("scroll-up-aggressively",
6060 ¤t_buffer
->scroll_up_aggressively
, Qnil
,
6061 doc
: /* How far to scroll windows upward.
6062 If you move point off the bottom, the window scrolls automatically.
6063 This variable controls how far it scrolls. The value nil, the default,
6064 means scroll to center point. A fraction means scroll to put point
6065 that fraction of the window's height from the bottom of the window.
6066 When the value is 0.0, point goes at the bottom line, which in the
6067 simple case that you moved off with C-f means scrolling just one line.
6068 1.0 means point goes at the top, so that in that simple case, the
6069 window scrolls by a full window height. Meaningful values are
6070 between 0.0 and 1.0, inclusive. */);
6072 DEFVAR_PER_BUFFER ("scroll-down-aggressively",
6073 ¤t_buffer
->scroll_down_aggressively
, Qnil
,
6074 doc
: /* How far to scroll windows downward.
6075 If you move point off the top, the window scrolls automatically.
6076 This variable controls how far it scrolls. The value nil, the default,
6077 means scroll to center point. A fraction means scroll to put point
6078 that fraction of the window's height from the top of the window.
6079 When the value is 0.0, point goes at the top line, which in the
6080 simple case that you moved off with C-b means scrolling just one line.
6081 1.0 means point goes at the bottom, so that in that simple case, the
6082 window scrolls by a full window height. Meaningful values are
6083 between 0.0 and 1.0, inclusive. */);
6085 /*DEFVAR_LISP ("debug-check-symbol", &Vcheck_symbol,
6089 DEFVAR_LISP ("before-change-functions", &Vbefore_change_functions
,
6090 doc
: /* List of functions to call before each text change.
6091 Two arguments are passed to each function: the positions of
6092 the beginning and end of the range of old text to be changed.
6093 \(For an insertion, the beginning and end are at the same place.)
6094 No information is given about the length of the text after the change.
6096 Buffer changes made while executing the `before-change-functions'
6097 don't call any before-change or after-change functions.
6098 That's because these variables are temporarily set to nil.
6099 As a result, a hook function cannot straightforwardly alter the
6100 value of these variables. See the Emacs Lisp manual for a way of
6101 accomplishing an equivalent result by using other variables.
6103 If an unhandled error happens in running these functions,
6104 the variable's value remains nil. That prevents the error
6105 from happening repeatedly and making Emacs nonfunctional. */);
6106 Vbefore_change_functions
= Qnil
;
6108 DEFVAR_LISP ("after-change-functions", &Vafter_change_functions
,
6109 doc
: /* List of functions to call after each text change.
6110 Three arguments are passed to each function: the positions of
6111 the beginning and end of the range of changed text,
6112 and the length in bytes of the pre-change text replaced by that range.
6113 \(For an insertion, the pre-change length is zero;
6114 for a deletion, that length is the number of bytes deleted,
6115 and the post-change beginning and end are at the same place.)
6117 Buffer changes made while executing the `after-change-functions'
6118 don't call any before-change or after-change functions.
6119 That's because these variables are temporarily set to nil.
6120 As a result, a hook function cannot straightforwardly alter the
6121 value of these variables. See the Emacs Lisp manual for a way of
6122 accomplishing an equivalent result by using other variables.
6124 If an unhandled error happens in running these functions,
6125 the variable's value remains nil. That prevents the error
6126 from happening repeatedly and making Emacs nonfunctional. */);
6127 Vafter_change_functions
= Qnil
;
6129 DEFVAR_LISP ("first-change-hook", &Vfirst_change_hook
,
6130 doc
: /* A list of functions to call before changing a buffer which is unmodified.
6131 The functions are run using the `run-hooks' function. */);
6132 Vfirst_change_hook
= Qnil
;
6134 DEFVAR_PER_BUFFER ("buffer-undo-list", ¤t_buffer
->undo_list
, Qnil
,
6135 doc
: /* List of undo entries in current buffer.
6136 Recent changes come first; older changes follow newer.
6138 An entry (BEG . END) represents an insertion which begins at
6139 position BEG and ends at position END.
6141 An entry (TEXT . POSITION) represents the deletion of the string TEXT
6142 from (abs POSITION). If POSITION is positive, point was at the front
6143 of the text being deleted; if negative, point was at the end.
6145 An entry (t HIGH . LOW) indicates that the buffer previously had
6146 \"unmodified\" status. HIGH and LOW are the high and low 16-bit portions
6147 of the visited file's modification time, as of that time. If the
6148 modification time of the most recent save is different, this entry is
6151 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
6152 was modified between BEG and END. PROPERTY is the property name,
6153 and VALUE is the old value.
6155 An entry (apply FUN-NAME . ARGS) means undo the change with
6156 \(apply FUN-NAME ARGS).
6158 An entry (apply DELTA BEG END FUN-NAME . ARGS) supports selective undo
6159 in the active region. BEG and END is the range affected by this entry
6160 and DELTA is the number of bytes added or deleted in that range by
6163 An entry (MARKER . DISTANCE) indicates that the marker MARKER
6164 was adjusted in position by the offset DISTANCE (an integer).
6166 An entry of the form POSITION indicates that point was at the buffer
6167 location given by the integer. Undoing an entry of this form places
6170 Entries with value `nil' mark undo boundaries. The undo command treats
6171 the changes between two undo boundaries as a single step to be undone.
6173 If the value of the variable is t, undo information is not recorded. */);
6175 DEFVAR_PER_BUFFER ("mark-active", ¤t_buffer
->mark_active
, Qnil
,
6176 doc
: /* Non-nil means the mark and region are currently active in this buffer. */);
6178 DEFVAR_PER_BUFFER ("cache-long-line-scans", ¤t_buffer
->cache_long_line_scans
, Qnil
,
6179 doc
: /* Non-nil means that Emacs should use caches to handle long lines more quickly.
6181 Normally, the line-motion functions work by scanning the buffer for
6182 newlines. Columnar operations (like `move-to-column' and
6183 `compute-motion') also work by scanning the buffer, summing character
6184 widths as they go. This works well for ordinary text, but if the
6185 buffer's lines are very long (say, more than 500 characters), these
6186 motion functions will take longer to execute. Emacs may also take
6187 longer to update the display.
6189 If `cache-long-line-scans' is non-nil, these motion functions cache the
6190 results of their scans, and consult the cache to avoid rescanning
6191 regions of the buffer until the text is modified. The caches are most
6192 beneficial when they prevent the most searching---that is, when the
6193 buffer contains long lines and large regions of characters with the
6194 same, fixed screen width.
6196 When `cache-long-line-scans' is non-nil, processing short lines will
6197 become slightly slower (because of the overhead of consulting the
6198 cache), and the caches will use memory roughly proportional to the
6199 number of newlines and characters whose screen width varies.
6201 The caches require no explicit maintenance; their accuracy is
6202 maintained internally by the Emacs primitives. Enabling or disabling
6203 the cache should not affect the behavior of any of the motion
6204 functions; it should only affect their performance. */);
6206 DEFVAR_PER_BUFFER ("point-before-scroll", ¤t_buffer
->point_before_scroll
, Qnil
,
6207 doc
: /* Value of point before the last series of scroll operations, or nil. */);
6209 DEFVAR_PER_BUFFER ("buffer-file-format", ¤t_buffer
->file_format
, Qnil
,
6210 doc
: /* List of formats to use when saving this buffer.
6211 Formats are defined by `format-alist'. This variable is
6212 set when a file is visited. */);
6214 DEFVAR_PER_BUFFER ("buffer-auto-save-file-format",
6215 ¤t_buffer
->auto_save_file_format
, Qnil
,
6216 doc
: /* *Format in which to write auto-save files.
6217 Should be a list of symbols naming formats that are defined in `format-alist'.
6218 If it is t, which is the default, auto-save files are written in the
6219 same format as a regular save would use. */);
6221 DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
6222 ¤t_buffer
->invisibility_spec
, Qnil
,
6223 doc
: /* Invisibility spec of this buffer.
6224 The default is t, which means that text is invisible
6225 if it has a non-nil `invisible' property.
6226 If the value is a list, a text character is invisible if its `invisible'
6227 property is an element in that list (or is a list with members in common).
6228 If an element is a cons cell of the form (PROP . ELLIPSIS),
6229 then characters with property value PROP are invisible,
6230 and they have an ellipsis as well if ELLIPSIS is non-nil. */);
6232 DEFVAR_PER_BUFFER ("buffer-display-count",
6233 ¤t_buffer
->display_count
, Qnil
,
6234 doc
: /* A number incremented each time this buffer is displayed in a window.
6235 The function `set-window-buffer' increments it. */);
6237 DEFVAR_PER_BUFFER ("buffer-display-time",
6238 ¤t_buffer
->display_time
, Qnil
,
6239 doc
: /* Time stamp updated each time this buffer is displayed in a window.
6240 The function `set-window-buffer' updates this variable
6241 to the value obtained by calling `current-time'.
6242 If the buffer has never been shown in a window, the value is nil. */);
6244 DEFVAR_LISP ("transient-mark-mode", &Vtransient_mark_mode
,
6246 Vtransient_mark_mode
= Qnil
;
6247 /* The docstring is in simple.el. If we put it here, it would be
6248 overwritten when transient-mark-mode is defined using
6249 define-minor-mode. */
6251 DEFVAR_LISP ("inhibit-read-only", &Vinhibit_read_only
,
6252 doc
: /* *Non-nil means disregard read-only status of buffers or characters.
6253 If the value is t, disregard `buffer-read-only' and all `read-only'
6254 text properties. If the value is a list, disregard `buffer-read-only'
6255 and disregard a `read-only' text property if the property value
6256 is a member of the list. */);
6257 Vinhibit_read_only
= Qnil
;
6259 DEFVAR_PER_BUFFER ("cursor-type", ¤t_buffer
->cursor_type
, Qnil
,
6260 doc
: /* Cursor to use when this buffer is in the selected window.
6261 Values are interpreted as follows:
6263 t use the cursor specified for the frame
6264 nil don't display a cursor
6265 box display a filled box cursor
6266 hollow display a hollow box cursor
6267 bar display a vertical bar cursor with default width
6268 (bar . WIDTH) display a vertical bar cursor with width WIDTH
6269 hbar display a horizontal bar cursor with default height
6270 (hbar . HEIGHT) display a horizontal bar cursor with height HEIGHT
6271 ANYTHING ELSE display a hollow box cursor
6273 When the buffer is displayed in a non-selected window, the
6274 cursor's appearance is instead controlled by the variable
6275 `cursor-in-non-selected-windows'. */);
6277 DEFVAR_PER_BUFFER ("line-spacing",
6278 ¤t_buffer
->extra_line_spacing
, Qnil
,
6279 doc
: /* Additional space to put between lines when displaying a buffer.
6280 The space is measured in pixels, and put below lines on graphic displays,
6281 see `display-graphic-p'.
6282 If value is a floating point number, it specifies the spacing relative
6283 to the default frame line height. A value of nil means add no extra space. */);
6285 DEFVAR_PER_BUFFER ("cursor-in-non-selected-windows",
6286 ¤t_buffer
->cursor_in_non_selected_windows
, Qnil
,
6287 doc
: /* *Cursor type to display in non-selected windows.
6288 The value t means to use hollow box cursor. See `cursor-type' for other values. */);
6290 DEFVAR_LISP ("kill-buffer-query-functions", &Vkill_buffer_query_functions
,
6291 doc
: /* List of functions called with no args to query before killing a buffer.
6292 The buffer being killed will be current while the functions are running.
6293 If any of them returns nil, the buffer is not killed. */);
6294 Vkill_buffer_query_functions
= Qnil
;
6296 DEFVAR_LISP ("change-major-mode-hook", &Vchange_major_mode_hook
,
6297 doc
: /* Normal hook run before changing the major mode of a buffer.
6298 The function `kill-all-local-variables' runs this before doing anything else. */);
6299 Vchange_major_mode_hook
= Qnil
;
6300 Qchange_major_mode_hook
= intern_c_string ("change-major-mode-hook");
6301 staticpro (&Qchange_major_mode_hook
);
6303 defsubr (&Sbuffer_live_p
);
6304 defsubr (&Sbuffer_list
);
6305 defsubr (&Sget_buffer
);
6306 defsubr (&Sget_file_buffer
);
6307 defsubr (&Sget_buffer_create
);
6308 defsubr (&Smake_indirect_buffer
);
6309 defsubr (&Sgenerate_new_buffer_name
);
6310 defsubr (&Sbuffer_name
);
6311 /*defsubr (&Sbuffer_number);*/
6312 defsubr (&Sbuffer_file_name
);
6313 defsubr (&Sbuffer_base_buffer
);
6314 defsubr (&Sbuffer_local_value
);
6315 defsubr (&Sbuffer_local_variables
);
6316 defsubr (&Sbuffer_modified_p
);
6317 defsubr (&Sset_buffer_modified_p
);
6318 defsubr (&Sbuffer_modified_tick
);
6319 defsubr (&Sbuffer_chars_modified_tick
);
6320 defsubr (&Srename_buffer
);
6321 defsubr (&Sother_buffer
);
6322 defsubr (&Sbuffer_enable_undo
);
6323 defsubr (&Skill_buffer
);
6324 defsubr (&Sset_buffer_major_mode
);
6325 defsubr (&Sswitch_to_buffer
);
6326 defsubr (&Scurrent_buffer
);
6327 defsubr (&Sset_buffer
);
6328 defsubr (&Sbarf_if_buffer_read_only
);
6329 defsubr (&Sbury_buffer
);
6330 defsubr (&Serase_buffer
);
6331 defsubr (&Sbuffer_swap_text
);
6332 defsubr (&Sset_buffer_multibyte
);
6333 defsubr (&Skill_all_local_variables
);
6335 defsubr (&Soverlayp
);
6336 defsubr (&Smake_overlay
);
6337 defsubr (&Sdelete_overlay
);
6338 defsubr (&Smove_overlay
);
6339 defsubr (&Soverlay_start
);
6340 defsubr (&Soverlay_end
);
6341 defsubr (&Soverlay_buffer
);
6342 defsubr (&Soverlay_properties
);
6343 defsubr (&Soverlays_at
);
6344 defsubr (&Soverlays_in
);
6345 defsubr (&Snext_overlay_change
);
6346 defsubr (&Sprevious_overlay_change
);
6347 defsubr (&Soverlay_recenter
);
6348 defsubr (&Soverlay_lists
);
6349 defsubr (&Soverlay_get
);
6350 defsubr (&Soverlay_put
);
6351 defsubr (&Srestore_buffer_modified_p
);
6357 initial_define_key (control_x_map
, 'b', "switch-to-buffer");
6358 initial_define_key (control_x_map
, 'k', "kill-buffer");
6360 /* This must not be in syms_of_buffer, because Qdisabled is not
6361 initialized when that function gets called. */
6362 Fput (intern_c_string ("erase-buffer"), Qdisabled
, Qt
);
6365 /* arch-tag: e48569bf-69a9-4b65-a23b-8e68769436e1
6366 (do not change this comment) */