1 /* Buffer manipulation primitives for GNU Emacs.
3 Copyright (C) 1985-1989, 1993-1995, 1997-2013 Free Software Foundation,
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
23 #define BUFFER_INLINE EXTERN_INLINE
25 #include <sys/types.h>
27 #include <sys/param.h>
35 #include "intervals.h"
38 #include "character.h"
40 #include "region-cache.h"
42 #include "blockinput.h"
49 #endif /* HAVE_XWIDGETS */
51 struct buffer
*current_buffer
; /* The current buffer. */
53 /* First buffer in chain of all buffers (in reverse order of creation).
54 Threaded through ->header.next.buffer. */
56 struct buffer
*all_buffers
;
58 /* This structure holds the default values of the buffer-local variables
59 defined with DEFVAR_PER_BUFFER, that have special slots in each buffer.
60 The default value occupies the same slot in this structure
61 as an individual buffer's value occupies in that buffer.
62 Setting the default value also goes through the alist of buffers
63 and stores into each buffer that does not say it has a local value. */
65 struct buffer
alignas (GCALIGNMENT
) buffer_defaults
;
67 /* This structure marks which slots in a buffer have corresponding
68 default values in buffer_defaults.
69 Each such slot has a nonzero value in this structure.
70 The value has only one nonzero bit.
72 When a buffer has its own local value for a slot,
73 the entry for that slot (found in the same slot in this structure)
74 is turned on in the buffer's local_flags array.
76 If a slot in this structure is -1, then even though there may
77 be a DEFVAR_PER_BUFFER for the slot, there is no default value for it;
78 and the corresponding slot in buffer_defaults is not used.
80 If a slot in this structure corresponding to a DEFVAR_PER_BUFFER is
81 zero, that is a bug. */
83 struct buffer buffer_local_flags
;
85 /* This structure holds the names of symbols whose values may be
86 buffer-local. It is indexed and accessed in the same way as the above. */
88 struct buffer
alignas (GCALIGNMENT
) buffer_local_symbols
;
90 /* Return the symbol of the per-buffer variable at offset OFFSET in
91 the buffer structure. */
93 #define PER_BUFFER_SYMBOL(OFFSET) \
94 (*(Lisp_Object *)((OFFSET) + (char *) &buffer_local_symbols))
96 /* Maximum length of an overlay vector. */
97 #define OVERLAY_COUNT_MAX \
98 ((ptrdiff_t) min (MOST_POSITIVE_FIXNUM, \
99 min (PTRDIFF_MAX, SIZE_MAX) / word_size))
101 /* Flags indicating which built-in buffer-local variables
102 are permanent locals. */
103 static char buffer_permanent_local_flags
[MAX_PER_BUFFER_VARS
];
105 /* Number of per-buffer variables used. */
107 int last_per_buffer_idx
;
109 static void call_overlay_mod_hooks (Lisp_Object list
, Lisp_Object overlay
,
110 bool after
, Lisp_Object arg1
,
111 Lisp_Object arg2
, Lisp_Object arg3
);
112 static void swap_out_buffer_local_variables (struct buffer
*b
);
113 static void reset_buffer_local_variables (struct buffer
*, bool);
115 /* Alist of all buffer names vs the buffers. This used to be
116 a Lisp-visible variable, but is no longer, to prevent lossage
117 due to user rplac'ing this alist or its elements. */
118 Lisp_Object Vbuffer_alist
;
120 static Lisp_Object Qkill_buffer_query_functions
;
122 /* Hook run before changing a major mode. */
123 static Lisp_Object Qchange_major_mode_hook
;
125 Lisp_Object Qfirst_change_hook
;
126 Lisp_Object Qbefore_change_functions
;
127 Lisp_Object Qafter_change_functions
;
129 static Lisp_Object Qfundamental_mode
, Qmode_class
, Qpermanent_local
;
130 static Lisp_Object Qpermanent_local_hook
;
132 static Lisp_Object Qprotected_field
;
134 static Lisp_Object QSFundamental
; /* A string "Fundamental". */
136 static Lisp_Object Qkill_buffer_hook
;
137 static Lisp_Object Qbuffer_list_update_hook
;
139 static Lisp_Object Qget_file_buffer
;
141 static Lisp_Object Qoverlayp
;
143 Lisp_Object Qpriority
, Qbefore_string
, Qafter_string
;
145 static Lisp_Object Qevaporate
;
147 Lisp_Object Qmodification_hooks
;
148 Lisp_Object Qinsert_in_front_hooks
;
149 Lisp_Object Qinsert_behind_hooks
;
151 static void alloc_buffer_text (struct buffer
*, ptrdiff_t);
152 static void free_buffer_text (struct buffer
*b
);
153 static struct Lisp_Overlay
* copy_overlays (struct buffer
*, struct Lisp_Overlay
*);
154 static void modify_overlay (struct buffer
*, ptrdiff_t, ptrdiff_t);
155 static Lisp_Object
buffer_lisp_local_variables (struct buffer
*, bool);
158 CHECK_OVERLAY (Lisp_Object x
)
160 CHECK_TYPE (OVERLAYP (x
), Qoverlayp
, x
);
163 /* These setters are used only in this file, so they can be private. */
165 bset_abbrev_mode (struct buffer
*b
, Lisp_Object val
)
167 b
->INTERNAL_FIELD (abbrev_mode
) = val
;
170 bset_abbrev_table (struct buffer
*b
, Lisp_Object val
)
172 b
->INTERNAL_FIELD (abbrev_table
) = val
;
175 bset_auto_fill_function (struct buffer
*b
, Lisp_Object val
)
177 b
->INTERNAL_FIELD (auto_fill_function
) = val
;
180 bset_auto_save_file_format (struct buffer
*b
, Lisp_Object val
)
182 b
->INTERNAL_FIELD (auto_save_file_format
) = val
;
185 bset_auto_save_file_name (struct buffer
*b
, Lisp_Object val
)
187 b
->INTERNAL_FIELD (auto_save_file_name
) = val
;
190 bset_backed_up (struct buffer
*b
, Lisp_Object val
)
192 b
->INTERNAL_FIELD (backed_up
) = val
;
195 bset_begv_marker (struct buffer
*b
, Lisp_Object val
)
197 b
->INTERNAL_FIELD (begv_marker
) = val
;
200 bset_bidi_display_reordering (struct buffer
*b
, Lisp_Object val
)
202 b
->INTERNAL_FIELD (bidi_display_reordering
) = val
;
205 bset_buffer_file_coding_system (struct buffer
*b
, Lisp_Object val
)
207 b
->INTERNAL_FIELD (buffer_file_coding_system
) = val
;
210 bset_cache_long_scans (struct buffer
*b
, Lisp_Object val
)
212 b
->INTERNAL_FIELD (cache_long_scans
) = val
;
215 bset_case_fold_search (struct buffer
*b
, Lisp_Object val
)
217 b
->INTERNAL_FIELD (case_fold_search
) = val
;
220 bset_ctl_arrow (struct buffer
*b
, Lisp_Object val
)
222 b
->INTERNAL_FIELD (ctl_arrow
) = val
;
225 bset_cursor_in_non_selected_windows (struct buffer
*b
, Lisp_Object val
)
227 b
->INTERNAL_FIELD (cursor_in_non_selected_windows
) = val
;
230 bset_cursor_type (struct buffer
*b
, Lisp_Object val
)
232 b
->INTERNAL_FIELD (cursor_type
) = val
;
235 bset_display_table (struct buffer
*b
, Lisp_Object val
)
237 b
->INTERNAL_FIELD (display_table
) = val
;
240 bset_extra_line_spacing (struct buffer
*b
, Lisp_Object val
)
242 b
->INTERNAL_FIELD (extra_line_spacing
) = val
;
245 bset_file_format (struct buffer
*b
, Lisp_Object val
)
247 b
->INTERNAL_FIELD (file_format
) = val
;
250 bset_file_truename (struct buffer
*b
, Lisp_Object val
)
252 b
->INTERNAL_FIELD (file_truename
) = val
;
255 bset_fringe_cursor_alist (struct buffer
*b
, Lisp_Object val
)
257 b
->INTERNAL_FIELD (fringe_cursor_alist
) = val
;
260 bset_fringe_indicator_alist (struct buffer
*b
, Lisp_Object val
)
262 b
->INTERNAL_FIELD (fringe_indicator_alist
) = val
;
265 bset_fringes_outside_margins (struct buffer
*b
, Lisp_Object val
)
267 b
->INTERNAL_FIELD (fringes_outside_margins
) = val
;
270 bset_header_line_format (struct buffer
*b
, Lisp_Object val
)
272 b
->INTERNAL_FIELD (header_line_format
) = val
;
275 bset_indicate_buffer_boundaries (struct buffer
*b
, Lisp_Object val
)
277 b
->INTERNAL_FIELD (indicate_buffer_boundaries
) = val
;
280 bset_indicate_empty_lines (struct buffer
*b
, Lisp_Object val
)
282 b
->INTERNAL_FIELD (indicate_empty_lines
) = val
;
285 bset_invisibility_spec (struct buffer
*b
, Lisp_Object val
)
287 b
->INTERNAL_FIELD (invisibility_spec
) = val
;
290 bset_left_fringe_width (struct buffer
*b
, Lisp_Object val
)
292 b
->INTERNAL_FIELD (left_fringe_width
) = val
;
295 bset_major_mode (struct buffer
*b
, Lisp_Object val
)
297 b
->INTERNAL_FIELD (major_mode
) = val
;
300 bset_mark (struct buffer
*b
, Lisp_Object val
)
302 b
->INTERNAL_FIELD (mark
) = val
;
305 bset_minor_modes (struct buffer
*b
, Lisp_Object val
)
307 b
->INTERNAL_FIELD (minor_modes
) = val
;
310 bset_mode_line_format (struct buffer
*b
, Lisp_Object val
)
312 b
->INTERNAL_FIELD (mode_line_format
) = val
;
315 bset_mode_name (struct buffer
*b
, Lisp_Object val
)
317 b
->INTERNAL_FIELD (mode_name
) = val
;
320 bset_name (struct buffer
*b
, Lisp_Object val
)
322 b
->INTERNAL_FIELD (name
) = val
;
325 bset_overwrite_mode (struct buffer
*b
, Lisp_Object val
)
327 b
->INTERNAL_FIELD (overwrite_mode
) = val
;
330 bset_pt_marker (struct buffer
*b
, Lisp_Object val
)
332 b
->INTERNAL_FIELD (pt_marker
) = val
;
335 bset_right_fringe_width (struct buffer
*b
, Lisp_Object val
)
337 b
->INTERNAL_FIELD (right_fringe_width
) = val
;
340 bset_save_length (struct buffer
*b
, Lisp_Object val
)
342 b
->INTERNAL_FIELD (save_length
) = val
;
345 bset_scroll_bar_width (struct buffer
*b
, Lisp_Object val
)
347 b
->INTERNAL_FIELD (scroll_bar_width
) = val
;
350 bset_scroll_down_aggressively (struct buffer
*b
, Lisp_Object val
)
352 b
->INTERNAL_FIELD (scroll_down_aggressively
) = val
;
355 bset_scroll_up_aggressively (struct buffer
*b
, Lisp_Object val
)
357 b
->INTERNAL_FIELD (scroll_up_aggressively
) = val
;
360 bset_selective_display (struct buffer
*b
, Lisp_Object val
)
362 b
->INTERNAL_FIELD (selective_display
) = val
;
365 bset_selective_display_ellipses (struct buffer
*b
, Lisp_Object val
)
367 b
->INTERNAL_FIELD (selective_display_ellipses
) = val
;
370 bset_vertical_scroll_bar_type (struct buffer
*b
, Lisp_Object val
)
372 b
->INTERNAL_FIELD (vertical_scroll_bar_type
) = val
;
375 bset_word_wrap (struct buffer
*b
, Lisp_Object val
)
377 b
->INTERNAL_FIELD (word_wrap
) = val
;
380 bset_zv_marker (struct buffer
*b
, Lisp_Object val
)
382 b
->INTERNAL_FIELD (zv_marker
) = val
;
386 nsberror (Lisp_Object spec
)
389 error ("No buffer named %s", SDATA (spec
));
390 error ("Invalid buffer argument");
393 DEFUN ("buffer-live-p", Fbuffer_live_p
, Sbuffer_live_p
, 1, 1, 0,
394 doc
: /* Return non-nil if OBJECT is a buffer which has not been killed.
395 Value is nil if OBJECT is not a buffer or if it has been killed. */)
398 return ((BUFFERP (object
) && BUFFER_LIVE_P (XBUFFER (object
)))
402 DEFUN ("buffer-list", Fbuffer_list
, Sbuffer_list
, 0, 1, 0,
403 doc
: /* Return a list of all existing live buffers.
404 If the optional arg FRAME is a frame, we return the buffer list in the
405 proper order for that frame: the buffers show in FRAME come first,
406 followed by the rest of the buffers. */)
410 general
= Fmapcar (Qcdr
, Vbuffer_alist
);
414 Lisp_Object framelist
, prevlist
, tail
;
417 framelist
= Fcopy_sequence (XFRAME (frame
)->buffer_list
);
418 prevlist
= Fnreverse (Fcopy_sequence
419 (XFRAME (frame
)->buried_buffer_list
));
421 /* Remove from GENERAL any buffer that duplicates one in
422 FRAMELIST or PREVLIST. */
426 general
= Fdelq (XCAR (tail
), general
);
432 general
= Fdelq (XCAR (tail
), general
);
439 return Fnconc (3, args
);
445 /* Like Fassoc, but use Fstring_equal to compare
446 (which ignores text properties),
447 and don't ever QUIT. */
450 assoc_ignore_text_properties (register Lisp_Object key
, Lisp_Object list
)
452 register Lisp_Object tail
;
453 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
455 register Lisp_Object elt
, tem
;
457 tem
= Fstring_equal (Fcar (elt
), key
);
464 DEFUN ("get-buffer", Fget_buffer
, Sget_buffer
, 1, 1, 0,
465 doc
: /* Return the buffer named BUFFER-OR-NAME.
466 BUFFER-OR-NAME must be either a string or a buffer. If BUFFER-OR-NAME
467 is a string and there is no buffer with that name, return nil. If
468 BUFFER-OR-NAME is a buffer, return it as given. */)
469 (register Lisp_Object buffer_or_name
)
471 if (BUFFERP (buffer_or_name
))
472 return buffer_or_name
;
473 CHECK_STRING (buffer_or_name
);
475 return Fcdr (assoc_ignore_text_properties (buffer_or_name
, Vbuffer_alist
));
478 DEFUN ("get-file-buffer", Fget_file_buffer
, Sget_file_buffer
, 1, 1, 0,
479 doc
: /* Return the buffer visiting file FILENAME (a string).
480 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
481 If there is no such live buffer, return nil.
482 See also `find-buffer-visiting'. */)
483 (register Lisp_Object filename
)
485 register Lisp_Object tail
, buf
, handler
;
487 CHECK_STRING (filename
);
488 filename
= Fexpand_file_name (filename
, Qnil
);
490 /* If the file name has special constructs in it,
491 call the corresponding file handler. */
492 handler
= Ffind_file_name_handler (filename
, Qget_file_buffer
);
495 Lisp_Object handled_buf
= call2 (handler
, Qget_file_buffer
,
497 return BUFFERP (handled_buf
) ? handled_buf
: Qnil
;
500 FOR_EACH_LIVE_BUFFER (tail
, buf
)
502 if (!STRINGP (BVAR (XBUFFER (buf
), filename
))) continue;
503 if (!NILP (Fstring_equal (BVAR (XBUFFER (buf
), filename
), filename
)))
510 get_truename_buffer (register Lisp_Object filename
)
512 register Lisp_Object tail
, buf
;
514 FOR_EACH_LIVE_BUFFER (tail
, buf
)
516 if (!STRINGP (BVAR (XBUFFER (buf
), file_truename
))) continue;
517 if (!NILP (Fstring_equal (BVAR (XBUFFER (buf
), file_truename
), filename
)))
523 DEFUN ("get-buffer-create", Fget_buffer_create
, Sget_buffer_create
, 1, 1, 0,
524 doc
: /* Return the buffer specified by BUFFER-OR-NAME, creating a new one if needed.
525 If BUFFER-OR-NAME is a string and a live buffer with that name exists,
526 return that buffer. If no such buffer exists, create a new buffer with
527 that name and return it. If BUFFER-OR-NAME starts with a space, the new
528 buffer does not keep undo information.
530 If BUFFER-OR-NAME is a buffer instead of a string, return it as given,
531 even if it is dead. The return value is never nil. */)
532 (register Lisp_Object buffer_or_name
)
534 register Lisp_Object buffer
, name
;
535 register struct buffer
*b
;
537 buffer
= Fget_buffer (buffer_or_name
);
541 if (SCHARS (buffer_or_name
) == 0)
542 error ("Empty string for buffer name is not allowed");
544 b
= allocate_buffer ();
546 /* An ordinary buffer uses its own struct buffer_text. */
547 b
->text
= &b
->own_text
;
548 b
->base_buffer
= NULL
;
549 /* No one shares the text with us now. */
551 /* No one shows us now. */
554 BUF_GAP_SIZE (b
) = 20;
556 /* We allocate extra 1-byte at the tail and keep it always '\0' for
557 anchoring a search. */
558 alloc_buffer_text (b
, BUF_GAP_SIZE (b
) + 1);
560 if (! BUF_BEG_ADDR (b
))
561 buffer_memory_full (BUF_GAP_SIZE (b
) + 1);
566 b
->pt_byte
= BEG_BYTE
;
567 b
->begv_byte
= BEG_BYTE
;
568 b
->zv_byte
= BEG_BYTE
;
571 BUF_GPT_BYTE (b
) = BEG_BYTE
;
574 BUF_Z_BYTE (b
) = BEG_BYTE
;
576 BUF_CHARS_MODIFF (b
) = 1;
577 BUF_OVERLAY_MODIFF (b
) = 1;
578 BUF_SAVE_MODIFF (b
) = 1;
580 set_buffer_intervals (b
, NULL
);
581 BUF_UNCHANGED_MODIFIED (b
) = 1;
582 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = 1;
583 BUF_END_UNCHANGED (b
) = 0;
584 BUF_BEG_UNCHANGED (b
) = 0;
585 *(BUF_GPT_ADDR (b
)) = *(BUF_Z_ADDR (b
)) = 0; /* Put an anchor '\0'. */
586 b
->text
->inhibit_shrinking
= 0;
588 b
->newline_cache
= 0;
589 b
->width_run_cache
= 0;
590 b
->bidi_paragraph_cache
= 0;
591 bset_width_table (b
, Qnil
);
592 b
->prevent_redisplay_optimizations_p
= 1;
594 /* An ordinary buffer normally doesn't need markers
595 to handle BEGV and ZV. */
596 bset_pt_marker (b
, Qnil
);
597 bset_begv_marker (b
, Qnil
);
598 bset_zv_marker (b
, Qnil
);
600 name
= Fcopy_sequence (buffer_or_name
);
601 set_string_intervals (name
, NULL
);
604 bset_undo_list (b
, SREF (name
, 0) != ' ' ? Qnil
: Qt
);
607 reset_buffer_local_variables (b
, 1);
609 bset_mark (b
, Fmake_marker ());
610 BUF_MARKERS (b
) = NULL
;
612 /* Put this in the alist of all live buffers. */
613 XSETBUFFER (buffer
, b
);
614 Vbuffer_alist
= nconc2 (Vbuffer_alist
, list1 (Fcons (name
, buffer
)));
615 /* And run buffer-list-update-hook. */
616 if (!NILP (Vrun_hooks
))
617 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
623 /* Return a list of overlays which is a copy of the overlay list
624 LIST, but for buffer B. */
626 static struct Lisp_Overlay
*
627 copy_overlays (struct buffer
*b
, struct Lisp_Overlay
*list
)
629 struct Lisp_Overlay
*result
= NULL
, *tail
= NULL
;
631 for (; list
; list
= list
->next
)
633 Lisp_Object overlay
, start
, end
;
634 struct Lisp_Marker
*m
;
636 eassert (MARKERP (list
->start
));
637 m
= XMARKER (list
->start
);
638 start
= build_marker (b
, m
->charpos
, m
->bytepos
);
639 XMARKER (start
)->insertion_type
= m
->insertion_type
;
641 eassert (MARKERP (list
->end
));
642 m
= XMARKER (list
->end
);
643 end
= build_marker (b
, m
->charpos
, m
->bytepos
);
644 XMARKER (end
)->insertion_type
= m
->insertion_type
;
646 overlay
= build_overlay (start
, end
, Fcopy_sequence (list
->plist
));
648 tail
= tail
->next
= XOVERLAY (overlay
);
650 result
= tail
= XOVERLAY (overlay
);
656 /* Set an appropriate overlay of B. */
659 set_buffer_overlays_before (struct buffer
*b
, struct Lisp_Overlay
*o
)
661 b
->overlays_before
= o
;
665 set_buffer_overlays_after (struct buffer
*b
, struct Lisp_Overlay
*o
)
667 b
->overlays_after
= o
;
670 /* Clone per-buffer values of buffer FROM.
672 Buffer TO gets the same per-buffer values as FROM, with the
673 following exceptions: (1) TO's name is left untouched, (2) markers
674 are copied and made to refer to TO, and (3) overlay lists are
678 clone_per_buffer_values (struct buffer
*from
, struct buffer
*to
)
682 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
686 /* Don't touch the `name' which should be unique for every buffer. */
687 if (offset
== PER_BUFFER_VAR_OFFSET (name
))
690 obj
= per_buffer_value (from
, offset
);
691 if (MARKERP (obj
) && XMARKER (obj
)->buffer
== from
)
693 struct Lisp_Marker
*m
= XMARKER (obj
);
695 obj
= build_marker (to
, m
->charpos
, m
->bytepos
);
696 XMARKER (obj
)->insertion_type
= m
->insertion_type
;
699 set_per_buffer_value (to
, offset
, obj
);
702 memcpy (to
->local_flags
, from
->local_flags
, sizeof to
->local_flags
);
704 set_buffer_overlays_before (to
, copy_overlays (to
, from
->overlays_before
));
705 set_buffer_overlays_after (to
, copy_overlays (to
, from
->overlays_after
));
707 /* Get (a copy of) the alist of Lisp-level local variables of FROM
708 and install that in TO. */
709 bset_local_var_alist (to
, buffer_lisp_local_variables (from
, 1));
713 /* If buffer B has markers to record PT, BEGV and ZV when it is not
714 current, update these markers. */
717 record_buffer_markers (struct buffer
*b
)
719 if (! NILP (BVAR (b
, pt_marker
)))
723 eassert (!NILP (BVAR (b
, begv_marker
)));
724 eassert (!NILP (BVAR (b
, zv_marker
)));
726 XSETBUFFER (buffer
, b
);
727 set_marker_both (BVAR (b
, pt_marker
), buffer
, b
->pt
, b
->pt_byte
);
728 set_marker_both (BVAR (b
, begv_marker
), buffer
, b
->begv
, b
->begv_byte
);
729 set_marker_both (BVAR (b
, zv_marker
), buffer
, b
->zv
, b
->zv_byte
);
734 /* If buffer B has markers to record PT, BEGV and ZV when it is not
735 current, fetch these values into B->begv etc. */
738 fetch_buffer_markers (struct buffer
*b
)
740 if (! NILP (BVAR (b
, pt_marker
)))
744 eassert (!NILP (BVAR (b
, begv_marker
)));
745 eassert (!NILP (BVAR (b
, zv_marker
)));
747 m
= BVAR (b
, pt_marker
);
748 SET_BUF_PT_BOTH (b
, marker_position (m
), marker_byte_position (m
));
750 m
= BVAR (b
, begv_marker
);
751 SET_BUF_BEGV_BOTH (b
, marker_position (m
), marker_byte_position (m
));
753 m
= BVAR (b
, zv_marker
);
754 SET_BUF_ZV_BOTH (b
, marker_position (m
), marker_byte_position (m
));
759 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer
, Smake_indirect_buffer
,
761 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ",
762 doc
: /* Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.
763 BASE-BUFFER should be a live buffer, or the name of an existing buffer.
764 NAME should be a string which is not the name of an existing buffer.
765 Optional argument CLONE non-nil means preserve BASE-BUFFER's state,
766 such as major and minor modes, in the indirect buffer.
767 CLONE nil means the indirect buffer's state is reset to default values. */)
768 (Lisp_Object base_buffer
, Lisp_Object name
, Lisp_Object clone
)
770 Lisp_Object buf
, tem
;
774 buf
= Fget_buffer (name
);
776 error ("Buffer name `%s' is in use", SDATA (name
));
779 base_buffer
= Fget_buffer (base_buffer
);
780 if (NILP (base_buffer
))
781 error ("No such buffer: `%s'", SDATA (tem
));
782 if (!BUFFER_LIVE_P (XBUFFER (base_buffer
)))
783 error ("Base buffer has been killed");
785 if (SCHARS (name
) == 0)
786 error ("Empty string for buffer name is not allowed");
788 b
= allocate_buffer ();
790 /* No double indirection - if base buffer is indirect,
791 new buffer becomes an indirect to base's base. */
792 b
->base_buffer
= (XBUFFER (base_buffer
)->base_buffer
793 ? XBUFFER (base_buffer
)->base_buffer
794 : XBUFFER (base_buffer
));
796 /* Use the base buffer's text object. */
797 b
->text
= b
->base_buffer
->text
;
798 /* We have no own text. */
799 b
->indirections
= -1;
800 /* Notify base buffer that we share the text now. */
801 b
->base_buffer
->indirections
++;
802 /* Always -1 for an indirect buffer. */
803 b
->window_count
= -1;
805 b
->pt
= b
->base_buffer
->pt
;
806 b
->begv
= b
->base_buffer
->begv
;
807 b
->zv
= b
->base_buffer
->zv
;
808 b
->pt_byte
= b
->base_buffer
->pt_byte
;
809 b
->begv_byte
= b
->base_buffer
->begv_byte
;
810 b
->zv_byte
= b
->base_buffer
->zv_byte
;
812 b
->newline_cache
= 0;
813 b
->width_run_cache
= 0;
814 b
->bidi_paragraph_cache
= 0;
815 bset_width_table (b
, Qnil
);
817 name
= Fcopy_sequence (name
);
818 set_string_intervals (name
, NULL
);
822 reset_buffer_local_variables (b
, 1);
824 /* Put this in the alist of all live buffers. */
826 Vbuffer_alist
= nconc2 (Vbuffer_alist
, list1 (Fcons (name
, buf
)));
828 bset_mark (b
, Fmake_marker ());
830 /* The multibyte status belongs to the base buffer. */
831 bset_enable_multibyte_characters
832 (b
, BVAR (b
->base_buffer
, enable_multibyte_characters
));
834 /* Make sure the base buffer has markers for its narrowing. */
835 if (NILP (BVAR (b
->base_buffer
, pt_marker
)))
837 eassert (NILP (BVAR (b
->base_buffer
, begv_marker
)));
838 eassert (NILP (BVAR (b
->base_buffer
, zv_marker
)));
840 bset_pt_marker (b
->base_buffer
,
841 build_marker (b
->base_buffer
, b
->base_buffer
->pt
,
842 b
->base_buffer
->pt_byte
));
844 bset_begv_marker (b
->base_buffer
,
845 build_marker (b
->base_buffer
, b
->base_buffer
->begv
,
846 b
->base_buffer
->begv_byte
));
848 bset_zv_marker (b
->base_buffer
,
849 build_marker (b
->base_buffer
, b
->base_buffer
->zv
,
850 b
->base_buffer
->zv_byte
));
852 XMARKER (BVAR (b
->base_buffer
, zv_marker
))->insertion_type
= 1;
857 /* Give the indirect buffer markers for its narrowing. */
858 bset_pt_marker (b
, build_marker (b
, b
->pt
, b
->pt_byte
));
859 bset_begv_marker (b
, build_marker (b
, b
->begv
, b
->begv_byte
));
860 bset_zv_marker (b
, build_marker (b
, b
->zv
, b
->zv_byte
));
861 XMARKER (BVAR (b
, zv_marker
))->insertion_type
= 1;
865 struct buffer
*old_b
= current_buffer
;
867 clone_per_buffer_values (b
->base_buffer
, b
);
868 bset_filename (b
, Qnil
);
869 bset_file_truename (b
, Qnil
);
870 bset_display_count (b
, make_number (0));
871 bset_backed_up (b
, Qnil
);
872 bset_auto_save_file_name (b
, Qnil
);
873 set_buffer_internal_1 (b
);
874 Fset (intern ("buffer-save-without-query"), Qnil
);
875 Fset (intern ("buffer-file-number"), Qnil
);
876 Fset (intern ("buffer-stale-function"), Qnil
);
877 set_buffer_internal_1 (old_b
);
880 /* Run buffer-list-update-hook. */
881 if (!NILP (Vrun_hooks
))
882 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
887 /* Mark OV as no longer associated with B. */
890 drop_overlay (struct buffer
*b
, struct Lisp_Overlay
*ov
)
892 eassert (b
== XBUFFER (Fmarker_buffer (ov
->start
)));
893 modify_overlay (b
, marker_position (ov
->start
),
894 marker_position (ov
->end
));
895 Fset_marker (ov
->start
, Qnil
, Qnil
);
896 Fset_marker (ov
->end
, Qnil
, Qnil
);
900 /* Delete all overlays of B and reset it's overlay lists. */
903 delete_all_overlays (struct buffer
*b
)
905 struct Lisp_Overlay
*ov
, *next
;
907 /* FIXME: Since each drop_overlay will scan BUF_MARKERS to unlink its
908 markers, we have an unneeded O(N^2) behavior here. */
909 for (ov
= b
->overlays_before
; ov
; ov
= next
)
911 drop_overlay (b
, ov
);
916 for (ov
= b
->overlays_after
; ov
; ov
= next
)
918 drop_overlay (b
, ov
);
923 set_buffer_overlays_before (b
, NULL
);
924 set_buffer_overlays_after (b
, NULL
);
927 /* Reinitialize everything about a buffer except its name and contents
929 If called on an already-initialized buffer, the list of overlays
930 should be deleted before calling this function, otherwise we end up
931 with overlays that claim to belong to the buffer but the buffer
932 claims it doesn't belong to it. */
935 reset_buffer (register struct buffer
*b
)
937 bset_filename (b
, Qnil
);
938 bset_file_truename (b
, Qnil
);
939 bset_directory (b
, current_buffer
? BVAR (current_buffer
, directory
) : Qnil
);
940 b
->modtime
= make_emacs_time (0, UNKNOWN_MODTIME_NSECS
);
941 b
->modtime_size
= -1;
942 XSETFASTINT (BVAR (b
, save_length
), 0);
943 b
->last_window_start
= 1;
944 /* It is more conservative to start out "changed" than "unchanged". */
946 b
->prevent_redisplay_optimizations_p
= 1;
947 bset_backed_up (b
, Qnil
);
948 BUF_AUTOSAVE_MODIFF (b
) = 0;
949 b
->auto_save_failure_time
= 0;
950 bset_auto_save_file_name (b
, Qnil
);
951 bset_read_only (b
, Qnil
);
952 set_buffer_overlays_before (b
, NULL
);
953 set_buffer_overlays_after (b
, NULL
);
954 b
->overlay_center
= BEG
;
955 bset_mark_active (b
, Qnil
);
956 bset_point_before_scroll (b
, Qnil
);
957 bset_file_format (b
, Qnil
);
958 bset_auto_save_file_format (b
, Qt
);
959 bset_last_selected_window (b
, Qnil
);
960 bset_display_count (b
, make_number (0));
961 bset_display_time (b
, Qnil
);
962 bset_enable_multibyte_characters
963 (b
, BVAR (&buffer_defaults
, enable_multibyte_characters
));
964 bset_cursor_type (b
, BVAR (&buffer_defaults
, cursor_type
));
965 bset_extra_line_spacing (b
, BVAR (&buffer_defaults
, extra_line_spacing
));
967 b
->display_error_modiff
= 0;
970 /* Reset buffer B's local variables info.
971 Don't use this on a buffer that has already been in use;
972 it does not treat permanent locals consistently.
973 Instead, use Fkill_all_local_variables.
975 If PERMANENT_TOO, reset permanent buffer-local variables.
976 If not, preserve those. */
979 reset_buffer_local_variables (struct buffer
*b
, bool permanent_too
)
983 /* Reset the major mode to Fundamental, together with all the
984 things that depend on the major mode.
985 default-major-mode is handled at a higher level.
986 We ignore it here. */
987 bset_major_mode (b
, Qfundamental_mode
);
988 bset_keymap (b
, Qnil
);
989 bset_mode_name (b
, QSFundamental
);
990 bset_minor_modes (b
, Qnil
);
992 /* If the standard case table has been altered and invalidated,
993 fix up its insides first. */
994 if (! (CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[0])
995 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[1])
996 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[2])))
997 Fset_standard_case_table (Vascii_downcase_table
);
999 bset_downcase_table (b
, Vascii_downcase_table
);
1000 bset_upcase_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[0]);
1001 bset_case_canon_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[1]);
1002 bset_case_eqv_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[2]);
1003 bset_invisibility_spec (b
, Qt
);
1005 /* Reset all (or most) per-buffer variables to their defaults. */
1007 bset_local_var_alist (b
, Qnil
);
1010 Lisp_Object tmp
, prop
, last
= Qnil
;
1011 for (tmp
= BVAR (b
, local_var_alist
); CONSP (tmp
); tmp
= XCDR (tmp
))
1012 if (!NILP (prop
= Fget (XCAR (XCAR (tmp
)), Qpermanent_local
)))
1014 /* If permanent-local, keep it. */
1016 if (EQ (prop
, Qpermanent_local_hook
))
1018 /* This is a partially permanent hook variable.
1019 Preserve only the elements that want to be preserved. */
1020 Lisp_Object list
, newlist
;
1021 list
= XCDR (XCAR (tmp
));
1025 for (newlist
= Qnil
; CONSP (list
); list
= XCDR (list
))
1027 Lisp_Object elt
= XCAR (list
);
1028 /* Preserve element ELT if it's t,
1029 if it is a function with a `permanent-local-hook' property,
1030 or if it's not a symbol. */
1033 || !NILP (Fget (elt
, Qpermanent_local_hook
)))
1034 newlist
= Fcons (elt
, newlist
);
1036 XSETCDR (XCAR (tmp
), Fnreverse (newlist
));
1039 /* Delete this local variable. */
1040 else if (NILP (last
))
1041 bset_local_var_alist (b
, XCDR (tmp
));
1043 XSETCDR (last
, XCDR (tmp
));
1046 for (i
= 0; i
< last_per_buffer_idx
; ++i
)
1047 if (permanent_too
|| buffer_permanent_local_flags
[i
] == 0)
1048 SET_PER_BUFFER_VALUE_P (b
, i
, 0);
1050 /* For each slot that has a default value, copy that into the slot. */
1051 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
1053 int idx
= PER_BUFFER_IDX (offset
);
1056 || buffer_permanent_local_flags
[idx
] == 0)))
1057 set_per_buffer_value (b
, offset
, per_buffer_default (offset
));
1061 /* We split this away from generate-new-buffer, because rename-buffer
1062 and set-visited-file-name ought to be able to use this to really
1063 rename the buffer properly. */
1065 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name
,
1066 Sgenerate_new_buffer_name
, 1, 2, 0,
1067 doc
: /* Return a string that is the name of no existing buffer based on NAME.
1068 If there is no live buffer named NAME, then return NAME.
1069 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
1070 \(starting at 2) until an unused name is found, and then return that name.
1071 Optional second argument IGNORE specifies a name that is okay to use (if
1072 it is in the sequence to be tried) even if a buffer with that name exists.
1074 If NAME begins with a space (i.e., a buffer that is not normally
1075 visible to users), then if buffer NAME already exists a random number
1076 is first appended to NAME, to speed up finding a non-existent buffer. */)
1077 (register Lisp_Object name
, Lisp_Object ignore
)
1079 register Lisp_Object gentemp
, tem
, tem2
;
1081 char number
[INT_BUFSIZE_BOUND (ptrdiff_t) + sizeof "<>"];
1083 CHECK_STRING (name
);
1085 tem
= Fstring_equal (name
, ignore
);
1088 tem
= Fget_buffer (name
);
1092 if (!strncmp (SSDATA (name
), " ", 1)) /* see bug#1229 */
1094 /* Note fileio.c:make_temp_name does random differently. */
1095 tem2
= concat2 (name
, make_formatted_string
1097 XFASTINT (Frandom (make_number (999999)))));
1098 tem
= Fget_buffer (tem2
);
1108 gentemp
= concat2 (tem2
, make_formatted_string
1109 (number
, "<%"pD
"d>", ++count
));
1110 tem
= Fstring_equal (gentemp
, ignore
);
1113 tem
= Fget_buffer (gentemp
);
1120 DEFUN ("buffer-name", Fbuffer_name
, Sbuffer_name
, 0, 1, 0,
1121 doc
: /* Return the name of BUFFER, as a string.
1122 BUFFER defaults to the current buffer.
1123 Return nil if BUFFER has been killed. */)
1124 (register Lisp_Object buffer
)
1127 return BVAR (current_buffer
, name
);
1128 CHECK_BUFFER (buffer
);
1129 return BVAR (XBUFFER (buffer
), name
);
1132 DEFUN ("buffer-file-name", Fbuffer_file_name
, Sbuffer_file_name
, 0, 1, 0,
1133 doc
: /* Return name of file BUFFER is visiting, or nil if none.
1134 No argument or nil as argument means use the current buffer. */)
1135 (register Lisp_Object buffer
)
1138 return BVAR (current_buffer
, filename
);
1139 CHECK_BUFFER (buffer
);
1140 return BVAR (XBUFFER (buffer
), filename
);
1143 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer
, Sbuffer_base_buffer
,
1145 doc
: /* Return the base buffer of indirect buffer BUFFER.
1146 If BUFFER is not indirect, return nil.
1147 BUFFER defaults to the current buffer. */)
1148 (register Lisp_Object buffer
)
1150 struct buffer
*base
;
1151 Lisp_Object base_buffer
;
1154 base
= current_buffer
->base_buffer
;
1157 CHECK_BUFFER (buffer
);
1158 base
= XBUFFER (buffer
)->base_buffer
;
1163 XSETBUFFER (base_buffer
, base
);
1167 DEFUN ("buffer-local-value", Fbuffer_local_value
,
1168 Sbuffer_local_value
, 2, 2, 0,
1169 doc
: /* Return the value of VARIABLE in BUFFER.
1170 If VARIABLE does not have a buffer-local binding in BUFFER, the value
1171 is the default binding of the variable. */)
1172 (register Lisp_Object variable
, register Lisp_Object buffer
)
1174 register Lisp_Object result
= buffer_local_value_1 (variable
, buffer
);
1176 if (EQ (result
, Qunbound
))
1177 xsignal1 (Qvoid_variable
, variable
);
1183 /* Like Fbuffer_local_value, but return Qunbound if the variable is
1187 buffer_local_value_1 (Lisp_Object variable
, Lisp_Object buffer
)
1189 register struct buffer
*buf
;
1190 register Lisp_Object result
;
1191 struct Lisp_Symbol
*sym
;
1193 CHECK_SYMBOL (variable
);
1194 CHECK_BUFFER (buffer
);
1195 buf
= XBUFFER (buffer
);
1196 sym
= XSYMBOL (variable
);
1199 switch (sym
->redirect
)
1201 case SYMBOL_VARALIAS
: sym
= indirect_variable (sym
); goto start
;
1202 case SYMBOL_PLAINVAL
: result
= SYMBOL_VAL (sym
); break;
1203 case SYMBOL_LOCALIZED
:
1204 { /* Look in local_var_alist. */
1205 struct Lisp_Buffer_Local_Value
*blv
= SYMBOL_BLV (sym
);
1206 XSETSYMBOL (variable
, sym
); /* Update In case of aliasing. */
1207 result
= Fassoc (variable
, BVAR (buf
, local_var_alist
));
1211 { /* What binding is loaded right now? */
1212 Lisp_Object current_alist_element
= blv
->valcell
;
1214 /* The value of the currently loaded binding is not
1215 stored in it, but rather in the realvalue slot.
1216 Store that value into the binding it belongs to
1217 in case that is the one we are about to use. */
1219 XSETCDR (current_alist_element
,
1220 do_symval_forwarding (blv
->fwd
));
1222 /* Now get the (perhaps updated) value out of the binding. */
1223 result
= XCDR (result
);
1226 result
= Fdefault_value (variable
);
1229 case SYMBOL_FORWARDED
:
1231 union Lisp_Fwd
*fwd
= SYMBOL_FWD (sym
);
1232 if (BUFFER_OBJFWDP (fwd
))
1233 result
= per_buffer_value (buf
, XBUFFER_OBJFWD (fwd
)->offset
);
1235 result
= Fdefault_value (variable
);
1238 default: emacs_abort ();
1244 /* Return an alist of the Lisp-level buffer-local bindings of
1245 buffer BUF. That is, don't include the variables maintained
1246 in special slots in the buffer object.
1247 If not CLONE, replace elements of the form (VAR . unbound)
1251 buffer_lisp_local_variables (struct buffer
*buf
, bool clone
)
1253 Lisp_Object result
= Qnil
;
1255 for (tail
= BVAR (buf
, local_var_alist
); CONSP (tail
); tail
= XCDR (tail
))
1257 Lisp_Object val
, elt
;
1261 /* Reference each variable in the alist in buf.
1262 If inquiring about the current buffer, this gets the current values,
1263 so store them into the alist so the alist is up to date.
1264 If inquiring about some other buffer, this swaps out any values
1265 for that buffer, making the alist up to date automatically. */
1266 val
= find_symbol_value (XCAR (elt
));
1267 /* Use the current buffer value only if buf is the current buffer. */
1268 if (buf
!= current_buffer
)
1271 result
= Fcons (!clone
&& EQ (val
, Qunbound
)
1273 : Fcons (XCAR (elt
), val
),
1280 DEFUN ("buffer-local-variables", Fbuffer_local_variables
,
1281 Sbuffer_local_variables
, 0, 1, 0,
1282 doc
: /* Return an alist of variables that are buffer-local in BUFFER.
1283 Most elements look like (SYMBOL . VALUE), describing one variable.
1284 For a symbol that is locally unbound, just the symbol appears in the value.
1285 Note that storing new VALUEs in these elements doesn't change the variables.
1286 No argument or nil as argument means use current buffer as BUFFER. */)
1287 (register Lisp_Object buffer
)
1289 register struct buffer
*buf
;
1290 register Lisp_Object result
;
1293 buf
= current_buffer
;
1296 CHECK_BUFFER (buffer
);
1297 buf
= XBUFFER (buffer
);
1300 result
= buffer_lisp_local_variables (buf
, 0);
1302 /* Add on all the variables stored in special slots. */
1306 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
1308 idx
= PER_BUFFER_IDX (offset
);
1309 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
1310 && SYMBOLP (PER_BUFFER_SYMBOL (offset
)))
1312 Lisp_Object sym
= PER_BUFFER_SYMBOL (offset
);
1313 Lisp_Object val
= per_buffer_value (buf
, offset
);
1314 result
= Fcons (EQ (val
, Qunbound
) ? sym
: Fcons (sym
, val
),
1323 DEFUN ("buffer-modified-p", Fbuffer_modified_p
, Sbuffer_modified_p
,
1325 doc
: /* Return t if BUFFER was modified since its file was last read or saved.
1326 No argument or nil as argument means use current buffer as BUFFER. */)
1327 (register Lisp_Object buffer
)
1329 register struct buffer
*buf
;
1331 buf
= current_buffer
;
1334 CHECK_BUFFER (buffer
);
1335 buf
= XBUFFER (buffer
);
1338 return BUF_SAVE_MODIFF (buf
) < BUF_MODIFF (buf
) ? Qt
: Qnil
;
1341 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p
, Sset_buffer_modified_p
,
1343 doc
: /* Mark current buffer as modified or unmodified according to FLAG.
1344 A non-nil FLAG means mark the buffer modified. */)
1349 #ifdef CLASH_DETECTION
1350 /* If buffer becoming modified, lock the file.
1351 If buffer becoming unmodified, unlock the file. */
1353 struct buffer
*b
= current_buffer
->base_buffer
1354 ? current_buffer
->base_buffer
1357 fn
= BVAR (b
, file_truename
);
1358 /* Test buffer-file-name so that binding it to nil is effective. */
1359 if (!NILP (fn
) && ! NILP (BVAR (b
, filename
)))
1361 bool already
= SAVE_MODIFF
< MODIFF
;
1362 if (!already
&& !NILP (flag
))
1364 else if (already
&& NILP (flag
))
1367 #endif /* CLASH_DETECTION */
1369 /* Here we have a problem. SAVE_MODIFF is used here to encode
1370 buffer-modified-p (as SAVE_MODIFF<MODIFF) as well as
1371 recent-auto-save-p (as SAVE_MODIFF<auto_save_modified). So if we
1372 modify SAVE_MODIFF to affect one, we may affect the other
1374 E.g. if FLAG is nil we need to set SAVE_MODIFF to MODIFF, but
1375 if SAVE_MODIFF<auto_save_modified that means we risk changing
1376 recent-auto-save-p from t to nil.
1377 Vice versa, if FLAG is non-nil and SAVE_MODIFF>=auto_save_modified
1378 we risk changing recent-auto-save-p from nil to t. */
1379 SAVE_MODIFF
= (NILP (flag
)
1380 /* FIXME: This unavoidably sets recent-auto-save-p to nil. */
1382 /* Let's try to preserve recent-auto-save-p. */
1383 : SAVE_MODIFF
< MODIFF
? SAVE_MODIFF
1384 /* If SAVE_MODIFF == auto_save_modified == MODIFF,
1385 we can either decrease SAVE_MODIFF and auto_save_modified
1386 or increase MODIFF. */
1389 /* Set update_mode_lines only if buffer is displayed in some window.
1390 Packages like jit-lock or lazy-lock preserve a buffer's modified
1391 state by recording/restoring the state around blocks of code.
1392 Setting update_mode_lines makes redisplay consider all windows
1393 (on all frames). Stealth fontification of buffers not displayed
1394 would incur additional redisplay costs if we'd set
1395 update_modes_lines unconditionally.
1397 Ideally, I think there should be another mechanism for fontifying
1398 buffers without "modifying" buffers, or redisplay should be
1399 smarter about updating the `*' in mode lines. --gerd */
1400 if (buffer_window_count (current_buffer
))
1402 ++update_mode_lines
;
1403 current_buffer
->prevent_redisplay_optimizations_p
= 1;
1409 DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p
,
1410 Srestore_buffer_modified_p
, 1, 1, 0,
1411 doc
: /* Like `set-buffer-modified-p', with a difference concerning redisplay.
1412 It is not ensured that mode lines will be updated to show the modified
1413 state of the current buffer. Use with care. */)
1416 #ifdef CLASH_DETECTION
1419 /* If buffer becoming modified, lock the file.
1420 If buffer becoming unmodified, unlock the file. */
1422 fn
= BVAR (current_buffer
, file_truename
);
1423 /* Test buffer-file-name so that binding it to nil is effective. */
1424 if (!NILP (fn
) && ! NILP (BVAR (current_buffer
, filename
)))
1426 bool already
= SAVE_MODIFF
< MODIFF
;
1427 if (!already
&& !NILP (flag
))
1429 else if (already
&& NILP (flag
))
1432 #endif /* CLASH_DETECTION */
1434 SAVE_MODIFF
= NILP (flag
) ? MODIFF
: 0;
1438 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick
, Sbuffer_modified_tick
,
1440 doc
: /* Return BUFFER's tick counter, incremented for each change in text.
1441 Each buffer has a tick counter which is incremented each time the
1442 text in that buffer is changed. It wraps around occasionally.
1443 No argument or nil as argument means use current buffer as BUFFER. */)
1444 (register Lisp_Object buffer
)
1446 register struct buffer
*buf
;
1448 buf
= current_buffer
;
1451 CHECK_BUFFER (buffer
);
1452 buf
= XBUFFER (buffer
);
1455 return make_number (BUF_MODIFF (buf
));
1458 DEFUN ("buffer-chars-modified-tick", Fbuffer_chars_modified_tick
,
1459 Sbuffer_chars_modified_tick
, 0, 1, 0,
1460 doc
: /* Return BUFFER's character-change tick counter.
1461 Each buffer has a character-change tick counter, which is set to the
1462 value of the buffer's tick counter \(see `buffer-modified-tick'), each
1463 time text in that buffer is inserted or deleted. By comparing the
1464 values returned by two individual calls of `buffer-chars-modified-tick',
1465 you can tell whether a character change occurred in that buffer in
1466 between these calls. No argument or nil as argument means use current
1467 buffer as BUFFER. */)
1468 (register Lisp_Object buffer
)
1470 register struct buffer
*buf
;
1472 buf
= current_buffer
;
1475 CHECK_BUFFER (buffer
);
1476 buf
= XBUFFER (buffer
);
1479 return make_number (BUF_CHARS_MODIFF (buf
));
1482 DEFUN ("rename-buffer", Frename_buffer
, Srename_buffer
, 1, 2,
1483 "(list (read-string \"Rename buffer (to new name): \" \
1484 nil 'buffer-name-history (buffer-name (current-buffer))) \
1485 current-prefix-arg)",
1486 doc
: /* Change current buffer's name to NEWNAME (a string).
1487 If second arg UNIQUE is nil or omitted, it is an error if a
1488 buffer named NEWNAME already exists.
1489 If UNIQUE is non-nil, come up with a new name using
1490 `generate-new-buffer-name'.
1491 Interactively, you can set UNIQUE with a prefix argument.
1492 We return the name we actually gave the buffer.
1493 This does not change the name of the visited file (if any). */)
1494 (register Lisp_Object newname
, Lisp_Object unique
)
1496 register Lisp_Object tem
, buf
;
1498 CHECK_STRING (newname
);
1500 if (SCHARS (newname
) == 0)
1501 error ("Empty string is invalid as a buffer name");
1503 tem
= Fget_buffer (newname
);
1506 /* Don't short-circuit if UNIQUE is t. That is a useful way to
1507 rename the buffer automatically so you can create another
1508 with the original name. It makes UNIQUE equivalent to
1509 (rename-buffer (generate-new-buffer-name NEWNAME)). */
1510 if (NILP (unique
) && XBUFFER (tem
) == current_buffer
)
1511 return BVAR (current_buffer
, name
);
1513 newname
= Fgenerate_new_buffer_name (newname
, BVAR (current_buffer
, name
));
1515 error ("Buffer name `%s' is in use", SDATA (newname
));
1518 bset_name (current_buffer
, newname
);
1520 /* Catch redisplay's attention. Unless we do this, the mode lines for
1521 any windows displaying current_buffer will stay unchanged. */
1522 update_mode_lines
++;
1524 XSETBUFFER (buf
, current_buffer
);
1525 Fsetcar (Frassq (buf
, Vbuffer_alist
), newname
);
1526 if (NILP (BVAR (current_buffer
, filename
))
1527 && !NILP (BVAR (current_buffer
, auto_save_file_name
)))
1528 call0 (intern ("rename-auto-save-file"));
1530 /* Run buffer-list-update-hook. */
1531 if (!NILP (Vrun_hooks
))
1532 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1534 /* Refetch since that last call may have done GC. */
1535 return BVAR (current_buffer
, name
);
1538 /* True if B can be used as 'other-than-BUFFER' buffer. */
1541 candidate_buffer (Lisp_Object b
, Lisp_Object buffer
)
1543 return (BUFFERP (b
) && !EQ (b
, buffer
)
1544 && BUFFER_LIVE_P (XBUFFER (b
))
1545 && !BUFFER_HIDDEN_P (XBUFFER (b
)));
1548 DEFUN ("other-buffer", Fother_buffer
, Sother_buffer
, 0, 3, 0,
1549 doc
: /* Return most recently selected buffer other than BUFFER.
1550 Buffers not visible in windows are preferred to visible buffers, unless
1551 optional second argument VISIBLE-OK is non-nil. Ignore the argument
1552 BUFFER unless it denotes a live buffer. If the optional third argument
1553 FRAME is non-nil, use that frame's buffer list instead of the selected
1554 frame's buffer list.
1556 The buffer is found by scanning the selected or specified frame's buffer
1557 list first, followed by the list of all buffers. If no other buffer
1558 exists, return the buffer `*scratch*' (creating it if necessary). */)
1559 (register Lisp_Object buffer
, Lisp_Object visible_ok
, Lisp_Object frame
)
1561 struct frame
*f
= decode_any_frame (frame
);
1562 Lisp_Object tail
= f
->buffer_list
, pred
= f
->buffer_predicate
;
1563 Lisp_Object buf
, notsogood
= Qnil
;
1565 /* Consider buffers that have been seen in the frame first. */
1566 for (; CONSP (tail
); tail
= XCDR (tail
))
1569 if (candidate_buffer (buf
, buffer
)
1570 /* If the frame has a buffer_predicate, disregard buffers that
1571 don't fit the predicate. */
1572 && (NILP (pred
) || !NILP (call1 (pred
, buf
))))
1574 if (!NILP (visible_ok
)
1575 || NILP (Fget_buffer_window (buf
, Qvisible
)))
1577 else if (NILP (notsogood
))
1582 /* Consider alist of all buffers next. */
1583 FOR_EACH_LIVE_BUFFER (tail
, buf
)
1585 if (candidate_buffer (buf
, buffer
)
1586 /* If the frame has a buffer_predicate, disregard buffers that
1587 don't fit the predicate. */
1588 && (NILP (pred
) || !NILP (call1 (pred
, buf
))))
1590 if (!NILP (visible_ok
)
1591 || NILP (Fget_buffer_window (buf
, Qvisible
)))
1593 else if (NILP (notsogood
))
1598 if (!NILP (notsogood
))
1602 buf
= Fget_buffer (build_string ("*scratch*"));
1605 buf
= Fget_buffer_create (build_string ("*scratch*"));
1606 Fset_buffer_major_mode (buf
);
1612 /* The following function is a safe variant of Fother_buffer: It doesn't
1613 pay attention to any frame-local buffer lists, doesn't care about
1614 visibility of buffers, and doesn't evaluate any frame predicates. */
1617 other_buffer_safely (Lisp_Object buffer
)
1619 Lisp_Object tail
, buf
;
1621 FOR_EACH_LIVE_BUFFER (tail
, buf
)
1622 if (candidate_buffer (buf
, buffer
))
1625 buf
= Fget_buffer (build_string ("*scratch*"));
1628 buf
= Fget_buffer_create (build_string ("*scratch*"));
1629 Fset_buffer_major_mode (buf
);
1635 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo
, Sbuffer_enable_undo
,
1637 doc
: /* Start keeping undo information for buffer BUFFER.
1638 No argument or nil as argument means do this for the current buffer. */)
1639 (register Lisp_Object buffer
)
1641 Lisp_Object real_buffer
;
1644 XSETBUFFER (real_buffer
, current_buffer
);
1647 real_buffer
= Fget_buffer (buffer
);
1648 if (NILP (real_buffer
))
1652 if (EQ (BVAR (XBUFFER (real_buffer
), undo_list
), Qt
))
1653 bset_undo_list (XBUFFER (real_buffer
), Qnil
);
1658 /* Truncate undo list and shrink the gap of BUFFER. */
1661 compact_buffer (struct buffer
*buffer
)
1663 BUFFER_CHECK_INDIRECTION (buffer
);
1665 /* Skip dead buffers, indirect buffers and buffers
1666 which aren't changed since last compaction. */
1667 if (BUFFER_LIVE_P (buffer
)
1668 && (buffer
->base_buffer
== NULL
)
1669 && (BUF_COMPACT (buffer
) != BUF_MODIFF (buffer
)))
1671 /* If a buffer's undo list is Qt, that means that undo is
1672 turned off in that buffer. Calling truncate_undo_list on
1673 Qt tends to return NULL, which effectively turns undo back on.
1674 So don't call truncate_undo_list if undo_list is Qt. */
1675 if (!EQ (buffer
->INTERNAL_FIELD (undo_list
), Qt
))
1676 truncate_undo_list (buffer
);
1678 /* Shrink buffer gaps. */
1679 if (!buffer
->text
->inhibit_shrinking
)
1681 /* If a buffer's gap size is more than 10% of the buffer
1682 size, or larger than GAP_BYTES_DFL bytes, then shrink it
1683 accordingly. Keep a minimum size of GAP_BYTES_MIN bytes. */
1684 ptrdiff_t size
= clip_to_bounds (GAP_BYTES_MIN
,
1685 BUF_Z_BYTE (buffer
) / 10,
1687 if (BUF_GAP_SIZE (buffer
) > size
)
1688 make_gap_1 (buffer
, -(BUF_GAP_SIZE (buffer
) - size
));
1690 BUF_COMPACT (buffer
) = BUF_MODIFF (buffer
);
1694 DEFUN ("kill-buffer", Fkill_buffer
, Skill_buffer
, 0, 1, "bKill buffer: ",
1695 doc
: /* Kill the buffer specified by BUFFER-OR-NAME.
1696 The argument may be a buffer or the name of an existing buffer.
1697 Argument nil or omitted means kill the current buffer. Return t if the
1698 buffer is actually killed, nil otherwise.
1700 The functions in `kill-buffer-query-functions' are called with the
1701 buffer to be killed as the current buffer. If any of them returns nil,
1702 the buffer is not killed. The hook `kill-buffer-hook' is run before the
1703 buffer is actually killed. The buffer being killed will be current
1704 while the hook is running. Functions called by any of these hooks are
1705 supposed to not change the current buffer.
1707 Any processes that have this buffer as the `process-buffer' are killed
1708 with SIGHUP. This function calls `replace-buffer-in-windows' for
1709 cleaning up all windows currently displaying the buffer to be killed. */)
1710 (Lisp_Object buffer_or_name
)
1713 register struct buffer
*b
;
1714 register Lisp_Object tem
;
1715 register struct Lisp_Marker
*m
;
1716 struct gcpro gcpro1
;
1718 if (NILP (buffer_or_name
))
1719 buffer
= Fcurrent_buffer ();
1721 buffer
= Fget_buffer (buffer_or_name
);
1723 nsberror (buffer_or_name
);
1725 b
= XBUFFER (buffer
);
1727 /* Avoid trouble for buffer already dead. */
1728 if (!BUFFER_LIVE_P (b
))
1731 /* Run hooks with the buffer to be killed the current buffer. */
1733 ptrdiff_t count
= SPECPDL_INDEX ();
1734 Lisp_Object arglist
[1];
1736 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1737 set_buffer_internal (b
);
1739 /* First run the query functions; if any query is answered no,
1740 don't kill the buffer. */
1741 arglist
[0] = Qkill_buffer_query_functions
;
1742 tem
= Frun_hook_with_args_until_failure (1, arglist
);
1744 return unbind_to (count
, Qnil
);
1746 /* Query if the buffer is still modified. */
1747 if (INTERACTIVE
&& !NILP (BVAR (b
, filename
))
1748 && BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
1751 tem
= do_yes_or_no_p (format2 ("Buffer %s modified; kill anyway? ",
1752 BVAR (b
, name
), make_number (0)));
1755 return unbind_to (count
, Qnil
);
1758 /* If the hooks have killed the buffer, exit now. */
1759 if (!BUFFER_LIVE_P (b
))
1760 return unbind_to (count
, Qt
);
1762 /* Then run the hooks. */
1763 Frun_hooks (1, &Qkill_buffer_hook
);
1764 unbind_to (count
, Qnil
);
1767 /* If the hooks have killed the buffer, exit now. */
1768 if (!BUFFER_LIVE_P (b
))
1771 /* We have no more questions to ask. Verify that it is valid
1772 to kill the buffer. This must be done after the questions
1773 since anything can happen within do_yes_or_no_p. */
1775 /* Don't kill the minibuffer now current. */
1776 if (EQ (buffer
, XWINDOW (minibuf_window
)->contents
))
1779 /* When we kill an ordinary buffer which shares it's buffer text
1780 with indirect buffer(s), we must kill indirect buffer(s) too.
1781 We do it at this stage so nothing terrible happens if they
1782 ask questions or their hooks get errors. */
1783 if (!b
->base_buffer
&& b
->indirections
> 0)
1785 struct buffer
*other
;
1789 FOR_EACH_BUFFER (other
)
1790 if (other
->base_buffer
== b
)
1793 XSETBUFFER (buf
, other
);
1799 /* Exit if we now have killed the base buffer (Bug#11665). */
1800 if (!BUFFER_LIVE_P (b
))
1804 /* Run replace_buffer_in_windows before making another buffer current
1805 since set-window-buffer-start-and-point will refuse to make another
1806 buffer current if the selected window does not show the current
1807 buffer. (Bug#10114) */
1808 replace_buffer_in_windows (buffer
);
1810 /* Exit if replacing the buffer in windows has killed our buffer. */
1811 if (!BUFFER_LIVE_P (b
))
1814 /* Make this buffer not be current. Exit if it is the sole visible
1816 if (b
== current_buffer
)
1818 tem
= Fother_buffer (buffer
, Qnil
, Qnil
);
1820 if (b
== current_buffer
)
1824 /* If the buffer now current is shown in the minibuffer and our buffer
1825 is the sole other buffer give up. */
1826 XSETBUFFER (tem
, current_buffer
);
1827 if (EQ (tem
, XWINDOW (minibuf_window
)->contents
)
1828 && EQ (buffer
, Fother_buffer (buffer
, Qnil
, Qnil
)))
1831 /* Now there is no question: we can kill the buffer. */
1833 #ifdef CLASH_DETECTION
1834 /* Unlock this buffer's file, if it is locked. */
1836 #endif /* CLASH_DETECTION */
1839 kill_buffer_processes (buffer
);
1842 #ifdef HAVE_XWIDGETS
1844 kill_buffer_xwidgets (buffer
);
1846 #endif /* HAVE_XWIDGETS */
1847 /* Killing buffer processes may run sentinels which may have killed
1849 if (!BUFFER_LIVE_P (b
))
1852 /* These may run Lisp code and into infinite loops (if someone
1853 insisted on circular lists) so allow quitting here. */
1854 frames_discard_buffer (buffer
);
1856 clear_charpos_cache (b
);
1858 tem
= Vinhibit_quit
;
1860 /* Remove the buffer from the list of all buffers. */
1861 Vbuffer_alist
= Fdelq (Frassq (buffer
, Vbuffer_alist
), Vbuffer_alist
);
1862 /* If replace_buffer_in_windows didn't do its job fix that now. */
1863 replace_buffer_in_windows_safely (buffer
);
1864 Vinhibit_quit
= tem
;
1866 /* Delete any auto-save file, if we saved it in this session.
1867 But not if the buffer is modified. */
1868 if (STRINGP (BVAR (b
, auto_save_file_name
))
1869 && BUF_AUTOSAVE_MODIFF (b
) != 0
1870 && BUF_SAVE_MODIFF (b
) < BUF_AUTOSAVE_MODIFF (b
)
1871 && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
)
1872 && NILP (Fsymbol_value (intern ("auto-save-visited-file-name"))))
1875 delete = Fsymbol_value (intern ("delete-auto-save-files"));
1876 if (! NILP (delete))
1877 internal_delete_file (BVAR (b
, auto_save_file_name
));
1880 /* Deleting an auto-save file could have killed our buffer. */
1881 if (!BUFFER_LIVE_P (b
))
1886 /* Unchain all markers that belong to this indirect buffer.
1887 Don't unchain the markers that belong to the base buffer
1888 or its other indirect buffers. */
1889 struct Lisp_Marker
**mp
= &BUF_MARKERS (b
);
1903 /* Unchain all markers of this buffer and its indirect buffers.
1904 and leave them pointing nowhere. */
1905 for (m
= BUF_MARKERS (b
); m
; )
1907 struct Lisp_Marker
*next
= m
->next
;
1912 BUF_MARKERS (b
) = NULL
;
1913 set_buffer_intervals (b
, NULL
);
1915 /* Perhaps we should explicitly free the interval tree here... */
1917 /* Since we've unlinked the markers, the overlays can't be here any more
1919 b
->overlays_before
= NULL
;
1920 b
->overlays_after
= NULL
;
1922 /* Reset the local variables, so that this buffer's local values
1923 won't be protected from GC. They would be protected
1924 if they happened to remain cached in their symbols.
1925 This gets rid of them for certain. */
1926 swap_out_buffer_local_variables (b
);
1927 reset_buffer_local_variables (b
, 1);
1929 bset_name (b
, Qnil
);
1934 /* Notify our base buffer that we don't share the text anymore. */
1935 eassert (b
->indirections
== -1);
1936 b
->base_buffer
->indirections
--;
1937 eassert (b
->base_buffer
->indirections
>= 0);
1938 /* Make sure that we wasn't confused. */
1939 eassert (b
->window_count
== -1);
1943 /* Make sure that no one shows us. */
1944 eassert (b
->window_count
== 0);
1945 /* No one shares our buffer text, can free it. */
1946 free_buffer_text (b
);
1949 if (b
->newline_cache
)
1951 free_region_cache (b
->newline_cache
);
1952 b
->newline_cache
= 0;
1954 if (b
->width_run_cache
)
1956 free_region_cache (b
->width_run_cache
);
1957 b
->width_run_cache
= 0;
1959 if (b
->bidi_paragraph_cache
)
1961 free_region_cache (b
->bidi_paragraph_cache
);
1962 b
->bidi_paragraph_cache
= 0;
1964 bset_width_table (b
, Qnil
);
1966 bset_undo_list (b
, Qnil
);
1968 /* Run buffer-list-update-hook. */
1969 if (!NILP (Vrun_hooks
))
1970 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1975 /* Move association for BUFFER to the front of buffer (a)lists. Since
1976 we do this each time BUFFER is selected visibly, the more recently
1977 selected buffers are always closer to the front of those lists. This
1978 means that other_buffer is more likely to choose a relevant buffer.
1980 Note that this moves BUFFER to the front of the buffer lists of the
1981 selected frame even if BUFFER is not shown there. If BUFFER is not
1982 shown in the selected frame, consider the present behavior a feature.
1983 `select-window' gets this right since it shows BUFFER in the selected
1984 window when calling us. */
1987 record_buffer (Lisp_Object buffer
)
1989 Lisp_Object aelt
, aelt_cons
, tem
;
1990 register struct frame
*f
= XFRAME (selected_frame
);
1992 CHECK_BUFFER (buffer
);
1994 /* Update Vbuffer_alist (we know that it has an entry for BUFFER).
1995 Don't allow quitting since this might leave the buffer list in an
1996 inconsistent state. */
1997 tem
= Vinhibit_quit
;
1999 aelt
= Frassq (buffer
, Vbuffer_alist
);
2000 aelt_cons
= Fmemq (aelt
, Vbuffer_alist
);
2001 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
2002 XSETCDR (aelt_cons
, Vbuffer_alist
);
2003 Vbuffer_alist
= aelt_cons
;
2004 Vinhibit_quit
= tem
;
2006 /* Update buffer list of selected frame. */
2007 fset_buffer_list (f
, Fcons (buffer
, Fdelq (buffer
, f
->buffer_list
)));
2008 fset_buried_buffer_list (f
, Fdelq (buffer
, f
->buried_buffer_list
));
2010 /* Run buffer-list-update-hook. */
2011 if (!NILP (Vrun_hooks
))
2012 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
2016 /* Move BUFFER to the end of the buffer (a)lists. Do nothing if the
2017 buffer is killed. For the selected frame's buffer list this moves
2018 BUFFER to its end even if it was never shown in that frame. If
2019 this happens we have a feature, hence `bury-buffer-internal' should be
2020 called only when BUFFER was shown in the selected frame. */
2022 DEFUN ("bury-buffer-internal", Fbury_buffer_internal
, Sbury_buffer_internal
,
2024 doc
: /* Move BUFFER to the end of the buffer list. */)
2025 (Lisp_Object buffer
)
2027 Lisp_Object aelt
, aelt_cons
, tem
;
2028 register struct frame
*f
= XFRAME (selected_frame
);
2030 CHECK_BUFFER (buffer
);
2032 /* Update Vbuffer_alist (we know that it has an entry for BUFFER).
2033 Don't allow quitting since this might leave the buffer list in an
2034 inconsistent state. */
2035 tem
= Vinhibit_quit
;
2037 aelt
= Frassq (buffer
, Vbuffer_alist
);
2038 aelt_cons
= Fmemq (aelt
, Vbuffer_alist
);
2039 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
2040 XSETCDR (aelt_cons
, Qnil
);
2041 Vbuffer_alist
= nconc2 (Vbuffer_alist
, aelt_cons
);
2042 Vinhibit_quit
= tem
;
2044 /* Update buffer lists of selected frame. */
2045 fset_buffer_list (f
, Fdelq (buffer
, f
->buffer_list
));
2046 fset_buried_buffer_list
2047 (f
, Fcons (buffer
, Fdelq (buffer
, f
->buried_buffer_list
)));
2049 /* Run buffer-list-update-hook. */
2050 if (!NILP (Vrun_hooks
))
2051 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
2056 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode
, Sset_buffer_major_mode
, 1, 1, 0,
2057 doc
: /* Set an appropriate major mode for BUFFER.
2058 For the *scratch* buffer, use `initial-major-mode', otherwise choose a mode
2059 according to the default value of `major-mode'.
2060 Use this function before selecting the buffer, since it may need to inspect
2061 the current buffer's major mode. */)
2062 (Lisp_Object buffer
)
2065 Lisp_Object function
;
2067 CHECK_BUFFER (buffer
);
2069 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
2070 error ("Attempt to set major mode for a dead buffer");
2072 if (strcmp (SSDATA (BVAR (XBUFFER (buffer
), name
)), "*scratch*") == 0)
2073 function
= find_symbol_value (intern ("initial-major-mode"));
2076 function
= BVAR (&buffer_defaults
, major_mode
);
2078 && NILP (Fget (BVAR (current_buffer
, major_mode
), Qmode_class
)))
2079 function
= BVAR (current_buffer
, major_mode
);
2082 if (NILP (function
) || EQ (function
, Qfundamental_mode
))
2085 count
= SPECPDL_INDEX ();
2087 /* To select a nonfundamental mode,
2088 select the buffer temporarily and then call the mode function. */
2090 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2092 Fset_buffer (buffer
);
2095 return unbind_to (count
, Qnil
);
2098 DEFUN ("current-buffer", Fcurrent_buffer
, Scurrent_buffer
, 0, 0, 0,
2099 doc
: /* Return the current buffer as a Lisp object. */)
2102 register Lisp_Object buf
;
2103 XSETBUFFER (buf
, current_buffer
);
2107 /* Set the current buffer to B, and do not set windows_or_buffers_changed.
2108 This is used by redisplay. */
2111 set_buffer_internal_1 (register struct buffer
*b
)
2113 register struct buffer
*old_buf
;
2114 register Lisp_Object tail
;
2116 #ifdef USE_MMAP_FOR_BUFFERS
2117 if (b
->text
->beg
== NULL
)
2118 enlarge_buffer_text (b
, 0);
2119 #endif /* USE_MMAP_FOR_BUFFERS */
2121 if (current_buffer
== b
)
2124 BUFFER_CHECK_INDIRECTION (b
);
2126 old_buf
= current_buffer
;
2128 last_known_column_point
= -1; /* invalidate indentation cache */
2132 /* Put the undo list back in the base buffer, so that it appears
2133 that an indirect buffer shares the undo list of its base. */
2134 if (old_buf
->base_buffer
)
2135 bset_undo_list (old_buf
->base_buffer
, BVAR (old_buf
, undo_list
));
2137 /* If the old current buffer has markers to record PT, BEGV and ZV
2138 when it is not current, update them now. */
2139 record_buffer_markers (old_buf
);
2142 /* Get the undo list from the base buffer, so that it appears
2143 that an indirect buffer shares the undo list of its base. */
2145 bset_undo_list (b
, BVAR (b
->base_buffer
, undo_list
));
2147 /* If the new current buffer has markers to record PT, BEGV and ZV
2148 when it is not current, fetch them now. */
2149 fetch_buffer_markers (b
);
2151 /* Look down buffer's list of local Lisp variables
2152 to find and update any that forward into C variables. */
2156 for (tail
= BVAR (b
, local_var_alist
); CONSP (tail
); tail
= XCDR (tail
))
2158 Lisp_Object var
= XCAR (XCAR (tail
));
2159 struct Lisp_Symbol
*sym
= XSYMBOL (var
);
2160 if (sym
->redirect
== SYMBOL_LOCALIZED
/* Just to be sure. */
2161 && SYMBOL_BLV (sym
)->fwd
)
2162 /* Just reference the variable
2163 to cause it to become set for this buffer. */
2164 Fsymbol_value (var
);
2167 /* Do the same with any others that were local to the previous buffer */
2168 while (b
!= old_buf
&& (b
= old_buf
, b
));
2171 /* Switch to buffer B temporarily for redisplay purposes.
2172 This avoids certain things that don't need to be done within redisplay. */
2175 set_buffer_temp (struct buffer
*b
)
2177 register struct buffer
*old_buf
;
2179 if (current_buffer
== b
)
2182 old_buf
= current_buffer
;
2185 /* If the old current buffer has markers to record PT, BEGV and ZV
2186 when it is not current, update them now. */
2187 record_buffer_markers (old_buf
);
2189 /* If the new current buffer has markers to record PT, BEGV and ZV
2190 when it is not current, fetch them now. */
2191 fetch_buffer_markers (b
);
2194 DEFUN ("set-buffer", Fset_buffer
, Sset_buffer
, 1, 1, 0,
2195 doc
: /* Make buffer BUFFER-OR-NAME current for editing operations.
2196 BUFFER-OR-NAME may be a buffer or the name of an existing buffer. See
2197 also `with-current-buffer' when you want to make a buffer current
2198 temporarily. This function does not display the buffer, so its effect
2199 ends when the current command terminates. Use `switch-to-buffer' or
2200 `pop-to-buffer' to switch buffers permanently. */)
2201 (register Lisp_Object buffer_or_name
)
2203 register Lisp_Object buffer
;
2204 buffer
= Fget_buffer (buffer_or_name
);
2206 nsberror (buffer_or_name
);
2207 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
2208 error ("Selecting deleted buffer");
2209 set_buffer_internal (XBUFFER (buffer
));
2214 restore_buffer (Lisp_Object buffer_or_name
)
2216 Fset_buffer (buffer_or_name
);
2219 /* Set the current buffer to BUFFER provided if it is alive. */
2222 set_buffer_if_live (Lisp_Object buffer
)
2224 if (BUFFER_LIVE_P (XBUFFER (buffer
)))
2225 set_buffer_internal (XBUFFER (buffer
));
2228 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only
,
2229 Sbarf_if_buffer_read_only
, 0, 0, 0,
2230 doc
: /* Signal a `buffer-read-only' error if the current buffer is read-only. */)
2233 if (!NILP (BVAR (current_buffer
, read_only
))
2234 && NILP (Vinhibit_read_only
))
2235 xsignal1 (Qbuffer_read_only
, Fcurrent_buffer ());
2239 DEFUN ("erase-buffer", Ferase_buffer
, Serase_buffer
, 0, 0, "*",
2240 doc
: /* Delete the entire contents of the current buffer.
2241 Any narrowing restriction in effect (see `narrow-to-region') is removed,
2242 so the buffer is truly empty after this. */)
2249 current_buffer
->last_window_start
= 1;
2250 /* Prevent warnings, or suspension of auto saving, that would happen
2251 if future size is less than past size. Use of erase-buffer
2252 implies that the future text is not really related to the past text. */
2253 XSETFASTINT (BVAR (current_buffer
, save_length
), 0);
2258 validate_region (register Lisp_Object
*b
, register Lisp_Object
*e
)
2260 CHECK_NUMBER_COERCE_MARKER (*b
);
2261 CHECK_NUMBER_COERCE_MARKER (*e
);
2263 if (XINT (*b
) > XINT (*e
))
2266 tem
= *b
; *b
= *e
; *e
= tem
;
2269 if (! (BEGV
<= XINT (*b
) && XINT (*e
) <= ZV
))
2270 args_out_of_range (*b
, *e
);
2273 /* Advance BYTE_POS up to a character boundary
2274 and return the adjusted position. */
2277 advance_to_char_boundary (ptrdiff_t byte_pos
)
2281 if (byte_pos
== BEG
)
2282 /* Beginning of buffer is always a character boundary. */
2285 c
= FETCH_BYTE (byte_pos
);
2286 if (! CHAR_HEAD_P (c
))
2288 /* We should advance BYTE_POS only when C is a constituent of a
2289 multibyte sequence. */
2290 ptrdiff_t orig_byte_pos
= byte_pos
;
2295 c
= FETCH_BYTE (byte_pos
);
2297 while (! CHAR_HEAD_P (c
) && byte_pos
> BEG
);
2299 if (byte_pos
< orig_byte_pos
)
2300 byte_pos
= orig_byte_pos
;
2301 /* If C is a constituent of a multibyte sequence, BYTE_POS was
2302 surely advance to the correct character boundary. If C is
2303 not, BYTE_POS was unchanged. */
2309 DEFUN ("buffer-swap-text", Fbuffer_swap_text
, Sbuffer_swap_text
,
2311 doc
: /* Swap the text between current buffer and BUFFER. */)
2312 (Lisp_Object buffer
)
2314 struct buffer
*other_buffer
;
2315 CHECK_BUFFER (buffer
);
2316 other_buffer
= XBUFFER (buffer
);
2318 if (!BUFFER_LIVE_P (other_buffer
))
2319 error ("Cannot swap a dead buffer's text");
2321 /* Actually, it probably works just fine.
2322 * if (other_buffer == current_buffer)
2323 * error ("Cannot swap a buffer's text with itself"); */
2325 /* Actually, this may be workable as well, tho probably only if they're
2327 if (other_buffer
->base_buffer
2328 || current_buffer
->base_buffer
)
2329 error ("Cannot swap indirect buffers's text");
2331 { /* This is probably harder to make work. */
2332 struct buffer
*other
;
2333 FOR_EACH_BUFFER (other
)
2334 if (other
->base_buffer
== other_buffer
2335 || other
->base_buffer
== current_buffer
)
2336 error ("One of the buffers to swap has indirect buffers");
2339 #define swapfield(field, type) \
2341 type tmp##field = other_buffer->field; \
2342 other_buffer->field = current_buffer->field; \
2343 current_buffer->field = tmp##field; \
2345 #define swapfield_(field, type) \
2347 type tmp##field = BVAR (other_buffer, field); \
2348 bset_##field (other_buffer, BVAR (current_buffer, field)); \
2349 bset_##field (current_buffer, tmp##field); \
2352 swapfield (own_text
, struct buffer_text
);
2353 eassert (current_buffer
->text
== ¤t_buffer
->own_text
);
2354 eassert (other_buffer
->text
== &other_buffer
->own_text
);
2356 r_alloc_reset_variable ((void **) ¤t_buffer
->own_text
.beg
,
2357 (void **) &other_buffer
->own_text
.beg
);
2358 r_alloc_reset_variable ((void **) &other_buffer
->own_text
.beg
,
2359 (void **) ¤t_buffer
->own_text
.beg
);
2360 #endif /* REL_ALLOC */
2362 swapfield (pt
, ptrdiff_t);
2363 swapfield (pt_byte
, ptrdiff_t);
2364 swapfield (begv
, ptrdiff_t);
2365 swapfield (begv_byte
, ptrdiff_t);
2366 swapfield (zv
, ptrdiff_t);
2367 swapfield (zv_byte
, ptrdiff_t);
2368 eassert (!current_buffer
->base_buffer
);
2369 eassert (!other_buffer
->base_buffer
);
2370 swapfield (indirections
, ptrdiff_t);
2371 current_buffer
->clip_changed
= 1; other_buffer
->clip_changed
= 1;
2372 swapfield (newline_cache
, struct region_cache
*);
2373 swapfield (width_run_cache
, struct region_cache
*);
2374 swapfield (bidi_paragraph_cache
, struct region_cache
*);
2375 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2376 other_buffer
->prevent_redisplay_optimizations_p
= 1;
2377 swapfield (overlays_before
, struct Lisp_Overlay
*);
2378 swapfield (overlays_after
, struct Lisp_Overlay
*);
2379 swapfield (overlay_center
, ptrdiff_t);
2380 swapfield_ (undo_list
, Lisp_Object
);
2381 swapfield_ (mark
, Lisp_Object
);
2382 swapfield_ (enable_multibyte_characters
, Lisp_Object
);
2383 swapfield_ (bidi_display_reordering
, Lisp_Object
);
2384 swapfield_ (bidi_paragraph_direction
, Lisp_Object
);
2385 /* FIXME: Not sure what we should do with these *_marker fields.
2386 Hopefully they're just nil anyway. */
2387 swapfield_ (pt_marker
, Lisp_Object
);
2388 swapfield_ (begv_marker
, Lisp_Object
);
2389 swapfield_ (zv_marker
, Lisp_Object
);
2390 bset_point_before_scroll (current_buffer
, Qnil
);
2391 bset_point_before_scroll (other_buffer
, Qnil
);
2393 current_buffer
->text
->modiff
++; other_buffer
->text
->modiff
++;
2394 current_buffer
->text
->chars_modiff
++; other_buffer
->text
->chars_modiff
++;
2395 current_buffer
->text
->overlay_modiff
++; other_buffer
->text
->overlay_modiff
++;
2396 current_buffer
->text
->beg_unchanged
= current_buffer
->text
->gpt
;
2397 current_buffer
->text
->end_unchanged
= current_buffer
->text
->gpt
;
2398 other_buffer
->text
->beg_unchanged
= other_buffer
->text
->gpt
;
2399 other_buffer
->text
->end_unchanged
= other_buffer
->text
->gpt
;
2401 struct Lisp_Marker
*m
;
2402 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
2403 if (m
->buffer
== other_buffer
)
2404 m
->buffer
= current_buffer
;
2406 /* Since there's no indirect buffer in sight, markers on
2407 BUF_MARKERS(buf) should either be for `buf' or dead. */
2408 eassert (!m
->buffer
);
2409 for (m
= BUF_MARKERS (other_buffer
); m
; m
= m
->next
)
2410 if (m
->buffer
== current_buffer
)
2411 m
->buffer
= other_buffer
;
2413 /* Since there's no indirect buffer in sight, markers on
2414 BUF_MARKERS(buf) should either be for `buf' or dead. */
2415 eassert (!m
->buffer
);
2417 { /* Some of the C code expects that both window markers of a
2418 live window points to that window's buffer. So since we
2419 just swapped the markers between the two buffers, we need
2420 to undo the effect of this swap for window markers. */
2421 Lisp_Object w
= selected_window
, ws
= Qnil
;
2422 Lisp_Object buf1
, buf2
;
2423 XSETBUFFER (buf1
, current_buffer
); XSETBUFFER (buf2
, other_buffer
);
2425 while (NILP (Fmemq (w
, ws
)))
2428 if (MARKERP (XWINDOW (w
)->pointm
)
2429 && (EQ (XWINDOW (w
)->contents
, buf1
)
2430 || EQ (XWINDOW (w
)->contents
, buf2
)))
2431 Fset_marker (XWINDOW (w
)->pointm
,
2433 (BUF_BEGV (XBUFFER (XWINDOW (w
)->contents
))),
2434 XWINDOW (w
)->contents
);
2435 if (MARKERP (XWINDOW (w
)->start
)
2436 && (EQ (XWINDOW (w
)->contents
, buf1
)
2437 || EQ (XWINDOW (w
)->contents
, buf2
)))
2438 Fset_marker (XWINDOW (w
)->start
,
2440 (XBUFFER (XWINDOW (w
)->contents
)->last_window_start
),
2441 XWINDOW (w
)->contents
);
2442 w
= Fnext_window (w
, Qt
, Qt
);
2446 if (current_buffer
->text
->intervals
)
2447 (eassert (EQ (current_buffer
->text
->intervals
->up
.obj
, buffer
)),
2448 XSETBUFFER (current_buffer
->text
->intervals
->up
.obj
, current_buffer
));
2449 if (other_buffer
->text
->intervals
)
2450 (eassert (EQ (other_buffer
->text
->intervals
->up
.obj
, Fcurrent_buffer ())),
2451 XSETBUFFER (other_buffer
->text
->intervals
->up
.obj
, other_buffer
));
2456 DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte
, Sset_buffer_multibyte
,
2458 doc
: /* Set the multibyte flag of the current buffer to FLAG.
2459 If FLAG is t, this makes the buffer a multibyte buffer.
2460 If FLAG is nil, this makes the buffer a single-byte buffer.
2461 In these cases, the buffer contents remain unchanged as a sequence of
2462 bytes but the contents viewed as characters do change.
2463 If FLAG is `to', this makes the buffer a multibyte buffer by changing
2464 all eight-bit bytes to eight-bit characters.
2465 If the multibyte flag was really changed, undo information of the
2466 current buffer is cleared. */)
2469 struct Lisp_Marker
*tail
, *markers
;
2470 struct buffer
*other
;
2472 bool narrowed
= (BEG
!= BEGV
|| Z
!= ZV
);
2473 bool modified_p
= !NILP (Fbuffer_modified_p (Qnil
));
2474 Lisp_Object old_undo
= BVAR (current_buffer
, undo_list
);
2475 struct gcpro gcpro1
;
2477 if (current_buffer
->base_buffer
)
2478 error ("Cannot do `set-buffer-multibyte' on an indirect buffer");
2480 /* Do nothing if nothing actually changes. */
2481 if (NILP (flag
) == NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
2486 /* Don't record these buffer changes. We will put a special undo entry
2488 bset_undo_list (current_buffer
, Qt
);
2490 /* If the cached position is for this buffer, clear it out. */
2491 clear_charpos_cache (current_buffer
);
2494 begv
= BEGV_BYTE
, zv
= ZV_BYTE
;
2496 begv
= BEGV
, zv
= ZV
;
2499 error ("Changing multibyteness in a narrowed buffer");
2503 ptrdiff_t pos
, stop
;
2506 /* Do this first, so it can use CHAR_TO_BYTE
2507 to calculate the old correspondences. */
2508 set_intervals_multibyte (0);
2510 bset_enable_multibyte_characters (current_buffer
, Qnil
);
2516 TEMP_SET_PT_BOTH (PT_BYTE
, PT_BYTE
);
2519 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
2520 tail
->charpos
= tail
->bytepos
;
2522 /* Convert multibyte form of 8-bit characters to unibyte. */
2537 if (ASCII_BYTE_P (*p
))
2539 else if (CHAR_BYTE8_HEAD_P (*p
))
2541 c
= STRING_CHAR_AND_LENGTH (p
, bytes
);
2542 /* Delete all bytes for this 8-bit character but the
2543 last one, and change the last one to the character
2546 del_range_2 (pos
, pos
, pos
+ bytes
, pos
+ bytes
, 0);
2558 bytes
= BYTES_BY_CHAR_HEAD (*p
);
2559 p
+= bytes
, pos
+= bytes
;
2563 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2568 ptrdiff_t pos
, stop
;
2569 unsigned char *p
, *pend
;
2571 /* Be sure not to have a multibyte sequence striding over the GAP.
2572 Ex: We change this: "...abc\302 _GAP_ \241def..."
2573 to: "...abc _GAP_ \302\241def..." */
2576 && GPT_BYTE
> 1 && GPT_BYTE
< Z_BYTE
2577 && ! CHAR_HEAD_P (*(GAP_END_ADDR
)))
2579 unsigned char *q
= GPT_ADDR
- 1;
2581 while (! CHAR_HEAD_P (*q
) && q
> BEG_ADDR
) q
--;
2582 if (LEADING_CODE_P (*q
))
2584 ptrdiff_t new_gpt
= GPT_BYTE
- (GPT_ADDR
- q
);
2586 move_gap_both (new_gpt
, new_gpt
);
2590 /* Make the buffer contents valid as multibyte by converting
2591 8-bit characters to multibyte form. */
2609 if (ASCII_BYTE_P (*p
))
2611 else if (EQ (flag
, Qt
)
2612 && ! CHAR_BYTE8_HEAD_P (*p
)
2613 && (bytes
= MULTIBYTE_LENGTH (p
, pend
)) > 0)
2614 p
+= bytes
, pos
+= bytes
;
2617 unsigned char tmp
[MAX_MULTIBYTE_LENGTH
];
2620 c
= BYTE8_TO_CHAR (*p
);
2621 bytes
= CHAR_STRING (c
, tmp
);
2623 TEMP_SET_PT_BOTH (pos
+ 1, pos
+ 1);
2625 insert_1_both ((char *) tmp
+ 1, bytes
, bytes
, 1, 0, 0);
2626 /* Now the gap is after the just inserted data. */
2644 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2646 /* Do this first, so that chars_in_text asks the right question.
2647 set_intervals_multibyte needs it too. */
2648 bset_enable_multibyte_characters (current_buffer
, Qt
);
2650 GPT_BYTE
= advance_to_char_boundary (GPT_BYTE
);
2651 GPT
= chars_in_text (BEG_ADDR
, GPT_BYTE
- BEG_BYTE
) + BEG
;
2653 Z
= chars_in_text (GAP_END_ADDR
, Z_BYTE
- GPT_BYTE
) + GPT
;
2655 BEGV_BYTE
= advance_to_char_boundary (BEGV_BYTE
);
2656 if (BEGV_BYTE
> GPT_BYTE
)
2657 BEGV
= chars_in_text (GAP_END_ADDR
, BEGV_BYTE
- GPT_BYTE
) + GPT
;
2659 BEGV
= chars_in_text (BEG_ADDR
, BEGV_BYTE
- BEG_BYTE
) + BEG
;
2661 ZV_BYTE
= advance_to_char_boundary (ZV_BYTE
);
2662 if (ZV_BYTE
> GPT_BYTE
)
2663 ZV
= chars_in_text (GAP_END_ADDR
, ZV_BYTE
- GPT_BYTE
) + GPT
;
2665 ZV
= chars_in_text (BEG_ADDR
, ZV_BYTE
- BEG_BYTE
) + BEG
;
2668 ptrdiff_t byte
= advance_to_char_boundary (PT_BYTE
);
2671 if (byte
> GPT_BYTE
)
2672 position
= chars_in_text (GAP_END_ADDR
, byte
- GPT_BYTE
) + GPT
;
2674 position
= chars_in_text (BEG_ADDR
, byte
- BEG_BYTE
) + BEG
;
2675 TEMP_SET_PT_BOTH (position
, byte
);
2678 tail
= markers
= BUF_MARKERS (current_buffer
);
2680 /* This prevents BYTE_TO_CHAR (that is, buf_bytepos_to_charpos) from
2681 getting confused by the markers that have not yet been updated.
2682 It is also a signal that it should never create a marker. */
2683 BUF_MARKERS (current_buffer
) = NULL
;
2685 for (; tail
; tail
= tail
->next
)
2687 tail
->bytepos
= advance_to_char_boundary (tail
->bytepos
);
2688 tail
->charpos
= BYTE_TO_CHAR (tail
->bytepos
);
2691 /* Make sure no markers were put on the chain
2692 while the chain value was incorrect. */
2693 if (BUF_MARKERS (current_buffer
))
2696 BUF_MARKERS (current_buffer
) = markers
;
2698 /* Do this last, so it can calculate the new correspondences
2699 between chars and bytes. */
2700 set_intervals_multibyte (1);
2703 if (!EQ (old_undo
, Qt
))
2705 /* Represent all the above changes by a special undo entry. */
2706 bset_undo_list (current_buffer
,
2707 Fcons (list3 (Qapply
,
2708 intern ("set-buffer-multibyte"),
2709 NILP (flag
) ? Qt
: Qnil
),
2715 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2717 /* If buffer is shown in a window, let redisplay consider other windows. */
2718 if (buffer_window_count (current_buffer
))
2719 ++windows_or_buffers_changed
;
2721 /* Copy this buffer's new multibyte status
2722 into all of its indirect buffers. */
2723 FOR_EACH_BUFFER (other
)
2724 if (other
->base_buffer
== current_buffer
&& BUFFER_LIVE_P (other
))
2726 BVAR (other
, enable_multibyte_characters
)
2727 = BVAR (current_buffer
, enable_multibyte_characters
);
2728 other
->prevent_redisplay_optimizations_p
= 1;
2731 /* Restore the modifiedness of the buffer. */
2732 if (!modified_p
&& !NILP (Fbuffer_modified_p (Qnil
)))
2733 Fset_buffer_modified_p (Qnil
);
2735 /* Update coding systems of this buffer's process (if any). */
2737 Lisp_Object process
;
2739 process
= Fget_buffer_process (Fcurrent_buffer ());
2740 if (PROCESSP (process
))
2741 setup_process_coding_systems (process
);
2747 DEFUN ("kill-all-local-variables", Fkill_all_local_variables
,
2748 Skill_all_local_variables
, 0, 0, 0,
2749 doc
: /* Switch to Fundamental mode by killing current buffer's local variables.
2750 Most local variable bindings are eliminated so that the default values
2751 become effective once more. Also, the syntax table is set from
2752 `standard-syntax-table', the local keymap is set to nil,
2753 and the abbrev table from `fundamental-mode-abbrev-table'.
2754 This function also forces redisplay of the mode line.
2756 Every function to select a new major mode starts by
2757 calling this function.
2759 As a special exception, local variables whose names have
2760 a non-nil `permanent-local' property are not eliminated by this function.
2762 The first thing this function does is run
2763 the normal hook `change-major-mode-hook'. */)
2766 Frun_hooks (1, &Qchange_major_mode_hook
);
2768 /* Make sure none of the bindings in local_var_alist
2769 remain swapped in, in their symbols. */
2771 swap_out_buffer_local_variables (current_buffer
);
2773 /* Actually eliminate all local bindings of this buffer. */
2775 reset_buffer_local_variables (current_buffer
, 0);
2777 /* Force mode-line redisplay. Useful here because all major mode
2778 commands call this function. */
2779 update_mode_lines
++;
2784 /* Make sure no local variables remain set up with buffer B
2785 for their current values. */
2788 swap_out_buffer_local_variables (struct buffer
*b
)
2790 Lisp_Object oalist
, alist
, buffer
;
2792 XSETBUFFER (buffer
, b
);
2793 oalist
= BVAR (b
, local_var_alist
);
2795 for (alist
= oalist
; CONSP (alist
); alist
= XCDR (alist
))
2797 Lisp_Object sym
= XCAR (XCAR (alist
));
2798 eassert (XSYMBOL (sym
)->redirect
== SYMBOL_LOCALIZED
);
2799 /* Need not do anything if some other buffer's binding is
2801 if (EQ (SYMBOL_BLV (XSYMBOL (sym
))->where
, buffer
))
2803 /* Symbol is set up for this buffer's old local value:
2805 swap_in_global_binding (XSYMBOL (sym
));
2810 /* Find all the overlays in the current buffer that contain position POS.
2811 Return the number found, and store them in a vector in *VEC_PTR.
2812 Store in *LEN_PTR the size allocated for the vector.
2813 Store in *NEXT_PTR the next position after POS where an overlay starts,
2814 or ZV if there are no more overlays between POS and ZV.
2815 Store in *PREV_PTR the previous position before POS where an overlay ends,
2816 or where an overlay starts which ends at or after POS;
2817 or BEGV if there are no such overlays from BEGV to POS.
2818 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2820 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2821 when this function is called.
2823 If EXTEND, make the vector bigger if necessary.
2824 If not, never extend the vector,
2825 and store only as many overlays as will fit.
2826 But still return the total number of overlays.
2828 If CHANGE_REQ, any position written into *PREV_PTR or
2829 *NEXT_PTR is guaranteed to be not equal to POS, unless it is the
2830 default (BEGV or ZV). */
2833 overlays_at (EMACS_INT pos
, bool extend
, Lisp_Object
**vec_ptr
,
2835 ptrdiff_t *next_ptr
, ptrdiff_t *prev_ptr
, bool change_req
)
2837 Lisp_Object overlay
, start
, end
;
2838 struct Lisp_Overlay
*tail
;
2840 ptrdiff_t len
= *len_ptr
;
2841 Lisp_Object
*vec
= *vec_ptr
;
2842 ptrdiff_t next
= ZV
;
2843 ptrdiff_t prev
= BEGV
;
2844 bool inhibit_storing
= 0;
2846 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2848 ptrdiff_t startpos
, endpos
;
2850 XSETMISC (overlay
, tail
);
2852 start
= OVERLAY_START (overlay
);
2853 end
= OVERLAY_END (overlay
);
2854 endpos
= OVERLAY_POSITION (end
);
2861 startpos
= OVERLAY_POSITION (start
);
2862 /* This one ends at or after POS
2863 so its start counts for PREV_PTR if it's before POS. */
2864 if (prev
< startpos
&& startpos
< pos
)
2868 if (startpos
<= pos
)
2872 /* The supplied vector is full.
2873 Either make it bigger, or don't store any more in it. */
2876 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2882 inhibit_storing
= 1;
2885 if (!inhibit_storing
)
2887 /* Keep counting overlays even if we can't return them all. */
2890 else if (startpos
< next
)
2894 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2896 ptrdiff_t startpos
, endpos
;
2898 XSETMISC (overlay
, tail
);
2900 start
= OVERLAY_START (overlay
);
2901 end
= OVERLAY_END (overlay
);
2902 startpos
= OVERLAY_POSITION (start
);
2905 if (startpos
< next
)
2909 endpos
= OVERLAY_POSITION (end
);
2916 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2922 inhibit_storing
= 1;
2925 if (!inhibit_storing
)
2929 if (startpos
< pos
&& startpos
> prev
)
2932 else if (endpos
< pos
&& endpos
> prev
)
2934 else if (endpos
== pos
&& startpos
> prev
2935 && (!change_req
|| startpos
< pos
))
2946 /* Find all the overlays in the current buffer that overlap the range
2947 BEG-END, or are empty at BEG, or are empty at END provided END
2948 denotes the position at the end of the current buffer.
2950 Return the number found, and store them in a vector in *VEC_PTR.
2951 Store in *LEN_PTR the size allocated for the vector.
2952 Store in *NEXT_PTR the next position after POS where an overlay starts,
2953 or ZV if there are no more overlays.
2954 Store in *PREV_PTR the previous position before POS where an overlay ends,
2955 or BEGV if there are no previous overlays.
2956 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2958 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2959 when this function is called.
2961 If EXTEND, make the vector bigger if necessary.
2962 If not, never extend the vector,
2963 and store only as many overlays as will fit.
2964 But still return the total number of overlays. */
2967 overlays_in (EMACS_INT beg
, EMACS_INT end
, bool extend
,
2968 Lisp_Object
**vec_ptr
, ptrdiff_t *len_ptr
,
2969 ptrdiff_t *next_ptr
, ptrdiff_t *prev_ptr
)
2971 Lisp_Object overlay
, ostart
, oend
;
2972 struct Lisp_Overlay
*tail
;
2974 ptrdiff_t len
= *len_ptr
;
2975 Lisp_Object
*vec
= *vec_ptr
;
2976 ptrdiff_t next
= ZV
;
2977 ptrdiff_t prev
= BEGV
;
2978 bool inhibit_storing
= 0;
2979 bool end_is_Z
= end
== Z
;
2981 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2983 ptrdiff_t startpos
, endpos
;
2985 XSETMISC (overlay
, tail
);
2987 ostart
= OVERLAY_START (overlay
);
2988 oend
= OVERLAY_END (overlay
);
2989 endpos
= OVERLAY_POSITION (oend
);
2996 startpos
= OVERLAY_POSITION (ostart
);
2997 /* Count an interval if it overlaps the range, is empty at the
2998 start of the range, or is empty at END provided END denotes the
2999 end of the buffer. */
3000 if ((beg
< endpos
&& startpos
< end
)
3001 || (startpos
== endpos
3002 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
3006 /* The supplied vector is full.
3007 Either make it bigger, or don't store any more in it. */
3010 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
3016 inhibit_storing
= 1;
3019 if (!inhibit_storing
)
3021 /* Keep counting overlays even if we can't return them all. */
3024 else if (startpos
< next
)
3028 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
3030 ptrdiff_t startpos
, endpos
;
3032 XSETMISC (overlay
, tail
);
3034 ostart
= OVERLAY_START (overlay
);
3035 oend
= OVERLAY_END (overlay
);
3036 startpos
= OVERLAY_POSITION (ostart
);
3039 if (startpos
< next
)
3043 endpos
= OVERLAY_POSITION (oend
);
3044 /* Count an interval if it overlaps the range, is empty at the
3045 start of the range, or is empty at END provided END denotes the
3046 end of the buffer. */
3047 if ((beg
< endpos
&& startpos
< end
)
3048 || (startpos
== endpos
3049 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
3055 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
3061 inhibit_storing
= 1;
3064 if (!inhibit_storing
)
3068 else if (endpos
< beg
&& endpos
> prev
)
3080 /* Return true if there exists an overlay with a non-nil
3081 `mouse-face' property overlapping OVERLAY. */
3084 mouse_face_overlay_overlaps (Lisp_Object overlay
)
3086 ptrdiff_t start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3087 ptrdiff_t end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3088 ptrdiff_t n
, i
, size
;
3089 Lisp_Object
*v
, tem
;
3092 v
= alloca (size
* sizeof *v
);
3093 n
= overlays_in (start
, end
, 0, &v
, &size
, NULL
, NULL
);
3096 v
= alloca (n
* sizeof *v
);
3097 overlays_in (start
, end
, 0, &v
, &n
, NULL
, NULL
);
3100 for (i
= 0; i
< n
; ++i
)
3101 if (!EQ (v
[i
], overlay
)
3102 && (tem
= Foverlay_get (overlay
, Qmouse_face
),
3111 /* Fast function to just test if we're at an overlay boundary. */
3113 overlay_touches_p (ptrdiff_t pos
)
3115 Lisp_Object overlay
;
3116 struct Lisp_Overlay
*tail
;
3118 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
3122 XSETMISC (overlay
,tail
);
3123 eassert (OVERLAYP (overlay
));
3125 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3128 if (endpos
== pos
|| OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
)
3132 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
3136 XSETMISC (overlay
, tail
);
3137 eassert (OVERLAYP (overlay
));
3139 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3142 if (startpos
== pos
|| OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
)
3150 Lisp_Object overlay
;
3156 compare_overlays (const void *v1
, const void *v2
)
3158 const struct sortvec
*s1
= v1
;
3159 const struct sortvec
*s2
= v2
;
3160 if (s1
->priority
!= s2
->priority
)
3161 return s1
->priority
< s2
->priority
? -1 : 1;
3162 if (s1
->beg
!= s2
->beg
)
3163 return s1
->beg
< s2
->beg
? -1 : 1;
3164 if (s1
->end
!= s2
->end
)
3165 return s2
->end
< s1
->end
? -1 : 1;
3166 /* Avoid the non-determinism of qsort by choosing an arbitrary ordering
3167 between "equal" overlays. The result can still change between
3168 invocations of Emacs, but it won't change in the middle of
3169 `find_field' (bug#6830). */
3170 if (!EQ (s1
->overlay
, s2
->overlay
))
3171 return XLI (s1
->overlay
) < XLI (s2
->overlay
) ? -1 : 1;
3175 /* Sort an array of overlays by priority. The array is modified in place.
3176 The return value is the new size; this may be smaller than the original
3177 size if some of the overlays were invalid or were window-specific. */
3179 sort_overlays (Lisp_Object
*overlay_vec
, ptrdiff_t noverlays
, struct window
*w
)
3183 struct sortvec
*sortvec
;
3185 SAFE_NALLOCA (sortvec
, 1, noverlays
);
3187 /* Put the valid and relevant overlays into sortvec. */
3189 for (i
= 0, j
= 0; i
< noverlays
; i
++)
3192 Lisp_Object overlay
;
3194 overlay
= overlay_vec
[i
];
3195 if (OVERLAYP (overlay
)
3196 && OVERLAY_POSITION (OVERLAY_START (overlay
)) > 0
3197 && OVERLAY_POSITION (OVERLAY_END (overlay
)) > 0)
3199 /* If we're interested in a specific window, then ignore
3200 overlays that are limited to some other window. */
3205 window
= Foverlay_get (overlay
, Qwindow
);
3206 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3210 /* This overlay is good and counts: put it into sortvec. */
3211 sortvec
[j
].overlay
= overlay
;
3212 sortvec
[j
].beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3213 sortvec
[j
].end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3214 tem
= Foverlay_get (overlay
, Qpriority
);
3216 sortvec
[j
].priority
= XINT (tem
);
3218 sortvec
[j
].priority
= 0;
3224 /* Sort the overlays into the proper order: increasing priority. */
3227 qsort (sortvec
, noverlays
, sizeof (struct sortvec
), compare_overlays
);
3229 for (i
= 0; i
< noverlays
; i
++)
3230 overlay_vec
[i
] = sortvec
[i
].overlay
;
3238 Lisp_Object string
, string2
;
3245 struct sortstr
*buf
; /* An array that expands as needed; never freed. */
3246 ptrdiff_t size
; /* Allocated length of that array. */
3247 ptrdiff_t used
; /* How much of the array is currently in use. */
3248 ptrdiff_t bytes
; /* Total length of the strings in buf. */
3251 /* Buffers for storing information about the overlays touching a given
3252 position. These could be automatic variables in overlay_strings, but
3253 it's more efficient to hold onto the memory instead of repeatedly
3254 allocating and freeing it. */
3255 static struct sortstrlist overlay_heads
, overlay_tails
;
3256 static unsigned char *overlay_str_buf
;
3258 /* Allocated length of overlay_str_buf. */
3259 static ptrdiff_t overlay_str_len
;
3261 /* A comparison function suitable for passing to qsort. */
3263 cmp_for_strings (const void *as1
, const void *as2
)
3265 struct sortstr
const *s1
= as1
;
3266 struct sortstr
const *s2
= as2
;
3267 if (s1
->size
!= s2
->size
)
3268 return s2
->size
< s1
->size
? -1 : 1;
3269 if (s1
->priority
!= s2
->priority
)
3270 return s1
->priority
< s2
->priority
? -1 : 1;
3275 record_overlay_string (struct sortstrlist
*ssl
, Lisp_Object str
,
3276 Lisp_Object str2
, Lisp_Object pri
, ptrdiff_t size
)
3280 if (ssl
->used
== ssl
->size
)
3281 ssl
->buf
= xpalloc (ssl
->buf
, &ssl
->size
, 5, -1, sizeof *ssl
->buf
);
3282 ssl
->buf
[ssl
->used
].string
= str
;
3283 ssl
->buf
[ssl
->used
].string2
= str2
;
3284 ssl
->buf
[ssl
->used
].size
= size
;
3285 ssl
->buf
[ssl
->used
].priority
= (INTEGERP (pri
) ? XINT (pri
) : 0);
3288 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3289 nbytes
= SCHARS (str
);
3290 else if (! STRING_MULTIBYTE (str
))
3291 nbytes
= count_size_as_multibyte (SDATA (str
),
3294 nbytes
= SBYTES (str
);
3296 if (INT_ADD_OVERFLOW (ssl
->bytes
, nbytes
))
3297 memory_full (SIZE_MAX
);
3298 ssl
->bytes
+= nbytes
;
3302 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3303 nbytes
= SCHARS (str2
);
3304 else if (! STRING_MULTIBYTE (str2
))
3305 nbytes
= count_size_as_multibyte (SDATA (str2
),
3308 nbytes
= SBYTES (str2
);
3310 if (INT_ADD_OVERFLOW (ssl
->bytes
, nbytes
))
3311 memory_full (SIZE_MAX
);
3312 ssl
->bytes
+= nbytes
;
3316 /* Return the concatenation of the strings associated with overlays that
3317 begin or end at POS, ignoring overlays that are specific to a window
3318 other than W. The strings are concatenated in the appropriate order:
3319 shorter overlays nest inside longer ones, and higher priority inside
3320 lower. Normally all of the after-strings come first, but zero-sized
3321 overlays have their after-strings ride along with the before-strings
3322 because it would look strange to print them inside-out.
3324 Returns the string length, and stores the contents indirectly through
3325 PSTR, if that variable is non-null. The string may be overwritten by
3326 subsequent calls. */
3329 overlay_strings (ptrdiff_t pos
, struct window
*w
, unsigned char **pstr
)
3331 Lisp_Object overlay
, window
, str
;
3332 struct Lisp_Overlay
*ov
;
3333 ptrdiff_t startpos
, endpos
;
3334 bool multibyte
= ! NILP (BVAR (current_buffer
, enable_multibyte_characters
));
3336 overlay_heads
.used
= overlay_heads
.bytes
= 0;
3337 overlay_tails
.used
= overlay_tails
.bytes
= 0;
3338 for (ov
= current_buffer
->overlays_before
; ov
; ov
= ov
->next
)
3340 XSETMISC (overlay
, ov
);
3341 eassert (OVERLAYP (overlay
));
3343 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3344 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3347 if (endpos
!= pos
&& startpos
!= pos
)
3349 window
= Foverlay_get (overlay
, Qwindow
);
3350 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3353 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3354 record_overlay_string (&overlay_heads
, str
,
3356 ? Foverlay_get (overlay
, Qafter_string
)
3358 Foverlay_get (overlay
, Qpriority
),
3360 else if (endpos
== pos
3361 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3362 record_overlay_string (&overlay_tails
, str
, Qnil
,
3363 Foverlay_get (overlay
, Qpriority
),
3366 for (ov
= current_buffer
->overlays_after
; ov
; ov
= ov
->next
)
3368 XSETMISC (overlay
, ov
);
3369 eassert (OVERLAYP (overlay
));
3371 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3372 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3375 if (endpos
!= pos
&& startpos
!= pos
)
3377 window
= Foverlay_get (overlay
, Qwindow
);
3378 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3381 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3382 record_overlay_string (&overlay_heads
, str
,
3384 ? Foverlay_get (overlay
, Qafter_string
)
3386 Foverlay_get (overlay
, Qpriority
),
3388 else if (endpos
== pos
3389 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3390 record_overlay_string (&overlay_tails
, str
, Qnil
,
3391 Foverlay_get (overlay
, Qpriority
),
3394 if (overlay_tails
.used
> 1)
3395 qsort (overlay_tails
.buf
, overlay_tails
.used
, sizeof (struct sortstr
),
3397 if (overlay_heads
.used
> 1)
3398 qsort (overlay_heads
.buf
, overlay_heads
.used
, sizeof (struct sortstr
),
3400 if (overlay_heads
.bytes
|| overlay_tails
.bytes
)
3407 if (INT_ADD_OVERFLOW (overlay_heads
.bytes
, overlay_tails
.bytes
))
3408 memory_full (SIZE_MAX
);
3409 total
= overlay_heads
.bytes
+ overlay_tails
.bytes
;
3410 if (total
> overlay_str_len
)
3411 overlay_str_buf
= xpalloc (overlay_str_buf
, &overlay_str_len
,
3412 total
- overlay_str_len
, -1, 1);
3414 p
= overlay_str_buf
;
3415 for (i
= overlay_tails
.used
; --i
>= 0;)
3418 tem
= overlay_tails
.buf
[i
].string
;
3419 nbytes
= copy_text (SDATA (tem
), p
,
3421 STRING_MULTIBYTE (tem
), multibyte
);
3424 for (i
= 0; i
< overlay_heads
.used
; ++i
)
3427 tem
= overlay_heads
.buf
[i
].string
;
3428 nbytes
= copy_text (SDATA (tem
), p
,
3430 STRING_MULTIBYTE (tem
), multibyte
);
3432 tem
= overlay_heads
.buf
[i
].string2
;
3435 nbytes
= copy_text (SDATA (tem
), p
,
3437 STRING_MULTIBYTE (tem
), multibyte
);
3441 if (p
!= overlay_str_buf
+ total
)
3444 *pstr
= overlay_str_buf
;
3450 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
3453 recenter_overlay_lists (struct buffer
*buf
, ptrdiff_t pos
)
3455 Lisp_Object overlay
, beg
, end
;
3456 struct Lisp_Overlay
*prev
, *tail
, *next
;
3458 /* See if anything in overlays_before should move to overlays_after. */
3460 /* We don't strictly need prev in this loop; it should always be nil.
3461 But we use it for symmetry and in case that should cease to be true
3462 with some future change. */
3464 for (tail
= buf
->overlays_before
; tail
; prev
= tail
, tail
= next
)
3467 XSETMISC (overlay
, tail
);
3468 eassert (OVERLAYP (overlay
));
3470 beg
= OVERLAY_START (overlay
);
3471 end
= OVERLAY_END (overlay
);
3473 if (OVERLAY_POSITION (end
) > pos
)
3475 /* OVERLAY needs to be moved. */
3476 ptrdiff_t where
= OVERLAY_POSITION (beg
);
3477 struct Lisp_Overlay
*other
, *other_prev
;
3479 /* Splice the cons cell TAIL out of overlays_before. */
3483 set_buffer_overlays_before (buf
, next
);
3485 /* Search thru overlays_after for where to put it. */
3487 for (other
= buf
->overlays_after
; other
;
3488 other_prev
= other
, other
= other
->next
)
3490 Lisp_Object otherbeg
, otheroverlay
;
3492 XSETMISC (otheroverlay
, other
);
3493 eassert (OVERLAYP (otheroverlay
));
3495 otherbeg
= OVERLAY_START (otheroverlay
);
3496 if (OVERLAY_POSITION (otherbeg
) >= where
)
3500 /* Add TAIL to overlays_after before OTHER. */
3503 other_prev
->next
= tail
;
3505 set_buffer_overlays_after (buf
, tail
);
3509 /* We've reached the things that should stay in overlays_before.
3510 All the rest of overlays_before must end even earlier,
3515 /* See if anything in overlays_after should be in overlays_before. */
3517 for (tail
= buf
->overlays_after
; tail
; prev
= tail
, tail
= next
)
3520 XSETMISC (overlay
, tail
);
3521 eassert (OVERLAYP (overlay
));
3523 beg
= OVERLAY_START (overlay
);
3524 end
= OVERLAY_END (overlay
);
3526 /* Stop looking, when we know that nothing further
3527 can possibly end before POS. */
3528 if (OVERLAY_POSITION (beg
) > pos
)
3531 if (OVERLAY_POSITION (end
) <= pos
)
3533 /* OVERLAY needs to be moved. */
3534 ptrdiff_t where
= OVERLAY_POSITION (end
);
3535 struct Lisp_Overlay
*other
, *other_prev
;
3537 /* Splice the cons cell TAIL out of overlays_after. */
3541 set_buffer_overlays_after (buf
, next
);
3543 /* Search thru overlays_before for where to put it. */
3545 for (other
= buf
->overlays_before
; other
;
3546 other_prev
= other
, other
= other
->next
)
3548 Lisp_Object otherend
, otheroverlay
;
3550 XSETMISC (otheroverlay
, other
);
3551 eassert (OVERLAYP (otheroverlay
));
3553 otherend
= OVERLAY_END (otheroverlay
);
3554 if (OVERLAY_POSITION (otherend
) <= where
)
3558 /* Add TAIL to overlays_before before OTHER. */
3561 other_prev
->next
= tail
;
3563 set_buffer_overlays_before (buf
, tail
);
3568 buf
->overlay_center
= pos
;
3572 adjust_overlays_for_insert (ptrdiff_t pos
, ptrdiff_t length
)
3574 /* After an insertion, the lists are still sorted properly,
3575 but we may need to update the value of the overlay center. */
3576 if (current_buffer
->overlay_center
>= pos
)
3577 current_buffer
->overlay_center
+= length
;
3581 adjust_overlays_for_delete (ptrdiff_t pos
, ptrdiff_t length
)
3583 if (current_buffer
->overlay_center
< pos
)
3584 /* The deletion was to our right. No change needed; the before- and
3585 after-lists are still consistent. */
3587 else if (current_buffer
->overlay_center
- pos
> length
)
3588 /* The deletion was to our left. We need to adjust the center value
3589 to account for the change in position, but the lists are consistent
3590 given the new value. */
3591 current_buffer
->overlay_center
-= length
;
3593 /* We're right in the middle. There might be things on the after-list
3594 that now belong on the before-list. Recentering will move them,
3595 and also update the center point. */
3596 recenter_overlay_lists (current_buffer
, pos
);
3599 /* Fix up overlays that were garbled as a result of permuting markers
3600 in the range START through END. Any overlay with at least one
3601 endpoint in this range will need to be unlinked from the overlay
3602 list and reinserted in its proper place.
3603 Such an overlay might even have negative size at this point.
3604 If so, we'll make the overlay empty. */
3606 fix_start_end_in_overlays (register ptrdiff_t start
, register ptrdiff_t end
)
3608 Lisp_Object overlay
;
3609 struct Lisp_Overlay
*before_list
IF_LINT (= NULL
);
3610 struct Lisp_Overlay
*after_list
IF_LINT (= NULL
);
3611 /* These are either nil, indicating that before_list or after_list
3612 should be assigned, or the cons cell the cdr of which should be
3614 struct Lisp_Overlay
*beforep
= NULL
, *afterp
= NULL
;
3615 /* 'Parent', likewise, indicates a cons cell or
3616 current_buffer->overlays_before or overlays_after, depending
3617 which loop we're in. */
3618 struct Lisp_Overlay
*tail
, *parent
;
3619 ptrdiff_t startpos
, endpos
;
3621 /* This algorithm shifts links around instead of consing and GCing.
3622 The loop invariant is that before_list (resp. after_list) is a
3623 well-formed list except that its last element, the CDR of beforep
3624 (resp. afterp) if beforep (afterp) isn't nil or before_list
3625 (after_list) if it is, is still uninitialized. So it's not a bug
3626 that before_list isn't initialized, although it may look
3628 for (parent
= NULL
, tail
= current_buffer
->overlays_before
; tail
;)
3630 XSETMISC (overlay
, tail
);
3632 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3633 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3635 /* If the overlay is backwards, make it empty. */
3636 if (endpos
< startpos
)
3639 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3647 || (startpos
>= start
&& startpos
< end
))
3649 /* Add it to the end of the wrong list. Later on,
3650 recenter_overlay_lists will move it to the right place. */
3651 if (endpos
< current_buffer
->overlay_center
)
3656 afterp
->next
= tail
;
3664 beforep
->next
= tail
;
3668 set_buffer_overlays_before (current_buffer
, tail
->next
);
3670 parent
->next
= tail
->next
;
3674 parent
= tail
, tail
= parent
->next
;
3676 for (parent
= NULL
, tail
= current_buffer
->overlays_after
; tail
;)
3678 XSETMISC (overlay
, tail
);
3680 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3681 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3683 /* If the overlay is backwards, make it empty. */
3684 if (endpos
< startpos
)
3687 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3691 if (startpos
>= end
)
3694 if (startpos
>= start
3695 || (endpos
>= start
&& endpos
< end
))
3697 if (endpos
< current_buffer
->overlay_center
)
3702 afterp
->next
= tail
;
3710 beforep
->next
= tail
;
3714 set_buffer_overlays_after (current_buffer
, tail
->next
);
3716 parent
->next
= tail
->next
;
3720 parent
= tail
, tail
= parent
->next
;
3723 /* Splice the constructed (wrong) lists into the buffer's lists,
3724 and let the recenter function make it sane again. */
3727 beforep
->next
= current_buffer
->overlays_before
;
3728 set_buffer_overlays_before (current_buffer
, before_list
);
3733 afterp
->next
= current_buffer
->overlays_after
;
3734 set_buffer_overlays_after (current_buffer
, after_list
);
3736 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3739 /* We have two types of overlay: the one whose ending marker is
3740 after-insertion-marker (this is the usual case) and the one whose
3741 ending marker is before-insertion-marker. When `overlays_before'
3742 contains overlays of the latter type and the former type in this
3743 order and both overlays end at inserting position, inserting a text
3744 increases only the ending marker of the latter type, which results
3745 in incorrect ordering of `overlays_before'.
3747 This function fixes ordering of overlays in the slot
3748 `overlays_before' of the buffer *BP. Before the insertion, `point'
3749 was at PREV, and now is at POS. */
3752 fix_overlays_before (struct buffer
*bp
, ptrdiff_t prev
, ptrdiff_t pos
)
3754 /* If parent is nil, replace overlays_before; otherwise, parent->next. */
3755 struct Lisp_Overlay
*tail
= bp
->overlays_before
, *parent
= NULL
, *right_pair
;
3757 ptrdiff_t end
IF_LINT (= 0);
3759 /* After the insertion, the several overlays may be in incorrect
3760 order. The possibility is that, in the list `overlays_before',
3761 an overlay which ends at POS appears after an overlay which ends
3762 at PREV. Since POS is greater than PREV, we must fix the
3763 ordering of these overlays, by moving overlays ends at POS before
3764 the overlays ends at PREV. */
3766 /* At first, find a place where disordered overlays should be linked
3767 in. It is where an overlay which end before POS exists. (i.e. an
3768 overlay whose ending marker is after-insertion-marker if disorder
3771 && (XSETMISC (tem
, tail
),
3772 (end
= OVERLAY_POSITION (OVERLAY_END (tem
))) >= pos
))
3778 /* If we don't find such an overlay,
3779 or the found one ends before PREV,
3780 or the found one is the last one in the list,
3781 we don't have to fix anything. */
3782 if (!tail
|| end
< prev
|| !tail
->next
)
3785 right_pair
= parent
;
3789 /* Now, end position of overlays in the list TAIL should be before
3790 or equal to PREV. In the loop, an overlay which ends at POS is
3791 moved ahead to the place indicated by the CDR of RIGHT_PAIR. If
3792 we found an overlay which ends before PREV, the remaining
3793 overlays are in correct order. */
3796 XSETMISC (tem
, tail
);
3797 end
= OVERLAY_POSITION (OVERLAY_END (tem
));
3800 { /* This overlay is disordered. */
3801 struct Lisp_Overlay
*found
= tail
;
3803 /* Unlink the found overlay. */
3805 parent
->next
= tail
;
3806 /* Move an overlay at RIGHT_PLACE to the next of the found one,
3807 and link it into the right place. */
3810 found
->next
= bp
->overlays_before
;
3811 set_buffer_overlays_before (bp
, found
);
3815 found
->next
= right_pair
->next
;
3816 right_pair
->next
= found
;
3819 else if (end
== prev
)
3824 else /* No more disordered overlay. */
3829 DEFUN ("overlayp", Foverlayp
, Soverlayp
, 1, 1, 0,
3830 doc
: /* Return t if OBJECT is an overlay. */)
3831 (Lisp_Object object
)
3833 return (OVERLAYP (object
) ? Qt
: Qnil
);
3836 DEFUN ("make-overlay", Fmake_overlay
, Smake_overlay
, 2, 5, 0,
3837 doc
: /* Create a new overlay with range BEG to END in BUFFER.
3838 If omitted, BUFFER defaults to the current buffer.
3839 BEG and END may be integers or markers.
3840 The fourth arg FRONT-ADVANCE, if non-nil, makes the marker
3841 for the front of the overlay advance when text is inserted there
3842 \(which means the text *is not* included in the overlay).
3843 The fifth arg REAR-ADVANCE, if non-nil, makes the marker
3844 for the rear of the overlay advance when text is inserted there
3845 \(which means the text *is* included in the overlay). */)
3846 (Lisp_Object beg
, Lisp_Object end
, Lisp_Object buffer
, Lisp_Object front_advance
, Lisp_Object rear_advance
)
3848 Lisp_Object overlay
;
3852 XSETBUFFER (buffer
, current_buffer
);
3854 CHECK_BUFFER (buffer
);
3856 && ! EQ (Fmarker_buffer (beg
), buffer
))
3857 error ("Marker points into wrong buffer");
3859 && ! EQ (Fmarker_buffer (end
), buffer
))
3860 error ("Marker points into wrong buffer");
3862 CHECK_NUMBER_COERCE_MARKER (beg
);
3863 CHECK_NUMBER_COERCE_MARKER (end
);
3865 if (XINT (beg
) > XINT (end
))
3868 temp
= beg
; beg
= end
; end
= temp
;
3871 b
= XBUFFER (buffer
);
3873 beg
= Fset_marker (Fmake_marker (), beg
, buffer
);
3874 end
= Fset_marker (Fmake_marker (), end
, buffer
);
3876 if (!NILP (front_advance
))
3877 XMARKER (beg
)->insertion_type
= 1;
3878 if (!NILP (rear_advance
))
3879 XMARKER (end
)->insertion_type
= 1;
3881 overlay
= build_overlay (beg
, end
, Qnil
);
3883 /* Put the new overlay on the wrong list. */
3884 end
= OVERLAY_END (overlay
);
3885 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
3887 eassert (b
->overlays_after
|| (XOVERLAY (overlay
)->next
== NULL
));
3888 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3889 set_buffer_overlays_after (b
, XOVERLAY (overlay
));
3893 eassert (b
->overlays_before
|| (XOVERLAY (overlay
)->next
== NULL
));
3894 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3895 set_buffer_overlays_before (b
, XOVERLAY (overlay
));
3897 /* This puts it in the right list, and in the right order. */
3898 recenter_overlay_lists (b
, b
->overlay_center
);
3900 /* We don't need to redisplay the region covered by the overlay, because
3901 the overlay has no properties at the moment. */
3906 /* Mark a section of BUF as needing redisplay because of overlays changes. */
3909 modify_overlay (struct buffer
*buf
, ptrdiff_t start
, ptrdiff_t end
)
3913 ptrdiff_t temp
= start
;
3918 BUF_COMPUTE_UNCHANGED (buf
, start
, end
);
3920 /* If BUF is visible, consider updating the display if ... */
3921 if (buffer_window_count (buf
) > 0)
3923 /* ... it's visible in other window than selected, */
3924 if (buf
!= XBUFFER (XWINDOW (selected_window
)->contents
))
3925 windows_or_buffers_changed
= 1;
3926 /* ... or if we modify an overlay at the end of the buffer
3927 and so we cannot be sure that window end is still valid. */
3928 else if (end
>= ZV
&& start
<= ZV
)
3929 windows_or_buffers_changed
= 1;
3932 ++BUF_OVERLAY_MODIFF (buf
);
3935 /* Remove OVERLAY from LIST. */
3937 static struct Lisp_Overlay
*
3938 unchain_overlay (struct Lisp_Overlay
*list
, struct Lisp_Overlay
*overlay
)
3940 register struct Lisp_Overlay
*tail
, **prev
= &list
;
3942 for (tail
= list
; tail
; prev
= &tail
->next
, tail
= *prev
)
3943 if (tail
== overlay
)
3945 *prev
= overlay
->next
;
3946 overlay
->next
= NULL
;
3952 /* Remove OVERLAY from both overlay lists of B. */
3955 unchain_both (struct buffer
*b
, Lisp_Object overlay
)
3957 struct Lisp_Overlay
*ov
= XOVERLAY (overlay
);
3959 set_buffer_overlays_before (b
, unchain_overlay (b
->overlays_before
, ov
));
3960 set_buffer_overlays_after (b
, unchain_overlay (b
->overlays_after
, ov
));
3961 eassert (XOVERLAY (overlay
)->next
== NULL
);
3964 DEFUN ("move-overlay", Fmove_overlay
, Smove_overlay
, 3, 4, 0,
3965 doc
: /* Set the endpoints of OVERLAY to BEG and END in BUFFER.
3966 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.
3967 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current
3969 (Lisp_Object overlay
, Lisp_Object beg
, Lisp_Object end
, Lisp_Object buffer
)
3971 struct buffer
*b
, *ob
= 0;
3972 Lisp_Object obuffer
;
3973 ptrdiff_t count
= SPECPDL_INDEX ();
3974 ptrdiff_t n_beg
, n_end
, o_beg
IF_LINT (= 0), o_end
IF_LINT (= 0);
3976 CHECK_OVERLAY (overlay
);
3978 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3980 XSETBUFFER (buffer
, current_buffer
);
3981 CHECK_BUFFER (buffer
);
3983 if (NILP (Fbuffer_live_p (buffer
)))
3984 error ("Attempt to move overlay to a dead buffer");
3987 && ! EQ (Fmarker_buffer (beg
), buffer
))
3988 error ("Marker points into wrong buffer");
3990 && ! EQ (Fmarker_buffer (end
), buffer
))
3991 error ("Marker points into wrong buffer");
3993 CHECK_NUMBER_COERCE_MARKER (beg
);
3994 CHECK_NUMBER_COERCE_MARKER (end
);
3996 if (XINT (beg
) > XINT (end
))
3999 temp
= beg
; beg
= end
; end
= temp
;
4002 specbind (Qinhibit_quit
, Qt
);
4004 obuffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4005 b
= XBUFFER (buffer
);
4007 if (!NILP (obuffer
))
4009 ob
= XBUFFER (obuffer
);
4011 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4012 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4014 unchain_both (ob
, overlay
);
4017 /* Set the overlay boundaries, which may clip them. */
4018 Fset_marker (OVERLAY_START (overlay
), beg
, buffer
);
4019 Fset_marker (OVERLAY_END (overlay
), end
, buffer
);
4021 n_beg
= marker_position (OVERLAY_START (overlay
));
4022 n_end
= marker_position (OVERLAY_END (overlay
));
4024 /* If the overlay has changed buffers, do a thorough redisplay. */
4025 if (!EQ (buffer
, obuffer
))
4027 /* Redisplay where the overlay was. */
4029 modify_overlay (ob
, o_beg
, o_end
);
4031 /* Redisplay where the overlay is going to be. */
4032 modify_overlay (b
, n_beg
, n_end
);
4035 /* Redisplay the area the overlay has just left, or just enclosed. */
4038 modify_overlay (b
, o_end
, n_end
);
4039 else if (o_end
== n_end
)
4040 modify_overlay (b
, o_beg
, n_beg
);
4042 modify_overlay (b
, min (o_beg
, n_beg
), max (o_end
, n_end
));
4045 /* Delete the overlay if it is empty after clipping and has the
4046 evaporate property. */
4047 if (n_beg
== n_end
&& !NILP (Foverlay_get (overlay
, Qevaporate
)))
4048 return unbind_to (count
, Fdelete_overlay (overlay
));
4050 /* Put the overlay into the new buffer's overlay lists, first on the
4052 if (n_end
< b
->overlay_center
)
4054 XOVERLAY (overlay
)->next
= b
->overlays_after
;
4055 set_buffer_overlays_after (b
, XOVERLAY (overlay
));
4059 XOVERLAY (overlay
)->next
= b
->overlays_before
;
4060 set_buffer_overlays_before (b
, XOVERLAY (overlay
));
4063 /* This puts it in the right list, and in the right order. */
4064 recenter_overlay_lists (b
, b
->overlay_center
);
4066 return unbind_to (count
, overlay
);
4069 DEFUN ("delete-overlay", Fdelete_overlay
, Sdelete_overlay
, 1, 1, 0,
4070 doc
: /* Delete the overlay OVERLAY from its buffer. */)
4071 (Lisp_Object overlay
)
4075 ptrdiff_t count
= SPECPDL_INDEX ();
4077 CHECK_OVERLAY (overlay
);
4079 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4083 b
= XBUFFER (buffer
);
4084 specbind (Qinhibit_quit
, Qt
);
4086 unchain_both (b
, overlay
);
4087 drop_overlay (b
, XOVERLAY (overlay
));
4089 /* When deleting an overlay with before or after strings, turn off
4090 display optimizations for the affected buffer, on the basis that
4091 these strings may contain newlines. This is easier to do than to
4092 check for that situation during redisplay. */
4093 if (!windows_or_buffers_changed
4094 && (!NILP (Foverlay_get (overlay
, Qbefore_string
))
4095 || !NILP (Foverlay_get (overlay
, Qafter_string
))))
4096 b
->prevent_redisplay_optimizations_p
= 1;
4098 return unbind_to (count
, Qnil
);
4101 DEFUN ("delete-all-overlays", Fdelete_all_overlays
, Sdelete_all_overlays
, 0, 1, 0,
4102 doc
: /* Delete all overlays of BUFFER.
4103 BUFFER omitted or nil means delete all overlays of the current
4105 (Lisp_Object buffer
)
4107 register struct buffer
*buf
;
4110 buf
= current_buffer
;
4113 CHECK_BUFFER (buffer
);
4114 buf
= XBUFFER (buffer
);
4117 delete_all_overlays (buf
);
4121 /* Overlay dissection functions. */
4123 DEFUN ("overlay-start", Foverlay_start
, Soverlay_start
, 1, 1, 0,
4124 doc
: /* Return the position at which OVERLAY starts. */)
4125 (Lisp_Object overlay
)
4127 CHECK_OVERLAY (overlay
);
4129 return (Fmarker_position (OVERLAY_START (overlay
)));
4132 DEFUN ("overlay-end", Foverlay_end
, Soverlay_end
, 1, 1, 0,
4133 doc
: /* Return the position at which OVERLAY ends. */)
4134 (Lisp_Object overlay
)
4136 CHECK_OVERLAY (overlay
);
4138 return (Fmarker_position (OVERLAY_END (overlay
)));
4141 DEFUN ("overlay-buffer", Foverlay_buffer
, Soverlay_buffer
, 1, 1, 0,
4142 doc
: /* Return the buffer OVERLAY belongs to.
4143 Return nil if OVERLAY has been deleted. */)
4144 (Lisp_Object overlay
)
4146 CHECK_OVERLAY (overlay
);
4148 return Fmarker_buffer (OVERLAY_START (overlay
));
4151 DEFUN ("overlay-properties", Foverlay_properties
, Soverlay_properties
, 1, 1, 0,
4152 doc
: /* Return a list of the properties on OVERLAY.
4153 This is a copy of OVERLAY's plist; modifying its conses has no effect on
4155 (Lisp_Object overlay
)
4157 CHECK_OVERLAY (overlay
);
4159 return Fcopy_sequence (XOVERLAY (overlay
)->plist
);
4163 DEFUN ("overlays-at", Foverlays_at
, Soverlays_at
, 1, 1, 0,
4164 doc
: /* Return a list of the overlays that contain the character at POS. */)
4167 ptrdiff_t len
, noverlays
;
4168 Lisp_Object
*overlay_vec
;
4171 CHECK_NUMBER_COERCE_MARKER (pos
);
4174 /* We can't use alloca here because overlays_at can call xrealloc. */
4175 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4177 /* Put all the overlays we want in a vector in overlay_vec.
4178 Store the length in len. */
4179 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4182 /* Make a list of them all. */
4183 result
= Flist (noverlays
, overlay_vec
);
4185 xfree (overlay_vec
);
4189 DEFUN ("overlays-in", Foverlays_in
, Soverlays_in
, 2, 2, 0,
4190 doc
: /* Return a list of the overlays that overlap the region BEG ... END.
4191 Overlap means that at least one character is contained within the overlay
4192 and also contained within the specified region.
4193 Empty overlays are included in the result if they are located at BEG,
4194 between BEG and END, or at END provided END denotes the position at the
4195 end of the buffer. */)
4196 (Lisp_Object beg
, Lisp_Object end
)
4198 ptrdiff_t len
, noverlays
;
4199 Lisp_Object
*overlay_vec
;
4202 CHECK_NUMBER_COERCE_MARKER (beg
);
4203 CHECK_NUMBER_COERCE_MARKER (end
);
4206 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4208 /* Put all the overlays we want in a vector in overlay_vec.
4209 Store the length in len. */
4210 noverlays
= overlays_in (XINT (beg
), XINT (end
), 1, &overlay_vec
, &len
,
4213 /* Make a list of them all. */
4214 result
= Flist (noverlays
, overlay_vec
);
4216 xfree (overlay_vec
);
4220 DEFUN ("next-overlay-change", Fnext_overlay_change
, Snext_overlay_change
,
4222 doc
: /* Return the next position after POS where an overlay starts or ends.
4223 If there are no overlay boundaries from POS to (point-max),
4224 the value is (point-max). */)
4227 ptrdiff_t i
, len
, noverlays
;
4229 Lisp_Object
*overlay_vec
;
4231 CHECK_NUMBER_COERCE_MARKER (pos
);
4234 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4236 /* Put all the overlays we want in a vector in overlay_vec.
4237 Store the length in len.
4238 endpos gets the position where the next overlay starts. */
4239 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4242 /* If any of these overlays ends before endpos,
4243 use its ending point instead. */
4244 for (i
= 0; i
< noverlays
; i
++)
4249 oend
= OVERLAY_END (overlay_vec
[i
]);
4250 oendpos
= OVERLAY_POSITION (oend
);
4251 if (oendpos
< endpos
)
4255 xfree (overlay_vec
);
4256 return make_number (endpos
);
4259 DEFUN ("previous-overlay-change", Fprevious_overlay_change
,
4260 Sprevious_overlay_change
, 1, 1, 0,
4261 doc
: /* Return the previous position before POS where an overlay starts or ends.
4262 If there are no overlay boundaries from (point-min) to POS,
4263 the value is (point-min). */)
4267 Lisp_Object
*overlay_vec
;
4270 CHECK_NUMBER_COERCE_MARKER (pos
);
4272 /* At beginning of buffer, we know the answer;
4273 avoid bug subtracting 1 below. */
4274 if (XINT (pos
) == BEGV
)
4278 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4280 /* Put all the overlays we want in a vector in overlay_vec.
4281 Store the length in len.
4282 prevpos gets the position of the previous change. */
4283 overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4286 xfree (overlay_vec
);
4287 return make_number (prevpos
);
4290 /* These functions are for debugging overlays. */
4292 DEFUN ("overlay-lists", Foverlay_lists
, Soverlay_lists
, 0, 0, 0,
4293 doc
: /* Return a pair of lists giving all the overlays of the current buffer.
4294 The car has all the overlays before the overlay center;
4295 the cdr has all the overlays after the overlay center.
4296 Recentering overlays moves overlays between these lists.
4297 The lists you get are copies, so that changing them has no effect.
4298 However, the overlays you get are the real objects that the buffer uses. */)
4301 struct Lisp_Overlay
*ol
;
4302 Lisp_Object before
= Qnil
, after
= Qnil
, tmp
;
4304 for (ol
= current_buffer
->overlays_before
; ol
; ol
= ol
->next
)
4307 before
= Fcons (tmp
, before
);
4309 for (ol
= current_buffer
->overlays_after
; ol
; ol
= ol
->next
)
4312 after
= Fcons (tmp
, after
);
4315 return Fcons (Fnreverse (before
), Fnreverse (after
));
4318 DEFUN ("overlay-recenter", Foverlay_recenter
, Soverlay_recenter
, 1, 1, 0,
4319 doc
: /* Recenter the overlays of the current buffer around position POS.
4320 That makes overlay lookup faster for positions near POS (but perhaps slower
4321 for positions far away from POS). */)
4325 CHECK_NUMBER_COERCE_MARKER (pos
);
4327 p
= clip_to_bounds (PTRDIFF_MIN
, XINT (pos
), PTRDIFF_MAX
);
4328 recenter_overlay_lists (current_buffer
, p
);
4332 DEFUN ("overlay-get", Foverlay_get
, Soverlay_get
, 2, 2, 0,
4333 doc
: /* Get the property of overlay OVERLAY with property name PROP. */)
4334 (Lisp_Object overlay
, Lisp_Object prop
)
4336 CHECK_OVERLAY (overlay
);
4337 return lookup_char_property (XOVERLAY (overlay
)->plist
, prop
, 0);
4340 DEFUN ("overlay-put", Foverlay_put
, Soverlay_put
, 3, 3, 0,
4341 doc
: /* Set one property of overlay OVERLAY: give property PROP value VALUE.
4342 VALUE will be returned.*/)
4343 (Lisp_Object overlay
, Lisp_Object prop
, Lisp_Object value
)
4345 Lisp_Object tail
, buffer
;
4348 CHECK_OVERLAY (overlay
);
4350 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4352 for (tail
= XOVERLAY (overlay
)->plist
;
4353 CONSP (tail
) && CONSP (XCDR (tail
));
4354 tail
= XCDR (XCDR (tail
)))
4355 if (EQ (XCAR (tail
), prop
))
4357 changed
= !EQ (XCAR (XCDR (tail
)), value
);
4358 XSETCAR (XCDR (tail
), value
);
4361 /* It wasn't in the list, so add it to the front. */
4362 changed
= !NILP (value
);
4364 (overlay
, Fcons (prop
, Fcons (value
, XOVERLAY (overlay
)->plist
)));
4366 if (! NILP (buffer
))
4369 modify_overlay (XBUFFER (buffer
),
4370 marker_position (OVERLAY_START (overlay
)),
4371 marker_position (OVERLAY_END (overlay
)));
4372 if (EQ (prop
, Qevaporate
) && ! NILP (value
)
4373 && (OVERLAY_POSITION (OVERLAY_START (overlay
))
4374 == OVERLAY_POSITION (OVERLAY_END (overlay
))))
4375 Fdelete_overlay (overlay
);
4381 /* Subroutine of report_overlay_modification. */
4383 /* Lisp vector holding overlay hook functions to call.
4384 Vector elements come in pairs.
4385 Each even-index element is a list of hook functions.
4386 The following odd-index element is the overlay they came from.
4388 Before the buffer change, we fill in this vector
4389 as we call overlay hook functions.
4390 After the buffer change, we get the functions to call from this vector.
4391 This way we always call the same functions before and after the change. */
4392 static Lisp_Object last_overlay_modification_hooks
;
4394 /* Number of elements actually used in last_overlay_modification_hooks. */
4395 static ptrdiff_t last_overlay_modification_hooks_used
;
4397 /* Add one functionlist/overlay pair
4398 to the end of last_overlay_modification_hooks. */
4401 add_overlay_mod_hooklist (Lisp_Object functionlist
, Lisp_Object overlay
)
4403 ptrdiff_t oldsize
= ASIZE (last_overlay_modification_hooks
);
4405 if (oldsize
- 1 <= last_overlay_modification_hooks_used
)
4406 last_overlay_modification_hooks
=
4407 larger_vector (last_overlay_modification_hooks
, 2, -1);
4408 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4409 functionlist
); last_overlay_modification_hooks_used
++;
4410 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4411 overlay
); last_overlay_modification_hooks_used
++;
4414 /* Run the modification-hooks of overlays that include
4415 any part of the text in START to END.
4416 If this change is an insertion, also
4417 run the insert-before-hooks of overlay starting at END,
4418 and the insert-after-hooks of overlay ending at START.
4420 This is called both before and after the modification.
4421 AFTER is true when we call after the modification.
4423 ARG1, ARG2, ARG3 are arguments to pass to the hook functions.
4424 When AFTER is nonzero, they are the start position,
4425 the position after the inserted new text,
4426 and the length of deleted or replaced old text. */
4429 report_overlay_modification (Lisp_Object start
, Lisp_Object end
, bool after
,
4430 Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
)
4432 Lisp_Object prop
, overlay
;
4433 struct Lisp_Overlay
*tail
;
4434 /* True if this change is an insertion. */
4435 bool insertion
= (after
? XFASTINT (arg3
) == 0 : EQ (start
, end
));
4436 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4441 /* We used to run the functions as soon as we found them and only register
4442 them in last_overlay_modification_hooks for the purpose of the `after'
4443 case. But running elisp code as we traverse the list of overlays is
4444 painful because the list can be modified by the elisp code so we had to
4445 copy at several places. We now simply do a read-only traversal that
4446 only collects the functions to run and we run them afterwards. It's
4447 simpler, especially since all the code was already there. -stef */
4451 /* We are being called before a change.
4452 Scan the overlays to find the functions to call. */
4453 last_overlay_modification_hooks_used
= 0;
4454 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4456 ptrdiff_t startpos
, endpos
;
4457 Lisp_Object ostart
, oend
;
4459 XSETMISC (overlay
, tail
);
4461 ostart
= OVERLAY_START (overlay
);
4462 oend
= OVERLAY_END (overlay
);
4463 endpos
= OVERLAY_POSITION (oend
);
4464 if (XFASTINT (start
) > endpos
)
4466 startpos
= OVERLAY_POSITION (ostart
);
4467 if (insertion
&& (XFASTINT (start
) == startpos
4468 || XFASTINT (end
) == startpos
))
4470 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4472 add_overlay_mod_hooklist (prop
, overlay
);
4474 if (insertion
&& (XFASTINT (start
) == endpos
4475 || XFASTINT (end
) == endpos
))
4477 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4479 add_overlay_mod_hooklist (prop
, overlay
);
4481 /* Test for intersecting intervals. This does the right thing
4482 for both insertion and deletion. */
4483 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4485 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4487 add_overlay_mod_hooklist (prop
, overlay
);
4491 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4493 ptrdiff_t startpos
, endpos
;
4494 Lisp_Object ostart
, oend
;
4496 XSETMISC (overlay
, tail
);
4498 ostart
= OVERLAY_START (overlay
);
4499 oend
= OVERLAY_END (overlay
);
4500 startpos
= OVERLAY_POSITION (ostart
);
4501 endpos
= OVERLAY_POSITION (oend
);
4502 if (XFASTINT (end
) < startpos
)
4504 if (insertion
&& (XFASTINT (start
) == startpos
4505 || XFASTINT (end
) == startpos
))
4507 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4509 add_overlay_mod_hooklist (prop
, overlay
);
4511 if (insertion
&& (XFASTINT (start
) == endpos
4512 || XFASTINT (end
) == endpos
))
4514 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4516 add_overlay_mod_hooklist (prop
, overlay
);
4518 /* Test for intersecting intervals. This does the right thing
4519 for both insertion and deletion. */
4520 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4522 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4524 add_overlay_mod_hooklist (prop
, overlay
);
4529 GCPRO4 (overlay
, arg1
, arg2
, arg3
);
4531 /* Call the functions recorded in last_overlay_modification_hooks.
4532 First copy the vector contents, in case some of these hooks
4533 do subsequent modification of the buffer. */
4534 ptrdiff_t size
= last_overlay_modification_hooks_used
;
4535 Lisp_Object
*copy
= alloca (size
* sizeof *copy
);
4538 memcpy (copy
, XVECTOR (last_overlay_modification_hooks
)->contents
,
4541 gcpro1
.nvars
= size
;
4543 for (i
= 0; i
< size
;)
4545 Lisp_Object prop_i
, overlay_i
;
4547 overlay_i
= copy
[i
++];
4548 call_overlay_mod_hooks (prop_i
, overlay_i
, after
, arg1
, arg2
, arg3
);
4555 call_overlay_mod_hooks (Lisp_Object list
, Lisp_Object overlay
, bool after
,
4556 Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
)
4558 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4560 GCPRO4 (list
, arg1
, arg2
, arg3
);
4562 while (CONSP (list
))
4565 call4 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
);
4567 call5 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
, arg3
);
4573 /* Delete any zero-sized overlays at position POS, if the `evaporate'
4576 evaporate_overlays (ptrdiff_t pos
)
4578 Lisp_Object overlay
, hit_list
;
4579 struct Lisp_Overlay
*tail
;
4582 if (pos
<= current_buffer
->overlay_center
)
4583 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4586 XSETMISC (overlay
, tail
);
4587 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4590 if (endpos
== pos
&& OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
4591 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4592 hit_list
= Fcons (overlay
, hit_list
);
4595 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4598 XSETMISC (overlay
, tail
);
4599 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4602 if (startpos
== pos
&& OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
4603 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4604 hit_list
= Fcons (overlay
, hit_list
);
4606 for (; CONSP (hit_list
); hit_list
= XCDR (hit_list
))
4607 Fdelete_overlay (XCAR (hit_list
));
4610 /***********************************************************************
4611 Allocation with mmap
4612 ***********************************************************************/
4614 #ifdef USE_MMAP_FOR_BUFFERS
4616 #include <sys/mman.h>
4619 #ifdef MAP_ANONYMOUS
4620 #define MAP_ANON MAP_ANONYMOUS
4627 #define MAP_FAILED ((void *) -1)
4637 /* Memory is allocated in regions which are mapped using mmap(2).
4638 The current implementation lets the system select mapped
4639 addresses; we're not using MAP_FIXED in general, except when
4640 trying to enlarge regions.
4642 Each mapped region starts with a mmap_region structure, the user
4643 area starts after that structure, aligned to MEM_ALIGN.
4645 +-----------------------+
4646 | struct mmap_info + |
4648 +-----------------------+
4652 +-----------------------+ */
4656 /* User-specified size. */
4657 size_t nbytes_specified
;
4659 /* Number of bytes mapped */
4660 size_t nbytes_mapped
;
4662 /* Pointer to the location holding the address of the memory
4663 allocated with the mmap'd block. The variable actually points
4664 after this structure. */
4667 /* Next and previous in list of all mmap'd regions. */
4668 struct mmap_region
*next
, *prev
;
4671 /* Doubly-linked list of mmap'd regions. */
4673 static struct mmap_region
*mmap_regions
;
4675 /* File descriptor for mmap. If we don't have anonymous mapping,
4676 /dev/zero will be opened on it. */
4680 /* Temporary storage for mmap_set_vars, see there. */
4682 static struct mmap_region
*mmap_regions_1
;
4683 static int mmap_fd_1
;
4685 /* Page size on this system. */
4687 static int mmap_page_size
;
4689 /* 1 means mmap has been initialized. */
4691 static bool mmap_initialized_p
;
4693 /* Value is X rounded up to the next multiple of N. */
4695 #define ROUND(X, N) (((X) + (N) - 1) / (N) * (N))
4697 /* Size of mmap_region structure plus padding. */
4699 #define MMAP_REGION_STRUCT_SIZE \
4700 ROUND (sizeof (struct mmap_region), MEM_ALIGN)
4702 /* Given a pointer P to the start of the user-visible part of a mapped
4703 region, return a pointer to the start of the region. */
4705 #define MMAP_REGION(P) \
4706 ((struct mmap_region *) ((char *) (P) - MMAP_REGION_STRUCT_SIZE))
4708 /* Given a pointer P to the start of a mapped region, return a pointer
4709 to the start of the user-visible part of the region. */
4711 #define MMAP_USER_AREA(P) \
4712 ((void *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
4714 #define MEM_ALIGN sizeof (double)
4716 /* Predicate returning true if part of the address range [START .. END]
4717 is currently mapped. Used to prevent overwriting an existing
4720 Default is to conservatively assume the address range is occupied by
4721 something else. This can be overridden by system configuration
4722 files if system-specific means to determine this exists. */
4724 #ifndef MMAP_ALLOCATED_P
4725 #define MMAP_ALLOCATED_P(start, end) 1
4728 /* Perform necessary initializations for the use of mmap. */
4734 /* The value of mmap_fd is initially 0 in temacs, and -1
4735 in a dumped Emacs. */
4738 /* No anonymous mmap -- we need the file descriptor. */
4739 mmap_fd
= emacs_open ("/dev/zero", O_RDONLY
, 0);
4741 fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno
));
4743 #endif /* MAP_ANON == 0 */
4745 if (mmap_initialized_p
)
4747 mmap_initialized_p
= 1;
4753 mmap_page_size
= getpagesize ();
4756 /* Return a region overlapping address range START...END, or null if
4757 none. END is not including, i.e. the last byte in the range
4760 static struct mmap_region
*
4761 mmap_find (void *start
, void *end
)
4763 struct mmap_region
*r
;
4764 char *s
= start
, *e
= end
;
4766 for (r
= mmap_regions
; r
; r
= r
->next
)
4768 char *rstart
= (char *) r
;
4769 char *rend
= rstart
+ r
->nbytes_mapped
;
4771 if (/* First byte of range, i.e. START, in this region? */
4772 (s
>= rstart
&& s
< rend
)
4773 /* Last byte of range, i.e. END - 1, in this region? */
4774 || (e
> rstart
&& e
<= rend
)
4775 /* First byte of this region in the range? */
4776 || (rstart
>= s
&& rstart
< e
)
4777 /* Last byte of this region in the range? */
4778 || (rend
> s
&& rend
<= e
))
4786 /* Unmap a region. P is a pointer to the start of the user-araa of
4790 mmap_free_1 (struct mmap_region
*r
)
4793 r
->next
->prev
= r
->prev
;
4795 r
->prev
->next
= r
->next
;
4797 mmap_regions
= r
->next
;
4799 if (munmap (r
, r
->nbytes_mapped
) == -1)
4800 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4804 /* Enlarge region R by NPAGES pages. NPAGES < 0 means shrink R.
4805 Value is true if successful. */
4808 mmap_enlarge (struct mmap_region
*r
, int npages
)
4810 char *region_end
= (char *) r
+ r
->nbytes_mapped
;
4816 /* Unmap pages at the end of the region. */
4817 nbytes
= - npages
* mmap_page_size
;
4818 if (munmap (region_end
- nbytes
, nbytes
) == -1)
4819 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4822 r
->nbytes_mapped
-= nbytes
;
4826 else if (npages
> 0)
4828 nbytes
= npages
* mmap_page_size
;
4830 /* Try to map additional pages at the end of the region. We
4831 cannot do this if the address range is already occupied by
4832 something else because mmap deletes any previous mapping.
4833 I'm not sure this is worth doing, let's see. */
4834 if (!MMAP_ALLOCATED_P (region_end
, region_end
+ nbytes
))
4838 p
= mmap (region_end
, nbytes
, PROT_READ
| PROT_WRITE
,
4839 MAP_ANON
| MAP_PRIVATE
| MAP_FIXED
, mmap_fd
, 0);
4840 if (p
== MAP_FAILED
)
4841 ; /* fprintf (stderr, "mmap: %s\n", emacs_strerror (errno)); */
4842 else if (p
!= region_end
)
4844 /* Kernels are free to choose a different address. In
4845 that case, unmap what we've mapped above; we have
4847 if (munmap (p
, nbytes
) == -1)
4848 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4852 r
->nbytes_mapped
+= nbytes
;
4862 /* Set or reset variables holding references to mapped regions.
4863 If not RESTORE_P, set all variables to null. If RESTORE_P, set all
4864 variables to the start of the user-areas of mapped regions.
4866 This function is called from Fdump_emacs to ensure that the dumped
4867 Emacs doesn't contain references to memory that won't be mapped
4868 when Emacs starts. */
4871 mmap_set_vars (bool restore_p
)
4873 struct mmap_region
*r
;
4877 mmap_regions
= mmap_regions_1
;
4878 mmap_fd
= mmap_fd_1
;
4879 for (r
= mmap_regions
; r
; r
= r
->next
)
4880 *r
->var
= MMAP_USER_AREA (r
);
4884 for (r
= mmap_regions
; r
; r
= r
->next
)
4886 mmap_regions_1
= mmap_regions
;
4887 mmap_regions
= NULL
;
4888 mmap_fd_1
= mmap_fd
;
4894 /* Allocate a block of storage large enough to hold NBYTES bytes of
4895 data. A pointer to the data is returned in *VAR. VAR is thus the
4896 address of some variable which will use the data area.
4898 The allocation of 0 bytes is valid.
4900 If we can't allocate the necessary memory, set *VAR to null, and
4904 mmap_alloc (void **var
, size_t nbytes
)
4911 map
= ROUND (nbytes
+ MMAP_REGION_STRUCT_SIZE
, mmap_page_size
);
4912 p
= mmap (NULL
, map
, PROT_READ
| PROT_WRITE
, MAP_ANON
| MAP_PRIVATE
,
4915 if (p
== MAP_FAILED
)
4917 if (errno
!= ENOMEM
)
4918 fprintf (stderr
, "mmap: %s\n", emacs_strerror (errno
));
4923 struct mmap_region
*r
= p
;
4925 r
->nbytes_specified
= nbytes
;
4926 r
->nbytes_mapped
= map
;
4929 r
->next
= mmap_regions
;
4934 p
= MMAP_USER_AREA (p
);
4941 /* Free a block of relocatable storage whose data is pointed to by
4942 PTR. Store 0 in *PTR to show there's no block allocated. */
4945 mmap_free (void **var
)
4951 mmap_free_1 (MMAP_REGION (*var
));
4957 /* Given a pointer at address VAR to data allocated with mmap_alloc,
4958 resize it to size NBYTES. Change *VAR to reflect the new block,
4959 and return this value. If more memory cannot be allocated, then
4960 leave *VAR unchanged, and return null. */
4963 mmap_realloc (void **var
, size_t nbytes
)
4970 result
= mmap_alloc (var
, nbytes
);
4971 else if (nbytes
== 0)
4974 result
= mmap_alloc (var
, nbytes
);
4978 struct mmap_region
*r
= MMAP_REGION (*var
);
4979 size_t room
= r
->nbytes_mapped
- MMAP_REGION_STRUCT_SIZE
;
4984 void *old_ptr
= *var
;
4986 /* Try to map additional pages at the end of the region.
4987 If that fails, allocate a new region, copy data
4988 from the old region, then free it. */
4989 if (mmap_enlarge (r
, (ROUND (nbytes
- room
, mmap_page_size
)
4992 r
->nbytes_specified
= nbytes
;
4993 *var
= result
= old_ptr
;
4995 else if (mmap_alloc (var
, nbytes
))
4997 memcpy (*var
, old_ptr
, r
->nbytes_specified
);
4998 mmap_free_1 (MMAP_REGION (old_ptr
));
5000 r
= MMAP_REGION (result
);
5001 r
->nbytes_specified
= nbytes
;
5009 else if (room
- nbytes
>= mmap_page_size
)
5011 /* Shrinking by at least a page. Let's give some
5012 memory back to the system.
5014 The extra parens are to make the division happens first,
5015 on positive values, so we know it will round towards
5017 mmap_enlarge (r
, - ((room
- nbytes
) / mmap_page_size
));
5019 r
->nbytes_specified
= nbytes
;
5023 /* Leave it alone. */
5025 r
->nbytes_specified
= nbytes
;
5033 #endif /* USE_MMAP_FOR_BUFFERS */
5037 /***********************************************************************
5038 Buffer-text Allocation
5039 ***********************************************************************/
5041 /* Allocate NBYTES bytes for buffer B's text buffer. */
5044 alloc_buffer_text (struct buffer
*b
, ptrdiff_t nbytes
)
5049 #if defined USE_MMAP_FOR_BUFFERS
5050 p
= mmap_alloc ((void **) &b
->text
->beg
, nbytes
);
5051 #elif defined REL_ALLOC
5052 p
= r_alloc ((void **) &b
->text
->beg
, nbytes
);
5054 p
= xmalloc (nbytes
);
5060 memory_full (nbytes
);
5067 /* Enlarge buffer B's text buffer by DELTA bytes. DELTA < 0 means
5071 enlarge_buffer_text (struct buffer
*b
, ptrdiff_t delta
)
5074 ptrdiff_t nbytes
= (BUF_Z_BYTE (b
) - BUF_BEG_BYTE (b
) + BUF_GAP_SIZE (b
) + 1
5077 #if defined USE_MMAP_FOR_BUFFERS
5078 p
= mmap_realloc ((void **) &b
->text
->beg
, nbytes
);
5079 #elif defined REL_ALLOC
5080 p
= r_re_alloc ((void **) &b
->text
->beg
, nbytes
);
5082 p
= xrealloc (b
->text
->beg
, nbytes
);
5088 memory_full (nbytes
);
5091 BUF_BEG_ADDR (b
) = p
;
5096 /* Free buffer B's text buffer. */
5099 free_buffer_text (struct buffer
*b
)
5103 #if defined USE_MMAP_FOR_BUFFERS
5104 mmap_free ((void **) &b
->text
->beg
);
5105 #elif defined REL_ALLOC
5106 r_alloc_free ((void **) &b
->text
->beg
);
5108 xfree (b
->text
->beg
);
5111 BUF_BEG_ADDR (b
) = NULL
;
5117 /***********************************************************************
5119 ***********************************************************************/
5122 init_buffer_once (void)
5126 memset (buffer_permanent_local_flags
, 0, sizeof buffer_permanent_local_flags
);
5128 /* Make sure all markable slots in buffer_defaults
5129 are initialized reasonably, so mark_buffer won't choke. */
5130 reset_buffer (&buffer_defaults
);
5131 eassert (EQ (BVAR (&buffer_defaults
, name
), make_number (0)));
5132 reset_buffer_local_variables (&buffer_defaults
, 1);
5133 eassert (EQ (BVAR (&buffer_local_symbols
, name
), make_number (0)));
5134 reset_buffer (&buffer_local_symbols
);
5135 reset_buffer_local_variables (&buffer_local_symbols
, 1);
5136 /* Prevent GC from getting confused. */
5137 buffer_defaults
.text
= &buffer_defaults
.own_text
;
5138 buffer_local_symbols
.text
= &buffer_local_symbols
.own_text
;
5139 /* No one will share the text with these buffers, but let's play it safe. */
5140 buffer_defaults
.indirections
= 0;
5141 buffer_local_symbols
.indirections
= 0;
5142 /* Likewise no one will display them. */
5143 buffer_defaults
.window_count
= 0;
5144 buffer_local_symbols
.window_count
= 0;
5145 set_buffer_intervals (&buffer_defaults
, NULL
);
5146 set_buffer_intervals (&buffer_local_symbols
, NULL
);
5147 /* This is not strictly necessary, but let's make them initialized. */
5148 bset_name (&buffer_defaults
, build_pure_c_string (" *buffer-defaults*"));
5149 bset_name (&buffer_local_symbols
, build_pure_c_string (" *buffer-local-symbols*"));
5150 BUFFER_PVEC_INIT (&buffer_defaults
);
5151 BUFFER_PVEC_INIT (&buffer_local_symbols
);
5153 /* Set up the default values of various buffer slots. */
5154 /* Must do these before making the first buffer! */
5156 /* real setup is done in bindings.el */
5157 bset_mode_line_format (&buffer_defaults
, build_pure_c_string ("%-"));
5158 bset_header_line_format (&buffer_defaults
, Qnil
);
5159 bset_abbrev_mode (&buffer_defaults
, Qnil
);
5160 bset_overwrite_mode (&buffer_defaults
, Qnil
);
5161 bset_case_fold_search (&buffer_defaults
, Qt
);
5162 bset_auto_fill_function (&buffer_defaults
, Qnil
);
5163 bset_selective_display (&buffer_defaults
, Qnil
);
5164 bset_selective_display_ellipses (&buffer_defaults
, Qt
);
5165 bset_abbrev_table (&buffer_defaults
, Qnil
);
5166 bset_display_table (&buffer_defaults
, Qnil
);
5167 bset_undo_list (&buffer_defaults
, Qnil
);
5168 bset_mark_active (&buffer_defaults
, Qnil
);
5169 bset_file_format (&buffer_defaults
, Qnil
);
5170 bset_auto_save_file_format (&buffer_defaults
, Qt
);
5171 set_buffer_overlays_before (&buffer_defaults
, NULL
);
5172 set_buffer_overlays_after (&buffer_defaults
, NULL
);
5173 buffer_defaults
.overlay_center
= BEG
;
5175 XSETFASTINT (BVAR (&buffer_defaults
, tab_width
), 8);
5176 bset_truncate_lines (&buffer_defaults
, Qnil
);
5177 bset_word_wrap (&buffer_defaults
, Qnil
);
5178 bset_ctl_arrow (&buffer_defaults
, Qt
);
5179 bset_bidi_display_reordering (&buffer_defaults
, Qt
);
5180 bset_bidi_paragraph_direction (&buffer_defaults
, Qnil
);
5181 bset_cursor_type (&buffer_defaults
, Qt
);
5182 bset_extra_line_spacing (&buffer_defaults
, Qnil
);
5183 bset_cursor_in_non_selected_windows (&buffer_defaults
, Qt
);
5185 bset_enable_multibyte_characters (&buffer_defaults
, Qt
);
5186 bset_buffer_file_coding_system (&buffer_defaults
, Qnil
);
5187 XSETFASTINT (BVAR (&buffer_defaults
, fill_column
), 70);
5188 XSETFASTINT (BVAR (&buffer_defaults
, left_margin
), 0);
5189 bset_cache_long_scans (&buffer_defaults
, Qnil
);
5190 bset_file_truename (&buffer_defaults
, Qnil
);
5191 XSETFASTINT (BVAR (&buffer_defaults
, display_count
), 0);
5192 XSETFASTINT (BVAR (&buffer_defaults
, left_margin_cols
), 0);
5193 XSETFASTINT (BVAR (&buffer_defaults
, right_margin_cols
), 0);
5194 bset_left_fringe_width (&buffer_defaults
, Qnil
);
5195 bset_right_fringe_width (&buffer_defaults
, Qnil
);
5196 bset_fringes_outside_margins (&buffer_defaults
, Qnil
);
5197 bset_scroll_bar_width (&buffer_defaults
, Qnil
);
5198 bset_vertical_scroll_bar_type (&buffer_defaults
, Qt
);
5199 bset_indicate_empty_lines (&buffer_defaults
, Qnil
);
5200 bset_indicate_buffer_boundaries (&buffer_defaults
, Qnil
);
5201 bset_fringe_indicator_alist (&buffer_defaults
, Qnil
);
5202 bset_fringe_cursor_alist (&buffer_defaults
, Qnil
);
5203 bset_scroll_up_aggressively (&buffer_defaults
, Qnil
);
5204 bset_scroll_down_aggressively (&buffer_defaults
, Qnil
);
5205 bset_display_time (&buffer_defaults
, Qnil
);
5207 /* Assign the local-flags to the slots that have default values.
5208 The local flag is a bit that is used in the buffer
5209 to say that it has its own local value for the slot.
5210 The local flag bits are in the local_var_flags slot of the buffer. */
5212 /* Nothing can work if this isn't true */
5213 { verify (sizeof (EMACS_INT
) == word_size
); }
5215 /* 0 means not a lisp var, -1 means always local, else mask */
5216 memset (&buffer_local_flags
, 0, sizeof buffer_local_flags
);
5217 bset_filename (&buffer_local_flags
, make_number (-1));
5218 bset_directory (&buffer_local_flags
, make_number (-1));
5219 bset_backed_up (&buffer_local_flags
, make_number (-1));
5220 bset_save_length (&buffer_local_flags
, make_number (-1));
5221 bset_auto_save_file_name (&buffer_local_flags
, make_number (-1));
5222 bset_read_only (&buffer_local_flags
, make_number (-1));
5223 bset_major_mode (&buffer_local_flags
, make_number (-1));
5224 bset_mode_name (&buffer_local_flags
, make_number (-1));
5225 bset_undo_list (&buffer_local_flags
, make_number (-1));
5226 bset_mark_active (&buffer_local_flags
, make_number (-1));
5227 bset_point_before_scroll (&buffer_local_flags
, make_number (-1));
5228 bset_file_truename (&buffer_local_flags
, make_number (-1));
5229 bset_invisibility_spec (&buffer_local_flags
, make_number (-1));
5230 bset_file_format (&buffer_local_flags
, make_number (-1));
5231 bset_auto_save_file_format (&buffer_local_flags
, make_number (-1));
5232 bset_display_count (&buffer_local_flags
, make_number (-1));
5233 bset_display_time (&buffer_local_flags
, make_number (-1));
5234 bset_enable_multibyte_characters (&buffer_local_flags
, make_number (-1));
5237 XSETFASTINT (BVAR (&buffer_local_flags
, mode_line_format
), idx
); ++idx
;
5238 XSETFASTINT (BVAR (&buffer_local_flags
, abbrev_mode
), idx
); ++idx
;
5239 XSETFASTINT (BVAR (&buffer_local_flags
, overwrite_mode
), idx
); ++idx
;
5240 XSETFASTINT (BVAR (&buffer_local_flags
, case_fold_search
), idx
); ++idx
;
5241 XSETFASTINT (BVAR (&buffer_local_flags
, auto_fill_function
), idx
); ++idx
;
5242 XSETFASTINT (BVAR (&buffer_local_flags
, selective_display
), idx
); ++idx
;
5243 XSETFASTINT (BVAR (&buffer_local_flags
, selective_display_ellipses
), idx
); ++idx
;
5244 XSETFASTINT (BVAR (&buffer_local_flags
, tab_width
), idx
); ++idx
;
5245 XSETFASTINT (BVAR (&buffer_local_flags
, truncate_lines
), idx
); ++idx
;
5246 XSETFASTINT (BVAR (&buffer_local_flags
, word_wrap
), idx
); ++idx
;
5247 XSETFASTINT (BVAR (&buffer_local_flags
, ctl_arrow
), idx
); ++idx
;
5248 XSETFASTINT (BVAR (&buffer_local_flags
, fill_column
), idx
); ++idx
;
5249 XSETFASTINT (BVAR (&buffer_local_flags
, left_margin
), idx
); ++idx
;
5250 XSETFASTINT (BVAR (&buffer_local_flags
, abbrev_table
), idx
); ++idx
;
5251 XSETFASTINT (BVAR (&buffer_local_flags
, display_table
), idx
); ++idx
;
5252 XSETFASTINT (BVAR (&buffer_local_flags
, syntax_table
), idx
); ++idx
;
5253 XSETFASTINT (BVAR (&buffer_local_flags
, cache_long_scans
), idx
); ++idx
;
5254 XSETFASTINT (BVAR (&buffer_local_flags
, category_table
), idx
); ++idx
;
5255 XSETFASTINT (BVAR (&buffer_local_flags
, bidi_display_reordering
), idx
); ++idx
;
5256 XSETFASTINT (BVAR (&buffer_local_flags
, bidi_paragraph_direction
), idx
); ++idx
;
5257 XSETFASTINT (BVAR (&buffer_local_flags
, buffer_file_coding_system
), idx
);
5258 /* Make this one a permanent local. */
5259 buffer_permanent_local_flags
[idx
++] = 1;
5260 XSETFASTINT (BVAR (&buffer_local_flags
, left_margin_cols
), idx
); ++idx
;
5261 XSETFASTINT (BVAR (&buffer_local_flags
, right_margin_cols
), idx
); ++idx
;
5262 XSETFASTINT (BVAR (&buffer_local_flags
, left_fringe_width
), idx
); ++idx
;
5263 XSETFASTINT (BVAR (&buffer_local_flags
, right_fringe_width
), idx
); ++idx
;
5264 XSETFASTINT (BVAR (&buffer_local_flags
, fringes_outside_margins
), idx
); ++idx
;
5265 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_bar_width
), idx
); ++idx
;
5266 XSETFASTINT (BVAR (&buffer_local_flags
, vertical_scroll_bar_type
), idx
); ++idx
;
5267 XSETFASTINT (BVAR (&buffer_local_flags
, indicate_empty_lines
), idx
); ++idx
;
5268 XSETFASTINT (BVAR (&buffer_local_flags
, indicate_buffer_boundaries
), idx
); ++idx
;
5269 XSETFASTINT (BVAR (&buffer_local_flags
, fringe_indicator_alist
), idx
); ++idx
;
5270 XSETFASTINT (BVAR (&buffer_local_flags
, fringe_cursor_alist
), idx
); ++idx
;
5271 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_up_aggressively
), idx
); ++idx
;
5272 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_down_aggressively
), idx
); ++idx
;
5273 XSETFASTINT (BVAR (&buffer_local_flags
, header_line_format
), idx
); ++idx
;
5274 XSETFASTINT (BVAR (&buffer_local_flags
, cursor_type
), idx
); ++idx
;
5275 XSETFASTINT (BVAR (&buffer_local_flags
, extra_line_spacing
), idx
); ++idx
;
5276 XSETFASTINT (BVAR (&buffer_local_flags
, cursor_in_non_selected_windows
), idx
); ++idx
;
5278 /* Need more room? */
5279 if (idx
>= MAX_PER_BUFFER_VARS
)
5281 last_per_buffer_idx
= idx
;
5283 Vbuffer_alist
= Qnil
;
5287 QSFundamental
= build_pure_c_string ("Fundamental");
5289 Qfundamental_mode
= intern_c_string ("fundamental-mode");
5290 bset_major_mode (&buffer_defaults
, Qfundamental_mode
);
5292 Qmode_class
= intern_c_string ("mode-class");
5294 Qprotected_field
= intern_c_string ("protected-field");
5296 Qpermanent_local
= intern_c_string ("permanent-local");
5298 Qkill_buffer_hook
= intern_c_string ("kill-buffer-hook");
5299 Fput (Qkill_buffer_hook
, Qpermanent_local
, Qt
);
5301 /* super-magic invisible buffer */
5302 Vprin1_to_string_buffer
= Fget_buffer_create (build_pure_c_string (" prin1"));
5303 Vbuffer_alist
= Qnil
;
5305 Fset_buffer (Fget_buffer_create (build_pure_c_string ("*scratch*")));
5307 inhibit_modification_hooks
= 0;
5317 #ifdef USE_MMAP_FOR_BUFFERS
5319 /* When using the ralloc implementation based on mmap(2), buffer
5320 text pointers will have been set to null in the dumped Emacs.
5325 if (b
->text
->beg
== NULL
)
5326 enlarge_buffer_text (b
, 0);
5328 #endif /* USE_MMAP_FOR_BUFFERS */
5330 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
5331 if (NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
)))
5332 Fset_buffer_multibyte (Qnil
);
5334 pwd
= get_current_dir_name ();
5337 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5339 /* Maybe this should really use some standard subroutine
5340 whose definition is filename syntax dependent. */
5342 if (!(IS_DIRECTORY_SEP (pwd
[len
- 1])))
5344 /* Grow buffer to add directory separator and '\0'. */
5345 pwd
= realloc (pwd
, len
+ 2);
5347 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5348 pwd
[len
] = DIRECTORY_SEP
;
5349 pwd
[len
+ 1] = '\0';
5353 bset_directory (current_buffer
, make_unibyte_string (pwd
, len
));
5354 if (! NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
)))
5355 /* At this moment, we still don't know how to decode the
5356 directory name. So, we keep the bytes in multibyte form so
5357 that ENCODE_FILE correctly gets the original bytes. */
5359 (current_buffer
, string_to_multibyte (BVAR (current_buffer
, directory
)));
5361 /* Add /: to the front of the name
5362 if it would otherwise be treated as magic. */
5363 temp
= Ffind_file_name_handler (BVAR (current_buffer
, directory
), Qt
);
5365 /* If the default dir is just /, TEMP is non-nil
5366 because of the ange-ftp completion handler.
5367 However, it is not necessary to turn / into /:/.
5368 So avoid doing that. */
5369 && strcmp ("/", SSDATA (BVAR (current_buffer
, directory
))))
5372 concat2 (build_string ("/:"), BVAR (current_buffer
, directory
)));
5374 temp
= get_minibuffer (0);
5375 bset_directory (XBUFFER (temp
), BVAR (current_buffer
, directory
));
5380 /* Similar to defvar_lisp but define a variable whose value is the
5381 Lisp_Object stored in the current buffer. LNAME is the Lisp-level
5382 variable name. VNAME is the name of the buffer slot. PREDICATE
5383 is nil for a general Lisp variable. If PREDICATE is non-nil, then
5384 only Lisp values that satisfies the PREDICATE are allowed (except
5385 that nil is allowed too). DOC is a dummy where you write the doc
5386 string as a comment. */
5388 #define DEFVAR_PER_BUFFER(lname, vname, predicate, doc) \
5390 static struct Lisp_Buffer_Objfwd bo_fwd; \
5391 defvar_per_buffer (&bo_fwd, lname, vname, predicate); \
5395 defvar_per_buffer (struct Lisp_Buffer_Objfwd
*bo_fwd
, const char *namestring
,
5396 Lisp_Object
*address
, Lisp_Object predicate
)
5398 struct Lisp_Symbol
*sym
;
5401 sym
= XSYMBOL (intern (namestring
));
5402 offset
= (char *)address
- (char *)current_buffer
;
5404 bo_fwd
->type
= Lisp_Fwd_Buffer_Obj
;
5405 bo_fwd
->offset
= offset
;
5406 bo_fwd
->predicate
= predicate
;
5407 sym
->declared_special
= 1;
5408 sym
->redirect
= SYMBOL_FORWARDED
;
5409 SET_SYMBOL_FWD (sym
, (union Lisp_Fwd
*) bo_fwd
);
5410 XSETSYMBOL (PER_BUFFER_SYMBOL (offset
), sym
);
5412 if (PER_BUFFER_IDX (offset
) == 0)
5413 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
5414 slot of buffer_local_flags */
5419 /* initialize the buffer routines */
5421 syms_of_buffer (void)
5423 staticpro (&last_overlay_modification_hooks
);
5424 last_overlay_modification_hooks
5425 = Fmake_vector (make_number (10), Qnil
);
5427 staticpro (&Qfundamental_mode
);
5428 staticpro (&Qmode_class
);
5429 staticpro (&QSFundamental
);
5430 staticpro (&Vbuffer_alist
);
5431 staticpro (&Qprotected_field
);
5432 staticpro (&Qpermanent_local
);
5433 staticpro (&Qkill_buffer_hook
);
5435 DEFSYM (Qpermanent_local_hook
, "permanent-local-hook");
5436 DEFSYM (Qoverlayp
, "overlayp");
5437 DEFSYM (Qevaporate
, "evaporate");
5438 DEFSYM (Qmodification_hooks
, "modification-hooks");
5439 DEFSYM (Qinsert_in_front_hooks
, "insert-in-front-hooks");
5440 DEFSYM (Qinsert_behind_hooks
, "insert-behind-hooks");
5441 DEFSYM (Qget_file_buffer
, "get-file-buffer");
5442 DEFSYM (Qpriority
, "priority");
5443 DEFSYM (Qbefore_string
, "before-string");
5444 DEFSYM (Qafter_string
, "after-string");
5445 DEFSYM (Qfirst_change_hook
, "first-change-hook");
5446 DEFSYM (Qbefore_change_functions
, "before-change-functions");
5447 DEFSYM (Qafter_change_functions
, "after-change-functions");
5448 DEFSYM (Qkill_buffer_query_functions
, "kill-buffer-query-functions");
5450 Fput (Qprotected_field
, Qerror_conditions
,
5451 listn (CONSTYPE_PURE
, 2, Qprotected_field
, Qerror
));
5452 Fput (Qprotected_field
, Qerror_message
,
5453 build_pure_c_string ("Attempt to modify a protected field"));
5455 DEFVAR_BUFFER_DEFAULTS ("default-mode-line-format",
5457 doc
: /* Default value of `mode-line-format' for buffers that don't override it.
5458 This is the same as (default-value 'mode-line-format). */);
5460 DEFVAR_BUFFER_DEFAULTS ("default-header-line-format",
5462 doc
: /* Default value of `header-line-format' for buffers that don't override it.
5463 This is the same as (default-value 'header-line-format). */);
5465 DEFVAR_BUFFER_DEFAULTS ("default-cursor-type", cursor_type
,
5466 doc
: /* Default value of `cursor-type' for buffers that don't override it.
5467 This is the same as (default-value 'cursor-type). */);
5469 DEFVAR_BUFFER_DEFAULTS ("default-line-spacing",
5471 doc
: /* Default value of `line-spacing' for buffers that don't override it.
5472 This is the same as (default-value 'line-spacing). */);
5474 DEFVAR_BUFFER_DEFAULTS ("default-cursor-in-non-selected-windows",
5475 cursor_in_non_selected_windows
,
5476 doc
: /* Default value of `cursor-in-non-selected-windows'.
5477 This is the same as (default-value 'cursor-in-non-selected-windows). */);
5479 DEFVAR_BUFFER_DEFAULTS ("default-abbrev-mode",
5481 doc
: /* Default value of `abbrev-mode' for buffers that do not override it.
5482 This is the same as (default-value 'abbrev-mode). */);
5484 DEFVAR_BUFFER_DEFAULTS ("default-ctl-arrow",
5486 doc
: /* Default value of `ctl-arrow' for buffers that do not override it.
5487 This is the same as (default-value 'ctl-arrow). */);
5489 DEFVAR_BUFFER_DEFAULTS ("default-enable-multibyte-characters",
5490 enable_multibyte_characters
,
5491 doc
: /* Default value of `enable-multibyte-characters' for buffers not overriding it.
5492 This is the same as (default-value 'enable-multibyte-characters). */);
5494 DEFVAR_BUFFER_DEFAULTS ("default-buffer-file-coding-system",
5495 buffer_file_coding_system
,
5496 doc
: /* Default value of `buffer-file-coding-system' for buffers not overriding it.
5497 This is the same as (default-value 'buffer-file-coding-system). */);
5499 DEFVAR_BUFFER_DEFAULTS ("default-truncate-lines",
5501 doc
: /* Default value of `truncate-lines' for buffers that do not override it.
5502 This is the same as (default-value 'truncate-lines). */);
5504 DEFVAR_BUFFER_DEFAULTS ("default-fill-column",
5506 doc
: /* Default value of `fill-column' for buffers that do not override it.
5507 This is the same as (default-value 'fill-column). */);
5509 DEFVAR_BUFFER_DEFAULTS ("default-left-margin",
5511 doc
: /* Default value of `left-margin' for buffers that do not override it.
5512 This is the same as (default-value 'left-margin). */);
5514 DEFVAR_BUFFER_DEFAULTS ("default-tab-width",
5516 doc
: /* Default value of `tab-width' for buffers that do not override it.
5517 NOTE: This controls the display width of a TAB character, and not
5518 the size of an indentation step.
5519 This is the same as (default-value 'tab-width). */);
5521 DEFVAR_BUFFER_DEFAULTS ("default-case-fold-search",
5523 doc
: /* Default value of `case-fold-search' for buffers that don't override it.
5524 This is the same as (default-value 'case-fold-search). */);
5526 DEFVAR_BUFFER_DEFAULTS ("default-left-margin-width",
5528 doc
: /* Default value of `left-margin-width' for buffers that don't override it.
5529 This is the same as (default-value 'left-margin-width). */);
5531 DEFVAR_BUFFER_DEFAULTS ("default-right-margin-width",
5533 doc
: /* Default value of `right-margin-width' for buffers that don't override it.
5534 This is the same as (default-value 'right-margin-width). */);
5536 DEFVAR_BUFFER_DEFAULTS ("default-left-fringe-width",
5538 doc
: /* Default value of `left-fringe-width' for buffers that don't override it.
5539 This is the same as (default-value 'left-fringe-width). */);
5541 DEFVAR_BUFFER_DEFAULTS ("default-right-fringe-width",
5543 doc
: /* Default value of `right-fringe-width' for buffers that don't override it.
5544 This is the same as (default-value 'right-fringe-width). */);
5546 DEFVAR_BUFFER_DEFAULTS ("default-fringes-outside-margins",
5547 fringes_outside_margins
,
5548 doc
: /* Default value of `fringes-outside-margins' for buffers that don't override it.
5549 This is the same as (default-value 'fringes-outside-margins). */);
5551 DEFVAR_BUFFER_DEFAULTS ("default-scroll-bar-width",
5553 doc
: /* Default value of `scroll-bar-width' for buffers that don't override it.
5554 This is the same as (default-value 'scroll-bar-width). */);
5556 DEFVAR_BUFFER_DEFAULTS ("default-vertical-scroll-bar",
5557 vertical_scroll_bar_type
,
5558 doc
: /* Default value of `vertical-scroll-bar' for buffers that don't override it.
5559 This is the same as (default-value 'vertical-scroll-bar). */);
5561 DEFVAR_BUFFER_DEFAULTS ("default-indicate-empty-lines",
5562 indicate_empty_lines
,
5563 doc
: /* Default value of `indicate-empty-lines' for buffers that don't override it.
5564 This is the same as (default-value 'indicate-empty-lines). */);
5566 DEFVAR_BUFFER_DEFAULTS ("default-indicate-buffer-boundaries",
5567 indicate_buffer_boundaries
,
5568 doc
: /* Default value of `indicate-buffer-boundaries' for buffers that don't override it.
5569 This is the same as (default-value 'indicate-buffer-boundaries). */);
5571 DEFVAR_BUFFER_DEFAULTS ("default-fringe-indicator-alist",
5572 fringe_indicator_alist
,
5573 doc
: /* Default value of `fringe-indicator-alist' for buffers that don't override it.
5574 This is the same as (default-value 'fringe-indicator-alist'). */);
5576 DEFVAR_BUFFER_DEFAULTS ("default-fringe-cursor-alist",
5577 fringe_cursor_alist
,
5578 doc
: /* Default value of `fringe-cursor-alist' for buffers that don't override it.
5579 This is the same as (default-value 'fringe-cursor-alist'). */);
5581 DEFVAR_BUFFER_DEFAULTS ("default-scroll-up-aggressively",
5582 scroll_up_aggressively
,
5583 doc
: /* Default value of `scroll-up-aggressively'.
5584 This value applies in buffers that don't have their own local values.
5585 This is the same as (default-value 'scroll-up-aggressively). */);
5587 DEFVAR_BUFFER_DEFAULTS ("default-scroll-down-aggressively",
5588 scroll_down_aggressively
,
5589 doc
: /* Default value of `scroll-down-aggressively'.
5590 This value applies in buffers that don't have their own local values.
5591 This is the same as (default-value 'scroll-down-aggressively). */);
5593 DEFVAR_PER_BUFFER ("header-line-format",
5594 &BVAR (current_buffer
, header_line_format
),
5596 doc
: /* Analogous to `mode-line-format', but controls the header line.
5597 The header line appears, optionally, at the top of a window;
5598 the mode line appears at the bottom. */);
5600 DEFVAR_PER_BUFFER ("mode-line-format", &BVAR (current_buffer
, mode_line_format
),
5602 doc
: /* Template for displaying mode line for current buffer.
5604 The value may be nil, a string, a symbol or a list.
5606 A value of nil means don't display a mode line.
5608 For any symbol other than t or nil, the symbol's value is processed as
5609 a mode line construct. As a special exception, if that value is a
5610 string, the string is processed verbatim, without handling any
5611 %-constructs (see below). Also, unless the symbol has a non-nil
5612 `risky-local-variable' property, all properties in any strings, as
5613 well as all :eval and :propertize forms in the value, are ignored.
5615 A list whose car is a string or list is processed by processing each
5616 of the list elements recursively, as separate mode line constructs,
5617 and concatenating the results.
5619 A list of the form `(:eval FORM)' is processed by evaluating FORM and
5620 using the result as a mode line construct. Be careful--FORM should
5621 not load any files, because that can cause an infinite recursion.
5623 A list of the form `(:propertize ELT PROPS...)' is processed by
5624 processing ELT as the mode line construct, and adding the text
5625 properties PROPS to the result.
5627 A list whose car is a symbol is processed by examining the symbol's
5628 value, and, if that value is non-nil, processing the cadr of the list
5629 recursively; and if that value is nil, processing the caddr of the
5632 A list whose car is an integer is processed by processing the cadr of
5633 the list, and padding (if the number is positive) or truncating (if
5634 negative) to the width specified by that number.
5636 A string is printed verbatim in the mode line except for %-constructs:
5637 %b -- print buffer name. %f -- print visited file name.
5638 %F -- print frame name.
5639 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
5640 %& is like %*, but ignore read-only-ness.
5641 % means buffer is read-only and * means it is modified.
5642 For a modified read-only buffer, %* gives % and %+ gives *.
5643 %s -- print process status. %l -- print the current line number.
5644 %c -- print the current column number (this makes editing slower).
5645 To make the column number update correctly in all cases,
5646 `column-number-mode' must be non-nil.
5647 %i -- print the size of the buffer.
5648 %I -- like %i, but use k, M, G, etc., to abbreviate.
5649 %p -- print percent of buffer above top of window, or Top, Bot or All.
5650 %P -- print percent of buffer above bottom of window, perhaps plus Top,
5651 or print Bottom or All.
5652 %n -- print Narrow if appropriate.
5653 %t -- visited file is text or binary (if OS supports this distinction).
5654 %z -- print mnemonics of keyboard, terminal, and buffer coding systems.
5655 %Z -- like %z, but including the end-of-line format.
5656 %e -- print error message about full memory.
5657 %@ -- print @ or hyphen. @ means that default-directory is on a
5659 %[ -- print one [ for each recursive editing level. %] similar.
5660 %% -- print %. %- -- print infinitely many dashes.
5661 Decimal digits after the % specify field width to which to pad. */);
5663 DEFVAR_BUFFER_DEFAULTS ("default-major-mode", major_mode
,
5664 doc
: /* Value of `major-mode' for new buffers. */);
5666 DEFVAR_PER_BUFFER ("major-mode", &BVAR (current_buffer
, major_mode
),
5668 doc
: /* Symbol for current buffer's major mode.
5669 The default value (normally `fundamental-mode') affects new buffers.
5670 A value of nil means to use the current buffer's major mode, provided
5671 it is not marked as "special".
5673 When a mode is used by default, `find-file' switches to it before it
5674 reads the contents into the buffer and before it finishes setting up
5675 the buffer. Thus, the mode and its hooks should not expect certain
5676 variables such as `buffer-read-only' and `buffer-file-coding-system'
5679 DEFVAR_PER_BUFFER ("mode-name", &BVAR (current_buffer
, mode_name
),
5681 doc
: /* Pretty name of current buffer's major mode.
5682 Usually a string, but can use any of the constructs for `mode-line-format',
5684 Format with `format-mode-line' to produce a string value. */);
5686 DEFVAR_PER_BUFFER ("local-abbrev-table", &BVAR (current_buffer
, abbrev_table
), Qnil
,
5687 doc
: /* Local (mode-specific) abbrev table of current buffer. */);
5689 DEFVAR_PER_BUFFER ("abbrev-mode", &BVAR (current_buffer
, abbrev_mode
), Qnil
,
5690 doc
: /* Non-nil if Abbrev mode is enabled.
5691 Use the command `abbrev-mode' to change this variable. */);
5693 DEFVAR_PER_BUFFER ("case-fold-search", &BVAR (current_buffer
, case_fold_search
),
5695 doc
: /* Non-nil if searches and matches should ignore case. */);
5697 DEFVAR_PER_BUFFER ("fill-column", &BVAR (current_buffer
, fill_column
),
5699 doc
: /* Column beyond which automatic line-wrapping should happen.
5700 Interactively, you can set the buffer local value using \\[set-fill-column]. */);
5702 DEFVAR_PER_BUFFER ("left-margin", &BVAR (current_buffer
, left_margin
),
5704 doc
: /* Column for the default `indent-line-function' to indent to.
5705 Linefeed indents to this column in Fundamental mode. */);
5707 DEFVAR_PER_BUFFER ("tab-width", &BVAR (current_buffer
, tab_width
),
5709 doc
: /* Distance between tab stops (for display of tab characters), in columns.
5710 NOTE: This controls the display width of a TAB character, and not
5711 the size of an indentation step.
5712 This should be an integer greater than zero. */);
5714 DEFVAR_PER_BUFFER ("ctl-arrow", &BVAR (current_buffer
, ctl_arrow
), Qnil
,
5715 doc
: /* Non-nil means display control chars with uparrow.
5716 A value of nil means use backslash and octal digits.
5717 This variable does not apply to characters whose display is specified
5718 in the current display table (if there is one). */);
5720 DEFVAR_PER_BUFFER ("enable-multibyte-characters",
5721 &BVAR (current_buffer
, enable_multibyte_characters
),
5723 doc
: /* Non-nil means the buffer contents are regarded as multi-byte characters.
5724 Otherwise they are regarded as unibyte. This affects the display,
5725 file I/O and the behavior of various editing commands.
5727 This variable is buffer-local but you cannot set it directly;
5728 use the function `set-buffer-multibyte' to change a buffer's representation.
5729 See also Info node `(elisp)Text Representations'. */);
5730 XSYMBOL (intern_c_string ("enable-multibyte-characters"))->constant
= 1;
5732 DEFVAR_PER_BUFFER ("buffer-file-coding-system",
5733 &BVAR (current_buffer
, buffer_file_coding_system
), Qnil
,
5734 doc
: /* Coding system to be used for encoding the buffer contents on saving.
5735 This variable applies to saving the buffer, and also to `write-region'
5736 and other functions that use `write-region'.
5737 It does not apply to sending output to subprocesses, however.
5739 If this is nil, the buffer is saved without any code conversion
5740 unless some coding system is specified in `file-coding-system-alist'
5741 for the buffer file.
5743 If the text to be saved cannot be encoded as specified by this variable,
5744 an alternative encoding is selected by `select-safe-coding-system', which see.
5746 The variable `coding-system-for-write', if non-nil, overrides this variable.
5748 This variable is never applied to a way of decoding a file while reading it. */);
5750 DEFVAR_PER_BUFFER ("bidi-display-reordering",
5751 &BVAR (current_buffer
, bidi_display_reordering
), Qnil
,
5752 doc
: /* Non-nil means reorder bidirectional text for display in the visual order. */);
5754 DEFVAR_PER_BUFFER ("bidi-paragraph-direction",
5755 &BVAR (current_buffer
, bidi_paragraph_direction
), Qnil
,
5756 doc
: /* If non-nil, forces directionality of text paragraphs in the buffer.
5758 If this is nil (the default), the direction of each paragraph is
5759 determined by the first strong directional character of its text.
5760 The values of `right-to-left' and `left-to-right' override that.
5761 Any other value is treated as nil.
5763 This variable has no effect unless the buffer's value of
5764 \`bidi-display-reordering' is non-nil. */);
5766 DEFVAR_PER_BUFFER ("truncate-lines", &BVAR (current_buffer
, truncate_lines
), Qnil
,
5767 doc
: /* Non-nil means do not display continuation lines.
5768 Instead, give each line of text just one screen line.
5770 Note that this is overridden by the variable
5771 `truncate-partial-width-windows' if that variable is non-nil
5772 and this buffer is not full-frame width.
5774 Minibuffers set this variable to nil. */);
5776 DEFVAR_PER_BUFFER ("word-wrap", &BVAR (current_buffer
, word_wrap
), Qnil
,
5777 doc
: /* Non-nil means to use word-wrapping for continuation lines.
5778 When word-wrapping is on, continuation lines are wrapped at the space
5779 or tab character nearest to the right window edge.
5780 If nil, continuation lines are wrapped at the right screen edge.
5782 This variable has no effect if long lines are truncated (see
5783 `truncate-lines' and `truncate-partial-width-windows'). If you use
5784 word-wrapping, you might want to reduce the value of
5785 `truncate-partial-width-windows', since wrapping can make text readable
5786 in narrower windows.
5788 Instead of setting this variable directly, most users should use
5789 Visual Line mode . Visual Line mode, when enabled, sets `word-wrap'
5790 to t, and additionally redefines simple editing commands to act on
5791 visual lines rather than logical lines. See the documentation of
5792 `visual-line-mode'. */);
5794 DEFVAR_PER_BUFFER ("default-directory", &BVAR (current_buffer
, directory
),
5796 doc
: /* Name of default directory of current buffer. Should end with slash.
5797 To interactively change the default directory, use command `cd'. */);
5799 DEFVAR_PER_BUFFER ("auto-fill-function", &BVAR (current_buffer
, auto_fill_function
),
5801 doc
: /* Function called (if non-nil) to perform auto-fill.
5802 It is called after self-inserting any character specified in
5803 the `auto-fill-chars' table.
5804 NOTE: This variable is not a hook;
5805 its value may not be a list of functions. */);
5807 DEFVAR_PER_BUFFER ("buffer-file-name", &BVAR (current_buffer
, filename
),
5809 doc
: /* Name of file visited in current buffer, or nil if not visiting a file. */);
5811 DEFVAR_PER_BUFFER ("buffer-file-truename", &BVAR (current_buffer
, file_truename
),
5813 doc
: /* Abbreviated truename of file visited in current buffer, or nil if none.
5814 The truename of a file is calculated by `file-truename'
5815 and then abbreviated with `abbreviate-file-name'. */);
5817 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
5818 &BVAR (current_buffer
, auto_save_file_name
),
5820 doc
: /* Name of file for auto-saving current buffer.
5821 If it is nil, that means don't auto-save this buffer. */);
5823 DEFVAR_PER_BUFFER ("buffer-read-only", &BVAR (current_buffer
, read_only
), Qnil
,
5824 doc
: /* Non-nil if this buffer is read-only. */);
5826 DEFVAR_PER_BUFFER ("buffer-backed-up", &BVAR (current_buffer
, backed_up
), Qnil
,
5827 doc
: /* Non-nil if this buffer's file has been backed up.
5828 Backing up is done before the first time the file is saved. */);
5830 DEFVAR_PER_BUFFER ("buffer-saved-size", &BVAR (current_buffer
, save_length
),
5832 doc
: /* Length of current buffer when last read in, saved or auto-saved.
5834 -1 means auto-saving turned off until next real save.
5836 If you set this to -2, that means don't turn off auto-saving in this buffer
5837 if its text size shrinks. If you use `buffer-swap-text' on a buffer,
5838 you probably should set this to -2 in that buffer. */);
5840 DEFVAR_PER_BUFFER ("selective-display", &BVAR (current_buffer
, selective_display
),
5842 doc
: /* Non-nil enables selective display.
5843 An integer N as value means display only lines
5844 that start with less than N columns of space.
5845 A value of t means that the character ^M makes itself and
5846 all the rest of the line invisible; also, when saving the buffer
5847 in a file, save the ^M as a newline. */);
5849 DEFVAR_PER_BUFFER ("selective-display-ellipses",
5850 &BVAR (current_buffer
, selective_display_ellipses
),
5852 doc
: /* Non-nil means display ... on previous line when a line is invisible. */);
5854 DEFVAR_PER_BUFFER ("overwrite-mode", &BVAR (current_buffer
, overwrite_mode
), Qnil
,
5855 doc
: /* Non-nil if self-insertion should replace existing text.
5856 The value should be one of `overwrite-mode-textual',
5857 `overwrite-mode-binary', or nil.
5858 If it is `overwrite-mode-textual', self-insertion still
5859 inserts at the end of a line, and inserts when point is before a tab,
5860 until the tab is filled in.
5861 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too. */);
5863 DEFVAR_PER_BUFFER ("buffer-display-table", &BVAR (current_buffer
, display_table
),
5865 doc
: /* Display table that controls display of the contents of current buffer.
5867 If this variable is nil, the value of `standard-display-table' is used.
5868 Each window can have its own, overriding display table, see
5869 `set-window-display-table' and `window-display-table'.
5871 The display table is a char-table created with `make-display-table'.
5872 A char-table is an array indexed by character codes. Normal array
5873 primitives `aref' and `aset' can be used to access elements of a char-table.
5875 Each of the char-table elements control how to display the corresponding
5876 text character: the element at index C in the table says how to display
5877 the character whose code is C. Each element should be a vector of
5878 characters or nil. The value nil means display the character in the
5879 default fashion; otherwise, the characters from the vector are delivered
5880 to the screen instead of the original character.
5882 For example, (aset buffer-display-table ?X [?Y]) tells Emacs
5883 to display a capital Y instead of each X character.
5885 In addition, a char-table has six extra slots to control the display of:
5887 the end of a truncated screen line (extra-slot 0, a single character);
5888 the end of a continued line (extra-slot 1, a single character);
5889 the escape character used to display character codes in octal
5890 (extra-slot 2, a single character);
5891 the character used as an arrow for control characters (extra-slot 3,
5892 a single character);
5893 the decoration indicating the presence of invisible lines (extra-slot 4,
5894 a vector of characters);
5895 the character used to draw the border between side-by-side windows
5896 (extra-slot 5, a single character).
5898 See also the functions `display-table-slot' and `set-display-table-slot'. */);
5900 DEFVAR_PER_BUFFER ("left-margin-width", &BVAR (current_buffer
, left_margin_cols
),
5902 doc
: /* Width of left marginal area for display of a buffer.
5903 A value of nil means no marginal area.
5905 Setting this variable does not take effect until a new buffer is displayed
5906 in a window. To make the change take effect, call `set-window-buffer'. */);
5908 DEFVAR_PER_BUFFER ("right-margin-width", &BVAR (current_buffer
, right_margin_cols
),
5910 doc
: /* Width of right marginal area for display of a buffer.
5911 A value of nil means no marginal area.
5913 Setting this variable does not take effect until a new buffer is displayed
5914 in a window. To make the change take effect, call `set-window-buffer'. */);
5916 DEFVAR_PER_BUFFER ("left-fringe-width", &BVAR (current_buffer
, left_fringe_width
),
5918 doc
: /* Width of this buffer's left fringe (in pixels).
5919 A value of 0 means no left fringe is shown in this buffer's window.
5920 A value of nil means to use the left fringe width from the window's frame.
5922 Setting this variable does not take effect until a new buffer is displayed
5923 in a window. To make the change take effect, call `set-window-buffer'. */);
5925 DEFVAR_PER_BUFFER ("right-fringe-width", &BVAR (current_buffer
, right_fringe_width
),
5927 doc
: /* Width of this buffer's right fringe (in pixels).
5928 A value of 0 means no right fringe is shown in this buffer's window.
5929 A value of nil means to use the right fringe width from the window's frame.
5931 Setting this variable does not take effect until a new buffer is displayed
5932 in a window. To make the change take effect, call `set-window-buffer'. */);
5934 DEFVAR_PER_BUFFER ("fringes-outside-margins", &BVAR (current_buffer
, fringes_outside_margins
),
5936 doc
: /* Non-nil means to display fringes outside display margins.
5937 A value of nil means to display fringes between margins and buffer text.
5939 Setting this variable does not take effect until a new buffer is displayed
5940 in a window. To make the change take effect, call `set-window-buffer'. */);
5942 DEFVAR_PER_BUFFER ("scroll-bar-width", &BVAR (current_buffer
, scroll_bar_width
),
5944 doc
: /* Width of this buffer's scroll bars in pixels.
5945 A value of nil means to use the scroll bar width from the window's frame. */);
5947 DEFVAR_PER_BUFFER ("vertical-scroll-bar", &BVAR (current_buffer
, vertical_scroll_bar_type
),
5949 doc
: /* Position of this buffer's vertical scroll bar.
5950 The value takes effect whenever you tell a window to display this buffer;
5951 for instance, with `set-window-buffer' or when `display-buffer' displays it.
5953 A value of `left' or `right' means put the vertical scroll bar at that side
5954 of the window; a value of nil means don't show any vertical scroll bars.
5955 A value of t (the default) means do whatever the window's frame specifies. */);
5957 DEFVAR_PER_BUFFER ("indicate-empty-lines",
5958 &BVAR (current_buffer
, indicate_empty_lines
), Qnil
,
5959 doc
: /* Visually indicate empty lines after the buffer end.
5960 If non-nil, a bitmap is displayed in the left fringe of a window on
5961 window-systems. */);
5963 DEFVAR_PER_BUFFER ("indicate-buffer-boundaries",
5964 &BVAR (current_buffer
, indicate_buffer_boundaries
), Qnil
,
5965 doc
: /* Visually indicate buffer boundaries and scrolling.
5966 If non-nil, the first and last line of the buffer are marked in the fringe
5967 of a window on window-systems with angle bitmaps, or if the window can be
5968 scrolled, the top and bottom line of the window are marked with up and down
5971 If value is a symbol `left' or `right', both angle and arrow bitmaps
5972 are displayed in the left or right fringe, resp. Any other value
5973 that doesn't look like an alist means display the angle bitmaps in
5974 the left fringe but no arrows.
5976 You can exercise more precise control by using an alist as the
5977 value. Each alist element (INDICATOR . POSITION) specifies
5978 where to show one of the indicators. INDICATOR is one of `top',
5979 `bottom', `up', `down', or t, which specifies the default position,
5980 and POSITION is one of `left', `right', or nil, meaning do not show
5983 For example, ((top . left) (t . right)) places the top angle bitmap in
5984 left fringe, the bottom angle bitmap in right fringe, and both arrow
5985 bitmaps in right fringe. To show just the angle bitmaps in the left
5986 fringe, but no arrow bitmaps, use ((top . left) (bottom . left)). */);
5988 DEFVAR_PER_BUFFER ("fringe-indicator-alist",
5989 &BVAR (current_buffer
, fringe_indicator_alist
), Qnil
,
5990 doc
: /* Mapping from logical to physical fringe indicator bitmaps.
5991 The value is an alist where each element (INDICATOR . BITMAPS)
5992 specifies the fringe bitmaps used to display a specific logical
5995 INDICATOR specifies the logical indicator type which is one of the
5996 following symbols: `truncation' , `continuation', `overlay-arrow',
5997 `top', `bottom', `top-bottom', `up', `down', empty-line', or `unknown'.
5999 BITMAPS is a list of symbols (LEFT RIGHT [LEFT1 RIGHT1]) which specifies
6000 the actual bitmap shown in the left or right fringe for the logical
6001 indicator. LEFT and RIGHT are the bitmaps shown in the left and/or
6002 right fringe for the specific indicator. The LEFT1 or RIGHT1 bitmaps
6003 are used only for the `bottom' and `top-bottom' indicators when the
6004 last (only) line has no final newline. BITMAPS may also be a single
6005 symbol which is used in both left and right fringes. */);
6007 DEFVAR_PER_BUFFER ("fringe-cursor-alist",
6008 &BVAR (current_buffer
, fringe_cursor_alist
), Qnil
,
6009 doc
: /* Mapping from logical to physical fringe cursor bitmaps.
6010 The value is an alist where each element (CURSOR . BITMAP)
6011 specifies the fringe bitmaps used to display a specific logical
6012 cursor type in the fringe.
6014 CURSOR specifies the logical cursor type which is one of the following
6015 symbols: `box' , `hollow', `bar', `hbar', or `hollow-small'. The last
6016 one is used to show a hollow cursor on narrow lines display lines
6017 where the normal hollow cursor will not fit.
6019 BITMAP is the corresponding fringe bitmap shown for the logical
6022 DEFVAR_PER_BUFFER ("scroll-up-aggressively",
6023 &BVAR (current_buffer
, scroll_up_aggressively
), Qfloatp
,
6024 doc
: /* How far to scroll windows upward.
6025 If you move point off the bottom, the window scrolls automatically.
6026 This variable controls how far it scrolls. The value nil, the default,
6027 means scroll to center point. A fraction means scroll to put point
6028 that fraction of the window's height from the bottom of the window.
6029 When the value is 0.0, point goes at the bottom line, which in the
6030 simple case that you moved off with C-f means scrolling just one line.
6031 1.0 means point goes at the top, so that in that simple case, the
6032 window scrolls by a full window height. Meaningful values are
6033 between 0.0 and 1.0, inclusive. */);
6035 DEFVAR_PER_BUFFER ("scroll-down-aggressively",
6036 &BVAR (current_buffer
, scroll_down_aggressively
), Qfloatp
,
6037 doc
: /* How far to scroll windows downward.
6038 If you move point off the top, the window scrolls automatically.
6039 This variable controls how far it scrolls. The value nil, the default,
6040 means scroll to center point. A fraction means scroll to put point
6041 that fraction of the window's height from the top of the window.
6042 When the value is 0.0, point goes at the top line, which in the
6043 simple case that you moved off with C-b means scrolling just one line.
6044 1.0 means point goes at the bottom, so that in that simple case, the
6045 window scrolls by a full window height. Meaningful values are
6046 between 0.0 and 1.0, inclusive. */);
6048 DEFVAR_LISP ("before-change-functions", Vbefore_change_functions
,
6049 doc
: /* List of functions to call before each text change.
6050 Two arguments are passed to each function: the positions of
6051 the beginning and end of the range of old text to be changed.
6052 \(For an insertion, the beginning and end are at the same place.)
6053 No information is given about the length of the text after the change.
6055 Buffer changes made while executing the `before-change-functions'
6056 don't call any before-change or after-change functions.
6057 That's because `inhibit-modification-hooks' is temporarily set non-nil.
6059 If an unhandled error happens in running these functions,
6060 the variable's value remains nil. That prevents the error
6061 from happening repeatedly and making Emacs nonfunctional. */);
6062 Vbefore_change_functions
= Qnil
;
6064 DEFVAR_LISP ("after-change-functions", Vafter_change_functions
,
6065 doc
: /* List of functions to call after each text change.
6066 Three arguments are passed to each function: the positions of
6067 the beginning and end of the range of changed text,
6068 and the length in bytes of the pre-change text replaced by that range.
6069 \(For an insertion, the pre-change length is zero;
6070 for a deletion, that length is the number of bytes deleted,
6071 and the post-change beginning and end are at the same place.)
6073 Buffer changes made while executing the `after-change-functions'
6074 don't call any before-change or after-change functions.
6075 That's because `inhibit-modification-hooks' is temporarily set non-nil.
6077 If an unhandled error happens in running these functions,
6078 the variable's value remains nil. That prevents the error
6079 from happening repeatedly and making Emacs nonfunctional. */);
6080 Vafter_change_functions
= Qnil
;
6082 DEFVAR_LISP ("first-change-hook", Vfirst_change_hook
,
6083 doc
: /* A list of functions to call before changing a buffer which is unmodified.
6084 The functions are run using the `run-hooks' function. */);
6085 Vfirst_change_hook
= Qnil
;
6087 DEFVAR_PER_BUFFER ("buffer-undo-list", &BVAR (current_buffer
, undo_list
), Qnil
,
6088 doc
: /* List of undo entries in current buffer.
6089 Recent changes come first; older changes follow newer.
6091 An entry (BEG . END) represents an insertion which begins at
6092 position BEG and ends at position END.
6094 An entry (TEXT . POSITION) represents the deletion of the string TEXT
6095 from (abs POSITION). If POSITION is positive, point was at the front
6096 of the text being deleted; if negative, point was at the end.
6098 An entry (t HIGH LOW USEC PSEC) indicates that the buffer was previously
6099 unmodified; (HIGH LOW USEC PSEC) is in the same style as (current-time)
6100 and is the visited file's modification time, as of that time. If the
6101 modification time of the most recent save is different, this entry is
6104 An entry (t . 0) means means the buffer was previously unmodified but
6105 its time stamp was unknown because it was not associated with a file.
6106 An entry (t . -1) is similar, except that it means the buffer's visited
6109 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
6110 was modified between BEG and END. PROPERTY is the property name,
6111 and VALUE is the old value.
6113 An entry (apply FUN-NAME . ARGS) means undo the change with
6114 \(apply FUN-NAME ARGS).
6116 An entry (apply DELTA BEG END FUN-NAME . ARGS) supports selective undo
6117 in the active region. BEG and END is the range affected by this entry
6118 and DELTA is the number of bytes added or deleted in that range by
6121 An entry (MARKER . DISTANCE) indicates that the marker MARKER
6122 was adjusted in position by the offset DISTANCE (an integer).
6124 An entry of the form POSITION indicates that point was at the buffer
6125 location given by the integer. Undoing an entry of this form places
6128 Entries with value `nil' mark undo boundaries. The undo command treats
6129 the changes between two undo boundaries as a single step to be undone.
6131 If the value of the variable is t, undo information is not recorded. */);
6133 DEFVAR_PER_BUFFER ("mark-active", &BVAR (current_buffer
, mark_active
), Qnil
,
6134 doc
: /* Non-nil means the mark and region are currently active in this buffer. */);
6136 DEFVAR_PER_BUFFER ("cache-long-scans", &BVAR (current_buffer
, cache_long_scans
), Qnil
,
6137 doc
: /* Non-nil means that Emacs should use caches in attempt to speedup buffer scans.
6139 Normally, the line-motion functions work by scanning the buffer for
6140 newlines. Columnar operations (like `move-to-column' and
6141 `compute-motion') also work by scanning the buffer, summing character
6142 widths as they go. This works well for ordinary text, but if the
6143 buffer's lines are very long (say, more than 500 characters), these
6144 motion functions will take longer to execute. Emacs may also take
6145 longer to update the display.
6147 If `cache-long-scans' is non-nil, these motion functions cache the
6148 results of their scans, and consult the cache to avoid rescanning
6149 regions of the buffer until the text is modified. The caches are most
6150 beneficial when they prevent the most searching---that is, when the
6151 buffer contains long lines and large regions of characters with the
6152 same, fixed screen width.
6154 When `cache-long-scans' is non-nil, processing short lines will
6155 become slightly slower (because of the overhead of consulting the
6156 cache), and the caches will use memory roughly proportional to the
6157 number of newlines and characters whose screen width varies.
6159 Bidirectional editing also requires buffer scans to find paragraph
6160 separators. If you have large paragraphs or no paragraph separators
6161 at all, these scans may be slow. If `cache-long-scans' is non-nil,
6162 results of these scans are cached. This doesn't help too much if
6163 paragraphs are of the reasonable (few thousands of characters) size.
6165 The caches require no explicit maintenance; their accuracy is
6166 maintained internally by the Emacs primitives. Enabling or disabling
6167 the cache should not affect the behavior of any of the motion
6168 functions; it should only affect their performance. */);
6170 DEFVAR_PER_BUFFER ("point-before-scroll", &BVAR (current_buffer
, point_before_scroll
), Qnil
,
6171 doc
: /* Value of point before the last series of scroll operations, or nil. */);
6173 DEFVAR_PER_BUFFER ("buffer-file-format", &BVAR (current_buffer
, file_format
), Qnil
,
6174 doc
: /* List of formats to use when saving this buffer.
6175 Formats are defined by `format-alist'. This variable is
6176 set when a file is visited. */);
6178 DEFVAR_PER_BUFFER ("buffer-auto-save-file-format",
6179 &BVAR (current_buffer
, auto_save_file_format
), Qnil
,
6180 doc
: /* Format in which to write auto-save files.
6181 Should be a list of symbols naming formats that are defined in `format-alist'.
6182 If it is t, which is the default, auto-save files are written in the
6183 same format as a regular save would use. */);
6185 DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
6186 &BVAR (current_buffer
, invisibility_spec
), Qnil
,
6187 doc
: /* Invisibility spec of this buffer.
6188 The default is t, which means that text is invisible
6189 if it has a non-nil `invisible' property.
6190 If the value is a list, a text character is invisible if its `invisible'
6191 property is an element in that list (or is a list with members in common).
6192 If an element is a cons cell of the form (PROP . ELLIPSIS),
6193 then characters with property value PROP are invisible,
6194 and they have an ellipsis as well if ELLIPSIS is non-nil. */);
6196 DEFVAR_PER_BUFFER ("buffer-display-count",
6197 &BVAR (current_buffer
, display_count
), Qintegerp
,
6198 doc
: /* A number incremented each time this buffer is displayed in a window.
6199 The function `set-window-buffer' increments it. */);
6201 DEFVAR_PER_BUFFER ("buffer-display-time",
6202 &BVAR (current_buffer
, display_time
), Qnil
,
6203 doc
: /* Time stamp updated each time this buffer is displayed in a window.
6204 The function `set-window-buffer' updates this variable
6205 to the value obtained by calling `current-time'.
6206 If the buffer has never been shown in a window, the value is nil. */);
6208 DEFVAR_LISP ("transient-mark-mode", Vtransient_mark_mode
,
6209 doc
: /* Non-nil if Transient Mark mode is enabled.
6210 See the command `transient-mark-mode' for a description of this minor mode.
6212 Non-nil also enables highlighting of the region whenever the mark is active.
6213 The variable `highlight-nonselected-windows' controls whether to highlight
6214 all windows or just the selected window.
6216 Lisp programs may give this variable certain special values:
6218 - A value of `lambda' enables Transient Mark mode temporarily.
6219 It is disabled again after any subsequent action that would
6220 normally deactivate the mark (e.g. buffer modification).
6222 - A value of (only . OLDVAL) enables Transient Mark mode
6223 temporarily. After any subsequent point motion command that is
6224 not shift-translated, or any other action that would normally
6225 deactivate the mark (e.g. buffer modification), the value of
6226 `transient-mark-mode' is set to OLDVAL. */);
6227 Vtransient_mark_mode
= Qnil
;
6229 DEFVAR_LISP ("inhibit-read-only", Vinhibit_read_only
,
6230 doc
: /* Non-nil means disregard read-only status of buffers or characters.
6231 If the value is t, disregard `buffer-read-only' and all `read-only'
6232 text properties. If the value is a list, disregard `buffer-read-only'
6233 and disregard a `read-only' text property if the property value
6234 is a member of the list. */);
6235 Vinhibit_read_only
= Qnil
;
6237 DEFVAR_PER_BUFFER ("cursor-type", &BVAR (current_buffer
, cursor_type
), Qnil
,
6238 doc
: /* Cursor to use when this buffer is in the selected window.
6239 Values are interpreted as follows:
6241 t use the cursor specified for the frame
6242 nil don't display a cursor
6243 box display a filled box cursor
6244 hollow display a hollow box cursor
6245 bar display a vertical bar cursor with default width
6246 (bar . WIDTH) display a vertical bar cursor with width WIDTH
6247 hbar display a horizontal bar cursor with default height
6248 (hbar . HEIGHT) display a horizontal bar cursor with height HEIGHT
6249 ANYTHING ELSE display a hollow box cursor
6251 When the buffer is displayed in a non-selected window, the
6252 cursor's appearance is instead controlled by the variable
6253 `cursor-in-non-selected-windows'. */);
6255 DEFVAR_PER_BUFFER ("line-spacing",
6256 &BVAR (current_buffer
, extra_line_spacing
), Qnumberp
,
6257 doc
: /* Additional space to put between lines when displaying a buffer.
6258 The space is measured in pixels, and put below lines on graphic displays,
6259 see `display-graphic-p'.
6260 If value is a floating point number, it specifies the spacing relative
6261 to the default frame line height. A value of nil means add no extra space. */);
6263 DEFVAR_PER_BUFFER ("cursor-in-non-selected-windows",
6264 &BVAR (current_buffer
, cursor_in_non_selected_windows
), Qnil
,
6265 doc
: /* Non-nil means show a cursor in non-selected windows.
6266 If nil, only shows a cursor in the selected window.
6267 If t, displays a cursor related to the usual cursor type
6268 \(a solid box becomes hollow, a bar becomes a narrower bar).
6269 You can also specify the cursor type as in the `cursor-type' variable.
6270 Use Custom to set this variable and update the display." */);
6272 DEFVAR_LISP ("kill-buffer-query-functions", Vkill_buffer_query_functions
,
6273 doc
: /* List of functions called with no args to query before killing a buffer.
6274 The buffer being killed will be current while the functions are running.
6276 If any of them returns nil, the buffer is not killed. Functions run by
6277 this hook are supposed to not change the current buffer. */);
6278 Vkill_buffer_query_functions
= Qnil
;
6280 DEFVAR_LISP ("change-major-mode-hook", Vchange_major_mode_hook
,
6281 doc
: /* Normal hook run before changing the major mode of a buffer.
6282 The function `kill-all-local-variables' runs this before doing anything else. */);
6283 Vchange_major_mode_hook
= Qnil
;
6284 DEFSYM (Qchange_major_mode_hook
, "change-major-mode-hook");
6286 DEFVAR_LISP ("buffer-list-update-hook", Vbuffer_list_update_hook
,
6287 doc
: /* Hook run when the buffer list changes.
6288 Functions running this hook are `get-buffer-create',
6289 `make-indirect-buffer', `rename-buffer', `kill-buffer',
6290 and `bury-buffer-internal'. */);
6291 Vbuffer_list_update_hook
= Qnil
;
6292 DEFSYM (Qbuffer_list_update_hook
, "buffer-list-update-hook");
6294 defsubr (&Sbuffer_live_p
);
6295 defsubr (&Sbuffer_list
);
6296 defsubr (&Sget_buffer
);
6297 defsubr (&Sget_file_buffer
);
6298 defsubr (&Sget_buffer_create
);
6299 defsubr (&Smake_indirect_buffer
);
6300 defsubr (&Sgenerate_new_buffer_name
);
6301 defsubr (&Sbuffer_name
);
6302 defsubr (&Sbuffer_file_name
);
6303 defsubr (&Sbuffer_base_buffer
);
6304 defsubr (&Sbuffer_local_value
);
6305 defsubr (&Sbuffer_local_variables
);
6306 defsubr (&Sbuffer_modified_p
);
6307 defsubr (&Sset_buffer_modified_p
);
6308 defsubr (&Sbuffer_modified_tick
);
6309 defsubr (&Sbuffer_chars_modified_tick
);
6310 defsubr (&Srename_buffer
);
6311 defsubr (&Sother_buffer
);
6312 defsubr (&Sbuffer_enable_undo
);
6313 defsubr (&Skill_buffer
);
6314 defsubr (&Sbury_buffer_internal
);
6315 defsubr (&Sset_buffer_major_mode
);
6316 defsubr (&Scurrent_buffer
);
6317 defsubr (&Sset_buffer
);
6318 defsubr (&Sbarf_if_buffer_read_only
);
6319 defsubr (&Serase_buffer
);
6320 defsubr (&Sbuffer_swap_text
);
6321 defsubr (&Sset_buffer_multibyte
);
6322 defsubr (&Skill_all_local_variables
);
6324 defsubr (&Soverlayp
);
6325 defsubr (&Smake_overlay
);
6326 defsubr (&Sdelete_overlay
);
6327 defsubr (&Sdelete_all_overlays
);
6328 defsubr (&Smove_overlay
);
6329 defsubr (&Soverlay_start
);
6330 defsubr (&Soverlay_end
);
6331 defsubr (&Soverlay_buffer
);
6332 defsubr (&Soverlay_properties
);
6333 defsubr (&Soverlays_at
);
6334 defsubr (&Soverlays_in
);
6335 defsubr (&Snext_overlay_change
);
6336 defsubr (&Sprevious_overlay_change
);
6337 defsubr (&Soverlay_recenter
);
6338 defsubr (&Soverlay_lists
);
6339 defsubr (&Soverlay_get
);
6340 defsubr (&Soverlay_put
);
6341 defsubr (&Srestore_buffer_modified_p
);
6345 keys_of_buffer (void)
6347 initial_define_key (control_x_map
, 'b', "switch-to-buffer");
6348 initial_define_key (control_x_map
, 'k', "kill-buffer");
6350 /* This must not be in syms_of_buffer, because Qdisabled is not
6351 initialized when that function gets called. */
6352 Fput (intern_c_string ("erase-buffer"), Qdisabled
, Qt
);