1 /* Buffer manipulation primitives for GNU Emacs.
3 Copyright (C) 1985-1989, 1993-1995, 1997-2012 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
22 #define BUFFER_INLINE EXTERN_INLINE
24 #include <sys/types.h>
26 #include <sys/param.h>
34 #include "intervals.h"
37 #include "character.h"
39 #include "region-cache.h"
41 #include "blockinput.h"
46 struct buffer
*current_buffer
; /* The current buffer. */
48 /* First buffer in chain of all buffers (in reverse order of creation).
49 Threaded through ->header.next.buffer. */
51 struct buffer
*all_buffers
;
53 /* This structure holds the default values of the buffer-local variables
54 defined with DEFVAR_PER_BUFFER, that have special slots in each buffer.
55 The default value occupies the same slot in this structure
56 as an individual buffer's value occupies in that buffer.
57 Setting the default value also goes through the alist of buffers
58 and stores into each buffer that does not say it has a local value. */
60 struct buffer
alignas (GCALIGNMENT
) buffer_defaults
;
62 /* This structure marks which slots in a buffer have corresponding
63 default values in buffer_defaults.
64 Each such slot has a nonzero value in this structure.
65 The value has only one nonzero bit.
67 When a buffer has its own local value for a slot,
68 the entry for that slot (found in the same slot in this structure)
69 is turned on in the buffer's local_flags array.
71 If a slot in this structure is -1, then even though there may
72 be a DEFVAR_PER_BUFFER for the slot, there is no default value for it;
73 and the corresponding slot in buffer_defaults is not used.
75 If a slot in this structure corresponding to a DEFVAR_PER_BUFFER is
76 zero, that is a bug. */
78 struct buffer buffer_local_flags
;
80 /* This structure holds the names of symbols whose values may be
81 buffer-local. It is indexed and accessed in the same way as the above. */
83 struct buffer
alignas (GCALIGNMENT
) buffer_local_symbols
;
85 /* Return the symbol of the per-buffer variable at offset OFFSET in
86 the buffer structure. */
88 #define PER_BUFFER_SYMBOL(OFFSET) \
89 (*(Lisp_Object *)((OFFSET) + (char *) &buffer_local_symbols))
91 /* Maximum length of an overlay vector. */
92 #define OVERLAY_COUNT_MAX \
93 ((ptrdiff_t) min (MOST_POSITIVE_FIXNUM, \
94 min (PTRDIFF_MAX, SIZE_MAX) / word_size))
96 /* Flags indicating which built-in buffer-local variables
97 are permanent locals. */
98 static char buffer_permanent_local_flags
[MAX_PER_BUFFER_VARS
];
100 /* Number of per-buffer variables used. */
102 int last_per_buffer_idx
;
104 static void call_overlay_mod_hooks (Lisp_Object list
, Lisp_Object overlay
,
105 bool after
, Lisp_Object arg1
,
106 Lisp_Object arg2
, Lisp_Object arg3
);
107 static void swap_out_buffer_local_variables (struct buffer
*b
);
108 static void reset_buffer_local_variables (struct buffer
*, bool);
110 /* Alist of all buffer names vs the buffers. */
111 /* This used to be a variable, but is no longer,
112 to prevent lossage due to user rplac'ing this alist or its elements. */
113 Lisp_Object Vbuffer_alist
;
115 static Lisp_Object Qkill_buffer_query_functions
;
117 /* Hook run before changing a major mode. */
118 static Lisp_Object Qchange_major_mode_hook
;
120 Lisp_Object Qfirst_change_hook
;
121 Lisp_Object Qbefore_change_functions
;
122 Lisp_Object Qafter_change_functions
;
124 static Lisp_Object Qfundamental_mode
, Qmode_class
, Qpermanent_local
;
125 static Lisp_Object Qpermanent_local_hook
;
127 static Lisp_Object Qprotected_field
;
129 static Lisp_Object QSFundamental
; /* A string "Fundamental". */
131 static Lisp_Object Qkill_buffer_hook
;
132 static Lisp_Object Qbuffer_list_update_hook
;
134 static Lisp_Object Qget_file_buffer
;
136 static Lisp_Object Qoverlayp
;
138 Lisp_Object Qpriority
, Qbefore_string
, Qafter_string
;
140 static Lisp_Object Qevaporate
;
142 Lisp_Object Qmodification_hooks
;
143 Lisp_Object Qinsert_in_front_hooks
;
144 Lisp_Object Qinsert_behind_hooks
;
146 static void alloc_buffer_text (struct buffer
*, ptrdiff_t);
147 static void free_buffer_text (struct buffer
*b
);
148 static struct Lisp_Overlay
* copy_overlays (struct buffer
*, struct Lisp_Overlay
*);
149 static void modify_overlay (struct buffer
*, ptrdiff_t, ptrdiff_t);
150 static Lisp_Object
buffer_lisp_local_variables (struct buffer
*, bool);
152 /* These setters are used only in this file, so they can be private. */
154 bset_abbrev_mode (struct buffer
*b
, Lisp_Object val
)
156 b
->INTERNAL_FIELD (abbrev_mode
) = val
;
159 bset_abbrev_table (struct buffer
*b
, Lisp_Object val
)
161 b
->INTERNAL_FIELD (abbrev_table
) = val
;
164 bset_auto_fill_function (struct buffer
*b
, Lisp_Object val
)
166 b
->INTERNAL_FIELD (auto_fill_function
) = val
;
169 bset_auto_save_file_format (struct buffer
*b
, Lisp_Object val
)
171 b
->INTERNAL_FIELD (auto_save_file_format
) = val
;
174 bset_auto_save_file_name (struct buffer
*b
, Lisp_Object val
)
176 b
->INTERNAL_FIELD (auto_save_file_name
) = val
;
179 bset_backed_up (struct buffer
*b
, Lisp_Object val
)
181 b
->INTERNAL_FIELD (backed_up
) = val
;
184 bset_begv_marker (struct buffer
*b
, Lisp_Object val
)
186 b
->INTERNAL_FIELD (begv_marker
) = val
;
189 bset_bidi_display_reordering (struct buffer
*b
, Lisp_Object val
)
191 b
->INTERNAL_FIELD (bidi_display_reordering
) = val
;
194 bset_buffer_file_coding_system (struct buffer
*b
, Lisp_Object val
)
196 b
->INTERNAL_FIELD (buffer_file_coding_system
) = val
;
199 bset_cache_long_line_scans (struct buffer
*b
, Lisp_Object val
)
201 b
->INTERNAL_FIELD (cache_long_line_scans
) = val
;
204 bset_case_fold_search (struct buffer
*b
, Lisp_Object val
)
206 b
->INTERNAL_FIELD (case_fold_search
) = val
;
209 bset_ctl_arrow (struct buffer
*b
, Lisp_Object val
)
211 b
->INTERNAL_FIELD (ctl_arrow
) = val
;
214 bset_cursor_in_non_selected_windows (struct buffer
*b
, Lisp_Object val
)
216 b
->INTERNAL_FIELD (cursor_in_non_selected_windows
) = val
;
219 bset_cursor_type (struct buffer
*b
, Lisp_Object val
)
221 b
->INTERNAL_FIELD (cursor_type
) = val
;
224 bset_display_table (struct buffer
*b
, Lisp_Object val
)
226 b
->INTERNAL_FIELD (display_table
) = val
;
229 bset_extra_line_spacing (struct buffer
*b
, Lisp_Object val
)
231 b
->INTERNAL_FIELD (extra_line_spacing
) = val
;
234 bset_file_format (struct buffer
*b
, Lisp_Object val
)
236 b
->INTERNAL_FIELD (file_format
) = val
;
239 bset_file_truename (struct buffer
*b
, Lisp_Object val
)
241 b
->INTERNAL_FIELD (file_truename
) = val
;
244 bset_fringe_cursor_alist (struct buffer
*b
, Lisp_Object val
)
246 b
->INTERNAL_FIELD (fringe_cursor_alist
) = val
;
249 bset_fringe_indicator_alist (struct buffer
*b
, Lisp_Object val
)
251 b
->INTERNAL_FIELD (fringe_indicator_alist
) = val
;
254 bset_fringes_outside_margins (struct buffer
*b
, Lisp_Object val
)
256 b
->INTERNAL_FIELD (fringes_outside_margins
) = val
;
259 bset_header_line_format (struct buffer
*b
, Lisp_Object val
)
261 b
->INTERNAL_FIELD (header_line_format
) = val
;
264 bset_indicate_buffer_boundaries (struct buffer
*b
, Lisp_Object val
)
266 b
->INTERNAL_FIELD (indicate_buffer_boundaries
) = val
;
269 bset_indicate_empty_lines (struct buffer
*b
, Lisp_Object val
)
271 b
->INTERNAL_FIELD (indicate_empty_lines
) = val
;
274 bset_invisibility_spec (struct buffer
*b
, Lisp_Object val
)
276 b
->INTERNAL_FIELD (invisibility_spec
) = val
;
279 bset_left_fringe_width (struct buffer
*b
, Lisp_Object val
)
281 b
->INTERNAL_FIELD (left_fringe_width
) = val
;
284 bset_major_mode (struct buffer
*b
, Lisp_Object val
)
286 b
->INTERNAL_FIELD (major_mode
) = val
;
289 bset_mark (struct buffer
*b
, Lisp_Object val
)
291 b
->INTERNAL_FIELD (mark
) = val
;
294 bset_minor_modes (struct buffer
*b
, Lisp_Object val
)
296 b
->INTERNAL_FIELD (minor_modes
) = val
;
299 bset_mode_line_format (struct buffer
*b
, Lisp_Object val
)
301 b
->INTERNAL_FIELD (mode_line_format
) = val
;
304 bset_mode_name (struct buffer
*b
, Lisp_Object val
)
306 b
->INTERNAL_FIELD (mode_name
) = val
;
309 bset_name (struct buffer
*b
, Lisp_Object val
)
311 b
->INTERNAL_FIELD (name
) = val
;
314 bset_overwrite_mode (struct buffer
*b
, Lisp_Object val
)
316 b
->INTERNAL_FIELD (overwrite_mode
) = val
;
319 bset_pt_marker (struct buffer
*b
, Lisp_Object val
)
321 b
->INTERNAL_FIELD (pt_marker
) = val
;
324 bset_right_fringe_width (struct buffer
*b
, Lisp_Object val
)
326 b
->INTERNAL_FIELD (right_fringe_width
) = val
;
329 bset_save_length (struct buffer
*b
, Lisp_Object val
)
331 b
->INTERNAL_FIELD (save_length
) = val
;
334 bset_scroll_bar_width (struct buffer
*b
, Lisp_Object val
)
336 b
->INTERNAL_FIELD (scroll_bar_width
) = val
;
339 bset_scroll_down_aggressively (struct buffer
*b
, Lisp_Object val
)
341 b
->INTERNAL_FIELD (scroll_down_aggressively
) = val
;
344 bset_scroll_up_aggressively (struct buffer
*b
, Lisp_Object val
)
346 b
->INTERNAL_FIELD (scroll_up_aggressively
) = val
;
349 bset_selective_display (struct buffer
*b
, Lisp_Object val
)
351 b
->INTERNAL_FIELD (selective_display
) = val
;
354 bset_selective_display_ellipses (struct buffer
*b
, Lisp_Object val
)
356 b
->INTERNAL_FIELD (selective_display_ellipses
) = val
;
359 bset_vertical_scroll_bar_type (struct buffer
*b
, Lisp_Object val
)
361 b
->INTERNAL_FIELD (vertical_scroll_bar_type
) = val
;
364 bset_word_wrap (struct buffer
*b
, Lisp_Object val
)
366 b
->INTERNAL_FIELD (word_wrap
) = val
;
369 bset_zv_marker (struct buffer
*b
, Lisp_Object val
)
371 b
->INTERNAL_FIELD (zv_marker
) = val
;
374 /* For debugging; temporary. See set_buffer_internal. */
375 /* Lisp_Object Qlisp_mode, Vcheck_symbol; */
378 nsberror (Lisp_Object spec
)
381 error ("No buffer named %s", SDATA (spec
));
382 error ("Invalid buffer argument");
385 DEFUN ("buffer-live-p", Fbuffer_live_p
, Sbuffer_live_p
, 1, 1, 0,
386 doc
: /* Return non-nil if OBJECT is a buffer which has not been killed.
387 Value is nil if OBJECT is not a buffer or if it has been killed. */)
390 return ((BUFFERP (object
) && BUFFER_LIVE_P (XBUFFER (object
)))
394 DEFUN ("buffer-list", Fbuffer_list
, Sbuffer_list
, 0, 1, 0,
395 doc
: /* Return a list of all existing live buffers.
396 If the optional arg FRAME is a frame, we return the buffer list in the
397 proper order for that frame: the buffers show in FRAME come first,
398 followed by the rest of the buffers. */)
402 general
= Fmapcar (Qcdr
, Vbuffer_alist
);
406 Lisp_Object framelist
, prevlist
, tail
;
410 framelist
= Fcopy_sequence (XFRAME (frame
)->buffer_list
);
411 prevlist
= Fnreverse (Fcopy_sequence
412 (XFRAME (frame
)->buried_buffer_list
));
414 /* Remove from GENERAL any buffer that duplicates one in
415 FRAMELIST or PREVLIST. */
419 general
= Fdelq (XCAR (tail
), general
);
425 general
= Fdelq (XCAR (tail
), general
);
432 return Fnconc (3, args
);
438 /* Like Fassoc, but use Fstring_equal to compare
439 (which ignores text properties),
440 and don't ever QUIT. */
443 assoc_ignore_text_properties (register Lisp_Object key
, Lisp_Object list
)
445 register Lisp_Object tail
;
446 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
448 register Lisp_Object elt
, tem
;
450 tem
= Fstring_equal (Fcar (elt
), key
);
457 DEFUN ("get-buffer", Fget_buffer
, Sget_buffer
, 1, 1, 0,
458 doc
: /* Return the buffer named BUFFER-OR-NAME.
459 BUFFER-OR-NAME must be either a string or a buffer. If BUFFER-OR-NAME
460 is a string and there is no buffer with that name, return nil. If
461 BUFFER-OR-NAME is a buffer, return it as given. */)
462 (register Lisp_Object buffer_or_name
)
464 if (BUFFERP (buffer_or_name
))
465 return buffer_or_name
;
466 CHECK_STRING (buffer_or_name
);
468 return Fcdr (assoc_ignore_text_properties (buffer_or_name
, Vbuffer_alist
));
471 DEFUN ("get-file-buffer", Fget_file_buffer
, Sget_file_buffer
, 1, 1, 0,
472 doc
: /* Return the buffer visiting file FILENAME (a string).
473 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
474 If there is no such live buffer, return nil.
475 See also `find-buffer-visiting'. */)
476 (register Lisp_Object filename
)
478 register Lisp_Object tail
, buf
, tem
;
481 CHECK_STRING (filename
);
482 filename
= Fexpand_file_name (filename
, Qnil
);
484 /* If the file name has special constructs in it,
485 call the corresponding file handler. */
486 handler
= Ffind_file_name_handler (filename
, Qget_file_buffer
);
489 Lisp_Object handled_buf
= call2 (handler
, Qget_file_buffer
,
491 return BUFFERP (handled_buf
) ? handled_buf
: Qnil
;
494 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
496 buf
= Fcdr (XCAR (tail
));
497 if (!BUFFERP (buf
)) continue;
498 if (!STRINGP (BVAR (XBUFFER (buf
), filename
))) continue;
499 tem
= Fstring_equal (BVAR (XBUFFER (buf
), filename
), filename
);
507 get_truename_buffer (register Lisp_Object filename
)
509 register Lisp_Object tail
, buf
, tem
;
511 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
513 buf
= Fcdr (XCAR (tail
));
514 if (!BUFFERP (buf
)) continue;
515 if (!STRINGP (BVAR (XBUFFER (buf
), file_truename
))) continue;
516 tem
= 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. */
552 BUF_GAP_SIZE (b
) = 20;
554 /* We allocate extra 1-byte at the tail and keep it always '\0' for
555 anchoring a search. */
556 alloc_buffer_text (b
, BUF_GAP_SIZE (b
) + 1);
558 if (! BUF_BEG_ADDR (b
))
559 buffer_memory_full (BUF_GAP_SIZE (b
) + 1);
564 b
->pt_byte
= BEG_BYTE
;
565 b
->begv_byte
= BEG_BYTE
;
566 b
->zv_byte
= BEG_BYTE
;
569 BUF_GPT_BYTE (b
) = BEG_BYTE
;
572 BUF_Z_BYTE (b
) = BEG_BYTE
;
574 BUF_CHARS_MODIFF (b
) = 1;
575 BUF_OVERLAY_MODIFF (b
) = 1;
576 BUF_SAVE_MODIFF (b
) = 1;
577 set_buffer_intervals (b
, NULL
);
578 BUF_UNCHANGED_MODIFIED (b
) = 1;
579 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = 1;
580 BUF_END_UNCHANGED (b
) = 0;
581 BUF_BEG_UNCHANGED (b
) = 0;
582 *(BUF_GPT_ADDR (b
)) = *(BUF_Z_ADDR (b
)) = 0; /* Put an anchor '\0'. */
583 b
->text
->inhibit_shrinking
= 0;
585 b
->newline_cache
= 0;
586 b
->width_run_cache
= 0;
587 bset_width_table (b
, Qnil
);
588 b
->prevent_redisplay_optimizations_p
= 1;
590 /* An ordinary buffer normally doesn't need markers
591 to handle BEGV and ZV. */
592 bset_pt_marker (b
, Qnil
);
593 bset_begv_marker (b
, Qnil
);
594 bset_zv_marker (b
, Qnil
);
596 name
= Fcopy_sequence (buffer_or_name
);
597 set_string_intervals (name
, NULL
);
600 bset_undo_list (b
, SREF (name
, 0) != ' ' ? Qnil
: Qt
);
603 reset_buffer_local_variables (b
, 1);
605 bset_mark (b
, Fmake_marker ());
606 BUF_MARKERS (b
) = NULL
;
608 /* Put this in the alist of all live buffers. */
609 XSETBUFFER (buffer
, b
);
610 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buffer
), Qnil
));
611 /* And run buffer-list-update-hook. */
612 if (!NILP (Vrun_hooks
))
613 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
619 /* Return a list of overlays which is a copy of the overlay list
620 LIST, but for buffer B. */
622 static struct Lisp_Overlay
*
623 copy_overlays (struct buffer
*b
, struct Lisp_Overlay
*list
)
625 struct Lisp_Overlay
*result
= NULL
, *tail
= NULL
;
627 for (; list
; list
= list
->next
)
629 Lisp_Object overlay
, start
, end
;
630 struct Lisp_Marker
*m
;
632 eassert (MARKERP (list
->start
));
633 m
= XMARKER (list
->start
);
634 start
= build_marker (b
, m
->charpos
, m
->bytepos
);
635 XMARKER (start
)->insertion_type
= m
->insertion_type
;
637 eassert (MARKERP (list
->end
));
638 m
= XMARKER (list
->end
);
639 end
= build_marker (b
, m
->charpos
, m
->bytepos
);
640 XMARKER (end
)->insertion_type
= m
->insertion_type
;
642 overlay
= build_overlay (start
, end
, Fcopy_sequence (list
->plist
));
644 tail
= tail
->next
= XOVERLAY (overlay
);
646 result
= tail
= XOVERLAY (overlay
);
652 /* Set an appropriate overlay of B. */
655 set_buffer_overlays_before (struct buffer
*b
, struct Lisp_Overlay
*o
)
657 b
->overlays_before
= o
;
661 set_buffer_overlays_after (struct buffer
*b
, struct Lisp_Overlay
*o
)
663 b
->overlays_after
= o
;
666 /* Clone per-buffer values of buffer FROM.
668 Buffer TO gets the same per-buffer values as FROM, with the
669 following exceptions: (1) TO's name is left untouched, (2) markers
670 are copied and made to refer to TO, and (3) overlay lists are
674 clone_per_buffer_values (struct buffer
*from
, struct buffer
*to
)
678 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
682 /* Don't touch the `name' which should be unique for every buffer. */
683 if (offset
== PER_BUFFER_VAR_OFFSET (name
))
686 obj
= per_buffer_value (from
, offset
);
687 if (MARKERP (obj
) && XMARKER (obj
)->buffer
== from
)
689 struct Lisp_Marker
*m
= XMARKER (obj
);
691 obj
= build_marker (to
, m
->charpos
, m
->bytepos
);
692 XMARKER (obj
)->insertion_type
= m
->insertion_type
;
695 set_per_buffer_value (to
, offset
, obj
);
698 memcpy (to
->local_flags
, from
->local_flags
, sizeof to
->local_flags
);
700 set_buffer_overlays_before (to
, copy_overlays (to
, from
->overlays_before
));
701 set_buffer_overlays_after (to
, copy_overlays (to
, from
->overlays_after
));
703 /* Get (a copy of) the alist of Lisp-level local variables of FROM
704 and install that in TO. */
705 bset_local_var_alist (to
, buffer_lisp_local_variables (from
, 1));
709 /* If buffer B has markers to record PT, BEGV and ZV when it is not
710 current, update these markers. */
713 record_buffer_markers (struct buffer
*b
)
715 if (! NILP (BVAR (b
, pt_marker
)))
719 eassert (!NILP (BVAR (b
, begv_marker
)));
720 eassert (!NILP (BVAR (b
, zv_marker
)));
722 XSETBUFFER (buffer
, b
);
723 set_marker_both (BVAR (b
, pt_marker
), buffer
, b
->pt
, b
->pt_byte
);
724 set_marker_both (BVAR (b
, begv_marker
), buffer
, b
->begv
, b
->begv_byte
);
725 set_marker_both (BVAR (b
, zv_marker
), buffer
, b
->zv
, b
->zv_byte
);
730 /* If buffer B has markers to record PT, BEGV and ZV when it is not
731 current, fetch these values into B->begv etc. */
734 fetch_buffer_markers (struct buffer
*b
)
736 if (! NILP (BVAR (b
, pt_marker
)))
740 eassert (!NILP (BVAR (b
, begv_marker
)));
741 eassert (!NILP (BVAR (b
, zv_marker
)));
743 m
= BVAR (b
, pt_marker
);
744 SET_BUF_PT_BOTH (b
, marker_position (m
), marker_byte_position (m
));
746 m
= BVAR (b
, begv_marker
);
747 SET_BUF_BEGV_BOTH (b
, marker_position (m
), marker_byte_position (m
));
749 m
= BVAR (b
, zv_marker
);
750 SET_BUF_ZV_BOTH (b
, marker_position (m
), marker_byte_position (m
));
755 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer
, Smake_indirect_buffer
,
757 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ",
758 doc
: /* Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.
759 BASE-BUFFER should be a live buffer, or the name of an existing buffer.
760 NAME should be a string which is not the name of an existing buffer.
761 Optional argument CLONE non-nil means preserve BASE-BUFFER's state,
762 such as major and minor modes, in the indirect buffer.
763 CLONE nil means the indirect buffer's state is reset to default values. */)
764 (Lisp_Object base_buffer
, Lisp_Object name
, Lisp_Object clone
)
766 Lisp_Object buf
, tem
;
770 buf
= Fget_buffer (name
);
772 error ("Buffer name `%s' is in use", SDATA (name
));
775 base_buffer
= Fget_buffer (base_buffer
);
776 if (NILP (base_buffer
))
777 error ("No such buffer: `%s'", SDATA (tem
));
778 if (!BUFFER_LIVE_P (XBUFFER (base_buffer
)))
779 error ("Base buffer has been killed");
781 if (SCHARS (name
) == 0)
782 error ("Empty string for buffer name is not allowed");
784 b
= allocate_buffer ();
786 /* No double indirection - if base buffer is indirect,
787 new buffer becomes an indirect to base's base. */
788 b
->base_buffer
= (XBUFFER (base_buffer
)->base_buffer
789 ? XBUFFER (base_buffer
)->base_buffer
790 : XBUFFER (base_buffer
));
792 /* Use the base buffer's text object. */
793 b
->text
= b
->base_buffer
->text
;
794 /* We have no own text. */
795 b
->indirections
= -1;
796 /* Notify base buffer that we share the text now. */
797 b
->base_buffer
->indirections
++;
799 b
->pt
= b
->base_buffer
->pt
;
800 b
->begv
= b
->base_buffer
->begv
;
801 b
->zv
= b
->base_buffer
->zv
;
802 b
->pt_byte
= b
->base_buffer
->pt_byte
;
803 b
->begv_byte
= b
->base_buffer
->begv_byte
;
804 b
->zv_byte
= b
->base_buffer
->zv_byte
;
806 b
->newline_cache
= 0;
807 b
->width_run_cache
= 0;
808 bset_width_table (b
, Qnil
);
810 name
= Fcopy_sequence (name
);
811 set_string_intervals (name
, NULL
);
815 reset_buffer_local_variables (b
, 1);
817 /* Put this in the alist of all live buffers. */
819 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buf
), Qnil
));
821 bset_mark (b
, Fmake_marker ());
823 /* The multibyte status belongs to the base buffer. */
824 bset_enable_multibyte_characters
825 (b
, BVAR (b
->base_buffer
, enable_multibyte_characters
));
827 /* Make sure the base buffer has markers for its narrowing. */
828 if (NILP (BVAR (b
->base_buffer
, pt_marker
)))
830 eassert (NILP (BVAR (b
->base_buffer
, begv_marker
)));
831 eassert (NILP (BVAR (b
->base_buffer
, zv_marker
)));
833 bset_pt_marker (b
->base_buffer
,
834 build_marker (b
->base_buffer
, b
->base_buffer
->pt
,
835 b
->base_buffer
->pt_byte
));
837 bset_begv_marker (b
->base_buffer
,
838 build_marker (b
->base_buffer
, b
->base_buffer
->begv
,
839 b
->base_buffer
->begv_byte
));
841 bset_zv_marker (b
->base_buffer
,
842 build_marker (b
->base_buffer
, b
->base_buffer
->zv
,
843 b
->base_buffer
->zv_byte
));
845 XMARKER (BVAR (b
->base_buffer
, zv_marker
))->insertion_type
= 1;
850 /* Give the indirect buffer markers for its narrowing. */
851 bset_pt_marker (b
, build_marker (b
, b
->pt
, b
->pt_byte
));
852 bset_begv_marker (b
, build_marker (b
, b
->begv
, b
->begv_byte
));
853 bset_zv_marker (b
, build_marker (b
, b
->zv
, b
->zv_byte
));
854 XMARKER (BVAR (b
, zv_marker
))->insertion_type
= 1;
858 struct buffer
*old_b
= current_buffer
;
860 clone_per_buffer_values (b
->base_buffer
, b
);
861 bset_filename (b
, Qnil
);
862 bset_file_truename (b
, Qnil
);
863 bset_display_count (b
, make_number (0));
864 bset_backed_up (b
, Qnil
);
865 bset_auto_save_file_name (b
, Qnil
);
866 set_buffer_internal_1 (b
);
867 Fset (intern ("buffer-save-without-query"), Qnil
);
868 Fset (intern ("buffer-file-number"), Qnil
);
869 Fset (intern ("buffer-stale-function"), Qnil
);
870 set_buffer_internal_1 (old_b
);
873 /* Run buffer-list-update-hook. */
874 if (!NILP (Vrun_hooks
))
875 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
880 /* Mark OV as no longer associated with B. */
883 drop_overlay (struct buffer
*b
, struct Lisp_Overlay
*ov
)
885 eassert (b
== XBUFFER (Fmarker_buffer (ov
->start
)));
886 modify_overlay (b
, marker_position (ov
->start
),
887 marker_position (ov
->end
));
888 Fset_marker (ov
->start
, Qnil
, Qnil
);
889 Fset_marker (ov
->end
, Qnil
, Qnil
);
893 /* Delete all overlays of B and reset it's overlay lists. */
896 delete_all_overlays (struct buffer
*b
)
898 struct Lisp_Overlay
*ov
, *next
;
900 for (ov
= b
->overlays_before
; ov
; ov
= next
)
902 drop_overlay (b
, ov
);
907 for (ov
= b
->overlays_after
; ov
; ov
= next
)
909 drop_overlay (b
, ov
);
914 set_buffer_overlays_before (b
, NULL
);
915 set_buffer_overlays_after (b
, NULL
);
918 /* Reinitialize everything about a buffer except its name and contents
920 If called on an already-initialized buffer, the list of overlays
921 should be deleted before calling this function, otherwise we end up
922 with overlays that claim to belong to the buffer but the buffer
923 claims it doesn't belong to it. */
926 reset_buffer (register struct buffer
*b
)
928 bset_filename (b
, Qnil
);
929 bset_file_truename (b
, Qnil
);
930 bset_directory (b
, current_buffer
? BVAR (current_buffer
, directory
) : Qnil
);
931 b
->modtime
= make_emacs_time (0, UNKNOWN_MODTIME_NSECS
);
932 b
->modtime_size
= -1;
933 XSETFASTINT (BVAR (b
, save_length
), 0);
934 b
->last_window_start
= 1;
935 /* It is more conservative to start out "changed" than "unchanged". */
937 b
->prevent_redisplay_optimizations_p
= 1;
938 bset_backed_up (b
, Qnil
);
939 BUF_AUTOSAVE_MODIFF (b
) = 0;
940 b
->auto_save_failure_time
= 0;
941 bset_auto_save_file_name (b
, Qnil
);
942 bset_read_only (b
, Qnil
);
943 set_buffer_overlays_before (b
, NULL
);
944 set_buffer_overlays_after (b
, NULL
);
945 b
->overlay_center
= BEG
;
946 bset_mark_active (b
, Qnil
);
947 bset_point_before_scroll (b
, Qnil
);
948 bset_file_format (b
, Qnil
);
949 bset_auto_save_file_format (b
, Qt
);
950 bset_last_selected_window (b
, Qnil
);
951 bset_display_count (b
, make_number (0));
952 bset_display_time (b
, Qnil
);
953 bset_enable_multibyte_characters
954 (b
, BVAR (&buffer_defaults
, enable_multibyte_characters
));
955 bset_cursor_type (b
, BVAR (&buffer_defaults
, cursor_type
));
956 bset_extra_line_spacing (b
, BVAR (&buffer_defaults
, extra_line_spacing
));
958 b
->display_error_modiff
= 0;
961 /* Reset buffer B's local variables info.
962 Don't use this on a buffer that has already been in use;
963 it does not treat permanent locals consistently.
964 Instead, use Fkill_all_local_variables.
966 If PERMANENT_TOO, reset permanent buffer-local variables.
967 If not, preserve those. */
970 reset_buffer_local_variables (struct buffer
*b
, bool permanent_too
)
974 /* Reset the major mode to Fundamental, together with all the
975 things that depend on the major mode.
976 default-major-mode is handled at a higher level.
977 We ignore it here. */
978 bset_major_mode (b
, Qfundamental_mode
);
979 bset_keymap (b
, Qnil
);
980 bset_mode_name (b
, QSFundamental
);
981 bset_minor_modes (b
, Qnil
);
983 /* If the standard case table has been altered and invalidated,
984 fix up its insides first. */
985 if (! (CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[0])
986 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[1])
987 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[2])))
988 Fset_standard_case_table (Vascii_downcase_table
);
990 bset_downcase_table (b
, Vascii_downcase_table
);
991 bset_upcase_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[0]);
992 bset_case_canon_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[1]);
993 bset_case_eqv_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[2]);
994 bset_invisibility_spec (b
, Qt
);
996 /* Reset all (or most) per-buffer variables to their defaults. */
998 bset_local_var_alist (b
, Qnil
);
1001 Lisp_Object tmp
, prop
, last
= Qnil
;
1002 for (tmp
= BVAR (b
, local_var_alist
); CONSP (tmp
); tmp
= XCDR (tmp
))
1003 if (!NILP (prop
= Fget (XCAR (XCAR (tmp
)), Qpermanent_local
)))
1005 /* If permanent-local, keep it. */
1007 if (EQ (prop
, Qpermanent_local_hook
))
1009 /* This is a partially permanent hook variable.
1010 Preserve only the elements that want to be preserved. */
1011 Lisp_Object list
, newlist
;
1012 list
= XCDR (XCAR (tmp
));
1016 for (newlist
= Qnil
; CONSP (list
); list
= XCDR (list
))
1018 Lisp_Object elt
= XCAR (list
);
1019 /* Preserve element ELT if it's t,
1020 if it is a function with a `permanent-local-hook' property,
1021 or if it's not a symbol. */
1024 || !NILP (Fget (elt
, Qpermanent_local_hook
)))
1025 newlist
= Fcons (elt
, newlist
);
1027 XSETCDR (XCAR (tmp
), Fnreverse (newlist
));
1030 /* Delete this local variable. */
1031 else if (NILP (last
))
1032 bset_local_var_alist (b
, XCDR (tmp
));
1034 XSETCDR (last
, XCDR (tmp
));
1037 for (i
= 0; i
< last_per_buffer_idx
; ++i
)
1038 if (permanent_too
|| buffer_permanent_local_flags
[i
] == 0)
1039 SET_PER_BUFFER_VALUE_P (b
, i
, 0);
1041 /* For each slot that has a default value, copy that into the slot. */
1042 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
1044 int idx
= PER_BUFFER_IDX (offset
);
1047 || buffer_permanent_local_flags
[idx
] == 0)))
1048 set_per_buffer_value (b
, offset
, per_buffer_default (offset
));
1052 /* We split this away from generate-new-buffer, because rename-buffer
1053 and set-visited-file-name ought to be able to use this to really
1054 rename the buffer properly. */
1056 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name
,
1057 Sgenerate_new_buffer_name
, 1, 2, 0,
1058 doc
: /* Return a string that is the name of no existing buffer based on NAME.
1059 If there is no live buffer named NAME, then return NAME.
1060 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
1061 \(starting at 2) until an unused name is found, and then return that name.
1062 Optional second argument IGNORE specifies a name that is okay to use (if
1063 it is in the sequence to be tried) even if a buffer with that name exists.
1065 If NAME begins with a space (i.e., a buffer that is not normally
1066 visible to users), then if buffer NAME already exists a random number
1067 is first appended to NAME, to speed up finding a non-existent buffer. */)
1068 (register Lisp_Object name
, Lisp_Object ignore
)
1070 register Lisp_Object gentemp
, tem
, tem2
;
1072 char number
[INT_BUFSIZE_BOUND (ptrdiff_t) + sizeof "<>"];
1074 CHECK_STRING (name
);
1076 tem
= Fstring_equal (name
, ignore
);
1079 tem
= Fget_buffer (name
);
1083 if (!strncmp (SSDATA (name
), " ", 1)) /* see bug#1229 */
1085 /* Note fileio.c:make_temp_name does random differently. */
1086 tem2
= concat2 (name
, make_formatted_string
1088 XFASTINT (Frandom (make_number (999999)))));
1089 tem
= Fget_buffer (tem2
);
1099 gentemp
= concat2 (tem2
, make_formatted_string
1100 (number
, "<%"pD
"d>", ++count
));
1101 tem
= Fstring_equal (gentemp
, ignore
);
1104 tem
= Fget_buffer (gentemp
);
1111 DEFUN ("buffer-name", Fbuffer_name
, Sbuffer_name
, 0, 1, 0,
1112 doc
: /* Return the name of BUFFER, as a string.
1113 BUFFER defaults to the current buffer.
1114 Return nil if BUFFER has been killed. */)
1115 (register Lisp_Object buffer
)
1118 return BVAR (current_buffer
, name
);
1119 CHECK_BUFFER (buffer
);
1120 return BVAR (XBUFFER (buffer
), name
);
1123 DEFUN ("buffer-file-name", Fbuffer_file_name
, Sbuffer_file_name
, 0, 1, 0,
1124 doc
: /* Return name of file BUFFER is visiting, or nil if none.
1125 No argument or nil as argument means use the current buffer. */)
1126 (register Lisp_Object buffer
)
1129 return BVAR (current_buffer
, filename
);
1130 CHECK_BUFFER (buffer
);
1131 return BVAR (XBUFFER (buffer
), filename
);
1134 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer
, Sbuffer_base_buffer
,
1136 doc
: /* Return the base buffer of indirect buffer BUFFER.
1137 If BUFFER is not indirect, return nil.
1138 BUFFER defaults to the current buffer. */)
1139 (register Lisp_Object buffer
)
1141 struct buffer
*base
;
1142 Lisp_Object base_buffer
;
1145 base
= current_buffer
->base_buffer
;
1148 CHECK_BUFFER (buffer
);
1149 base
= XBUFFER (buffer
)->base_buffer
;
1154 XSETBUFFER (base_buffer
, base
);
1158 DEFUN ("buffer-local-value", Fbuffer_local_value
,
1159 Sbuffer_local_value
, 2, 2, 0,
1160 doc
: /* Return the value of VARIABLE in BUFFER.
1161 If VARIABLE does not have a buffer-local binding in BUFFER, the value
1162 is the default binding of the variable. */)
1163 (register Lisp_Object variable
, register Lisp_Object buffer
)
1165 register Lisp_Object result
= buffer_local_value_1 (variable
, buffer
);
1167 if (EQ (result
, Qunbound
))
1168 xsignal1 (Qvoid_variable
, variable
);
1174 /* Like Fbuffer_local_value, but return Qunbound if the variable is
1178 buffer_local_value_1 (Lisp_Object variable
, Lisp_Object buffer
)
1180 register struct buffer
*buf
;
1181 register Lisp_Object result
;
1182 struct Lisp_Symbol
*sym
;
1184 CHECK_SYMBOL (variable
);
1185 CHECK_BUFFER (buffer
);
1186 buf
= XBUFFER (buffer
);
1187 sym
= XSYMBOL (variable
);
1190 switch (sym
->redirect
)
1192 case SYMBOL_VARALIAS
: sym
= indirect_variable (sym
); goto start
;
1193 case SYMBOL_PLAINVAL
: result
= SYMBOL_VAL (sym
); break;
1194 case SYMBOL_LOCALIZED
:
1195 { /* Look in local_var_alist. */
1196 struct Lisp_Buffer_Local_Value
*blv
= SYMBOL_BLV (sym
);
1197 XSETSYMBOL (variable
, sym
); /* Update In case of aliasing. */
1198 result
= Fassoc (variable
, BVAR (buf
, local_var_alist
));
1202 { /* What binding is loaded right now? */
1203 Lisp_Object current_alist_element
= blv
->valcell
;
1205 /* The value of the currently loaded binding is not
1206 stored in it, but rather in the realvalue slot.
1207 Store that value into the binding it belongs to
1208 in case that is the one we are about to use. */
1210 XSETCDR (current_alist_element
,
1211 do_symval_forwarding (blv
->fwd
));
1213 /* Now get the (perhaps updated) value out of the binding. */
1214 result
= XCDR (result
);
1217 result
= Fdefault_value (variable
);
1220 case SYMBOL_FORWARDED
:
1222 union Lisp_Fwd
*fwd
= SYMBOL_FWD (sym
);
1223 if (BUFFER_OBJFWDP (fwd
))
1224 result
= per_buffer_value (buf
, XBUFFER_OBJFWD (fwd
)->offset
);
1226 result
= Fdefault_value (variable
);
1229 default: emacs_abort ();
1235 /* Return an alist of the Lisp-level buffer-local bindings of
1236 buffer BUF. That is, don't include the variables maintained
1237 in special slots in the buffer object.
1238 If not CLONE, replace elements of the form (VAR . unbound)
1242 buffer_lisp_local_variables (struct buffer
*buf
, bool clone
)
1244 Lisp_Object result
= Qnil
;
1246 for (tail
= BVAR (buf
, local_var_alist
); CONSP (tail
); tail
= XCDR (tail
))
1248 Lisp_Object val
, elt
;
1252 /* Reference each variable in the alist in buf.
1253 If inquiring about the current buffer, this gets the current values,
1254 so store them into the alist so the alist is up to date.
1255 If inquiring about some other buffer, this swaps out any values
1256 for that buffer, making the alist up to date automatically. */
1257 val
= find_symbol_value (XCAR (elt
));
1258 /* Use the current buffer value only if buf is the current buffer. */
1259 if (buf
!= current_buffer
)
1262 result
= Fcons (!clone
&& EQ (val
, Qunbound
)
1264 : Fcons (XCAR (elt
), val
),
1271 DEFUN ("buffer-local-variables", Fbuffer_local_variables
,
1272 Sbuffer_local_variables
, 0, 1, 0,
1273 doc
: /* Return an alist of variables that are buffer-local in BUFFER.
1274 Most elements look like (SYMBOL . VALUE), describing one variable.
1275 For a symbol that is locally unbound, just the symbol appears in the value.
1276 Note that storing new VALUEs in these elements doesn't change the variables.
1277 No argument or nil as argument means use current buffer as BUFFER. */)
1278 (register Lisp_Object buffer
)
1280 register struct buffer
*buf
;
1281 register Lisp_Object result
;
1284 buf
= current_buffer
;
1287 CHECK_BUFFER (buffer
);
1288 buf
= XBUFFER (buffer
);
1291 result
= buffer_lisp_local_variables (buf
, 0);
1293 /* Add on all the variables stored in special slots. */
1297 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
1299 idx
= PER_BUFFER_IDX (offset
);
1300 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
1301 && SYMBOLP (PER_BUFFER_SYMBOL (offset
)))
1303 Lisp_Object sym
= PER_BUFFER_SYMBOL (offset
);
1304 Lisp_Object val
= per_buffer_value (buf
, offset
);
1305 result
= Fcons (EQ (val
, Qunbound
) ? sym
: Fcons (sym
, val
),
1314 DEFUN ("buffer-modified-p", Fbuffer_modified_p
, Sbuffer_modified_p
,
1316 doc
: /* Return t if BUFFER was modified since its file was last read or saved.
1317 No argument or nil as argument means use current buffer as BUFFER. */)
1318 (register Lisp_Object buffer
)
1320 register struct buffer
*buf
;
1322 buf
= current_buffer
;
1325 CHECK_BUFFER (buffer
);
1326 buf
= XBUFFER (buffer
);
1329 return BUF_SAVE_MODIFF (buf
) < BUF_MODIFF (buf
) ? Qt
: Qnil
;
1332 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p
, Sset_buffer_modified_p
,
1334 doc
: /* Mark current buffer as modified or unmodified according to FLAG.
1335 A non-nil FLAG means mark the buffer modified. */)
1338 Lisp_Object fn
, buffer
, window
;
1340 #ifdef CLASH_DETECTION
1341 /* If buffer becoming modified, lock the file.
1342 If buffer becoming unmodified, unlock the file. */
1344 fn
= BVAR (current_buffer
, file_truename
);
1345 /* Test buffer-file-name so that binding it to nil is effective. */
1346 if (!NILP (fn
) && ! NILP (BVAR (current_buffer
, filename
)))
1348 bool already
= SAVE_MODIFF
< MODIFF
;
1349 if (!already
&& !NILP (flag
))
1351 else if (already
&& NILP (flag
))
1354 #endif /* CLASH_DETECTION */
1356 /* Here we have a problem. SAVE_MODIFF is used here to encode
1357 buffer-modified-p (as SAVE_MODIFF<MODIFF) as well as
1358 recent-auto-save-p (as SAVE_MODIFF<auto_save_modified). So if we
1359 modify SAVE_MODIFF to affect one, we may affect the other
1361 E.g. if FLAG is nil we need to set SAVE_MODIFF to MODIFF, but
1362 if SAVE_MODIFF<auto_save_modified that means we risk changing
1363 recent-auto-save-p from t to nil.
1364 Vice versa, if FLAG is non-nil and SAVE_MODIFF>=auto_save_modified
1365 we risk changing recent-auto-save-p from nil to t. */
1366 SAVE_MODIFF
= (NILP (flag
)
1367 /* FIXME: This unavoidably sets recent-auto-save-p to nil. */
1369 /* Let's try to preserve recent-auto-save-p. */
1370 : SAVE_MODIFF
< MODIFF
? SAVE_MODIFF
1371 /* If SAVE_MODIFF == auto_save_modified == MODIFF,
1372 we can either decrease SAVE_MODIFF and auto_save_modified
1373 or increase MODIFF. */
1376 /* Set update_mode_lines only if buffer is displayed in some window.
1377 Packages like jit-lock or lazy-lock preserve a buffer's modified
1378 state by recording/restoring the state around blocks of code.
1379 Setting update_mode_lines makes redisplay consider all windows
1380 (on all frames). Stealth fontification of buffers not displayed
1381 would incur additional redisplay costs if we'd set
1382 update_modes_lines unconditionally.
1384 Ideally, I think there should be another mechanism for fontifying
1385 buffers without "modifying" buffers, or redisplay should be
1386 smarter about updating the `*' in mode lines. --gerd */
1387 XSETBUFFER (buffer
, current_buffer
);
1388 window
= Fget_buffer_window (buffer
, Qt
);
1389 if (WINDOWP (window
))
1391 ++update_mode_lines
;
1392 current_buffer
->prevent_redisplay_optimizations_p
= 1;
1398 DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p
,
1399 Srestore_buffer_modified_p
, 1, 1, 0,
1400 doc
: /* Like `set-buffer-modified-p', with a difference concerning redisplay.
1401 It is not ensured that mode lines will be updated to show the modified
1402 state of the current buffer. Use with care. */)
1405 #ifdef CLASH_DETECTION
1408 /* If buffer becoming modified, lock the file.
1409 If buffer becoming unmodified, unlock the file. */
1411 fn
= BVAR (current_buffer
, file_truename
);
1412 /* Test buffer-file-name so that binding it to nil is effective. */
1413 if (!NILP (fn
) && ! NILP (BVAR (current_buffer
, filename
)))
1415 bool already
= SAVE_MODIFF
< MODIFF
;
1416 if (!already
&& !NILP (flag
))
1418 else if (already
&& NILP (flag
))
1421 #endif /* CLASH_DETECTION */
1423 SAVE_MODIFF
= NILP (flag
) ? MODIFF
: 0;
1427 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick
, Sbuffer_modified_tick
,
1429 doc
: /* Return BUFFER's tick counter, incremented for each change in text.
1430 Each buffer has a tick counter which is incremented each time the
1431 text in that buffer is changed. It wraps around occasionally.
1432 No argument or nil as argument means use current buffer as BUFFER. */)
1433 (register Lisp_Object buffer
)
1435 register struct buffer
*buf
;
1437 buf
= current_buffer
;
1440 CHECK_BUFFER (buffer
);
1441 buf
= XBUFFER (buffer
);
1444 return make_number (BUF_MODIFF (buf
));
1447 DEFUN ("buffer-chars-modified-tick", Fbuffer_chars_modified_tick
,
1448 Sbuffer_chars_modified_tick
, 0, 1, 0,
1449 doc
: /* Return BUFFER's character-change tick counter.
1450 Each buffer has a character-change tick counter, which is set to the
1451 value of the buffer's tick counter \(see `buffer-modified-tick'), each
1452 time text in that buffer is inserted or deleted. By comparing the
1453 values returned by two individual calls of `buffer-chars-modified-tick',
1454 you can tell whether a character change occurred in that buffer in
1455 between these calls. No argument or nil as argument means use current
1456 buffer as BUFFER. */)
1457 (register Lisp_Object buffer
)
1459 register struct buffer
*buf
;
1461 buf
= current_buffer
;
1464 CHECK_BUFFER (buffer
);
1465 buf
= XBUFFER (buffer
);
1468 return make_number (BUF_CHARS_MODIFF (buf
));
1471 DEFUN ("rename-buffer", Frename_buffer
, Srename_buffer
, 1, 2,
1472 "(list (read-string \"Rename buffer (to new name): \" \
1473 nil 'buffer-name-history (buffer-name (current-buffer))) \
1474 current-prefix-arg)",
1475 doc
: /* Change current buffer's name to NEWNAME (a string).
1476 If second arg UNIQUE is nil or omitted, it is an error if a
1477 buffer named NEWNAME already exists.
1478 If UNIQUE is non-nil, come up with a new name using
1479 `generate-new-buffer-name'.
1480 Interactively, you can set UNIQUE with a prefix argument.
1481 We return the name we actually gave the buffer.
1482 This does not change the name of the visited file (if any). */)
1483 (register Lisp_Object newname
, Lisp_Object unique
)
1485 register Lisp_Object tem
, buf
;
1487 CHECK_STRING (newname
);
1489 if (SCHARS (newname
) == 0)
1490 error ("Empty string is invalid as a buffer name");
1492 tem
= Fget_buffer (newname
);
1495 /* Don't short-circuit if UNIQUE is t. That is a useful way to
1496 rename the buffer automatically so you can create another
1497 with the original name. It makes UNIQUE equivalent to
1498 (rename-buffer (generate-new-buffer-name NEWNAME)). */
1499 if (NILP (unique
) && XBUFFER (tem
) == current_buffer
)
1500 return BVAR (current_buffer
, name
);
1502 newname
= Fgenerate_new_buffer_name (newname
, BVAR (current_buffer
, name
));
1504 error ("Buffer name `%s' is in use", SDATA (newname
));
1507 bset_name (current_buffer
, newname
);
1509 /* Catch redisplay's attention. Unless we do this, the mode lines for
1510 any windows displaying current_buffer will stay unchanged. */
1511 update_mode_lines
++;
1513 XSETBUFFER (buf
, current_buffer
);
1514 Fsetcar (Frassq (buf
, Vbuffer_alist
), newname
);
1515 if (NILP (BVAR (current_buffer
, filename
))
1516 && !NILP (BVAR (current_buffer
, auto_save_file_name
)))
1517 call0 (intern ("rename-auto-save-file"));
1519 /* Run buffer-list-update-hook. */
1520 if (!NILP (Vrun_hooks
))
1521 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1523 /* Refetch since that last call may have done GC. */
1524 return BVAR (current_buffer
, name
);
1527 DEFUN ("other-buffer", Fother_buffer
, Sother_buffer
, 0, 3, 0,
1528 doc
: /* Return most recently selected buffer other than BUFFER.
1529 Buffers not visible in windows are preferred to visible buffers, unless
1530 optional second argument VISIBLE-OK is non-nil. Ignore the argument
1531 BUFFER unless it denotes a live buffer. If the optional third argument
1532 FRAME is non-nil, use that frame's buffer list instead of the selected
1533 frame's buffer list.
1535 The buffer is found by scanning the selected or specified frame's buffer
1536 list first, followed by the list of all buffers. If no other buffer
1537 exists, return the buffer `*scratch*' (creating it if necessary). */)
1538 (register Lisp_Object buffer
, Lisp_Object visible_ok
, Lisp_Object frame
)
1540 Lisp_Object tail
, buf
, pred
;
1541 Lisp_Object notsogood
= Qnil
;
1544 frame
= selected_frame
;
1546 CHECK_FRAME (frame
);
1548 pred
= frame_buffer_predicate (frame
);
1549 /* Consider buffers that have been seen in the frame first. */
1550 tail
= XFRAME (frame
)->buffer_list
;
1551 for (; CONSP (tail
); tail
= XCDR (tail
))
1554 if (BUFFERP (buf
) && !EQ (buf
, buffer
)
1555 && BUFFER_LIVE_P (XBUFFER (buf
))
1556 && (SREF (BVAR (XBUFFER (buf
), name
), 0) != ' ')
1557 /* If the frame has a buffer_predicate, disregard buffers that
1558 don't fit the predicate. */
1559 && (NILP (pred
) || !NILP (call1 (pred
, buf
))))
1561 if (!NILP (visible_ok
)
1562 || NILP (Fget_buffer_window (buf
, Qvisible
)))
1564 else if (NILP (notsogood
))
1569 /* Consider alist of all buffers next. */
1570 tail
= Vbuffer_alist
;
1571 for (; CONSP (tail
); tail
= XCDR (tail
))
1573 buf
= Fcdr (XCAR (tail
));
1574 if (BUFFERP (buf
) && !EQ (buf
, buffer
)
1575 && BUFFER_LIVE_P (XBUFFER (buf
))
1576 && (SREF (BVAR (XBUFFER (buf
), name
), 0) != ' ')
1577 /* If the frame has a buffer_predicate, disregard buffers that
1578 don't fit the predicate. */
1579 && (NILP (pred
) || !NILP (call1 (pred
, buf
))))
1581 if (!NILP (visible_ok
)
1582 || NILP (Fget_buffer_window (buf
, Qvisible
)))
1584 else if (NILP (notsogood
))
1589 if (!NILP (notsogood
))
1593 buf
= Fget_buffer (build_string ("*scratch*"));
1596 buf
= Fget_buffer_create (build_string ("*scratch*"));
1597 Fset_buffer_major_mode (buf
);
1603 /* The following function is a safe variant of Fother_buffer: It doesn't
1604 pay attention to any frame-local buffer lists, doesn't care about
1605 visibility of buffers, and doesn't evaluate any frame predicates. */
1608 other_buffer_safely (Lisp_Object buffer
)
1610 Lisp_Object tail
, buf
;
1612 tail
= Vbuffer_alist
;
1613 for (; CONSP (tail
); tail
= XCDR (tail
))
1615 buf
= Fcdr (XCAR (tail
));
1616 if (BUFFERP (buf
) && !EQ (buf
, buffer
)
1617 && BUFFER_LIVE_P (XBUFFER (buf
))
1618 && (SREF (BVAR (XBUFFER (buf
), name
), 0) != ' '))
1622 buf
= Fget_buffer (build_string ("*scratch*"));
1625 buf
= Fget_buffer_create (build_string ("*scratch*"));
1626 Fset_buffer_major_mode (buf
);
1632 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo
, Sbuffer_enable_undo
,
1634 doc
: /* Start keeping undo information for buffer BUFFER.
1635 No argument or nil as argument means do this for the current buffer. */)
1636 (register Lisp_Object buffer
)
1638 Lisp_Object real_buffer
;
1641 XSETBUFFER (real_buffer
, current_buffer
);
1644 real_buffer
= Fget_buffer (buffer
);
1645 if (NILP (real_buffer
))
1649 if (EQ (BVAR (XBUFFER (real_buffer
), undo_list
), Qt
))
1650 bset_undo_list (XBUFFER (real_buffer
), Qnil
);
1655 /* Truncate undo list and shrink the gap of BUFFER. */
1658 compact_buffer (struct buffer
*buffer
)
1660 /* Verify indirection counters. */
1661 if (buffer
->base_buffer
)
1663 eassert (buffer
->indirections
== -1);
1664 eassert (buffer
->base_buffer
->indirections
> 0);
1667 eassert (buffer
->indirections
>= 0);
1669 /* Skip dead buffers, indirect buffers and buffers
1670 which aren't changed since last compaction. */
1671 if (!NILP (buffer
->INTERNAL_FIELD (name
))
1672 && (buffer
->base_buffer
== NULL
)
1673 && (buffer
->text
->compact
!= buffer
->text
->modiff
))
1675 /* If a buffer's undo list is Qt, that means that undo is
1676 turned off in that buffer. Calling truncate_undo_list on
1677 Qt tends to return NULL, which effectively turns undo back on.
1678 So don't call truncate_undo_list if undo_list is Qt. */
1679 if (!EQ (buffer
->INTERNAL_FIELD (undo_list
), Qt
))
1680 truncate_undo_list (buffer
);
1682 /* Shrink buffer gaps. */
1683 if (!buffer
->text
->inhibit_shrinking
)
1685 /* If a buffer's gap size is more than 10% of the buffer
1686 size, or larger than 2000 bytes, then shrink it
1687 accordingly. Keep a minimum size of 20 bytes. */
1688 int size
= min (2000, max (20, (buffer
->text
->z_byte
/ 10)));
1690 if (buffer
->text
->gap_size
> size
)
1692 struct buffer
*save_current
= current_buffer
;
1693 current_buffer
= buffer
;
1694 make_gap (-(buffer
->text
->gap_size
- size
));
1695 current_buffer
= save_current
;
1698 buffer
->text
->compact
= buffer
->text
->modiff
;
1702 DEFUN ("kill-buffer", Fkill_buffer
, Skill_buffer
, 0, 1, "bKill buffer: ",
1703 doc
: /* Kill the buffer specified by BUFFER-OR-NAME.
1704 The argument may be a buffer or the name of an existing buffer.
1705 Argument nil or omitted means kill the current buffer. Return t if the
1706 buffer is actually killed, nil otherwise.
1708 The functions in `kill-buffer-query-functions' are called with the
1709 buffer to be killed as the current buffer. If any of them returns nil,
1710 the buffer is not killed. The hook `kill-buffer-hook' is run before the
1711 buffer is actually killed. The buffer being killed will be current
1712 while the hook is running. Functions called by any of these hooks are
1713 supposed to not change the current buffer.
1715 Any processes that have this buffer as the `process-buffer' are killed
1716 with SIGHUP. This function calls `replace-buffer-in-windows' for
1717 cleaning up all windows currently displaying the buffer to be killed. */)
1718 (Lisp_Object buffer_or_name
)
1721 register struct buffer
*b
;
1722 register Lisp_Object tem
;
1723 register struct Lisp_Marker
*m
;
1724 struct gcpro gcpro1
;
1726 if (NILP (buffer_or_name
))
1727 buffer
= Fcurrent_buffer ();
1729 buffer
= Fget_buffer (buffer_or_name
);
1731 nsberror (buffer_or_name
);
1733 b
= XBUFFER (buffer
);
1735 /* Avoid trouble for buffer already dead. */
1736 if (!BUFFER_LIVE_P (b
))
1739 /* Query if the buffer is still modified. */
1740 if (INTERACTIVE
&& !NILP (BVAR (b
, filename
))
1741 && BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
1744 tem
= do_yes_or_no_p (format2 ("Buffer %s modified; kill anyway? ",
1745 BVAR (b
, name
), make_number (0)));
1751 /* Run hooks with the buffer to be killed the current buffer. */
1753 ptrdiff_t count
= SPECPDL_INDEX ();
1754 Lisp_Object arglist
[1];
1756 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1757 set_buffer_internal (b
);
1759 /* First run the query functions; if any query is answered no,
1760 don't kill the buffer. */
1761 arglist
[0] = Qkill_buffer_query_functions
;
1762 tem
= Frun_hook_with_args_until_failure (1, arglist
);
1764 return unbind_to (count
, Qnil
);
1766 /* Then run the hooks. */
1767 Frun_hooks (1, &Qkill_buffer_hook
);
1768 unbind_to (count
, Qnil
);
1771 /* If the hooks have killed the buffer, exit now. */
1772 if (!BUFFER_LIVE_P (b
))
1775 /* We have no more questions to ask. Verify that it is valid
1776 to kill the buffer. This must be done after the questions
1777 since anything can happen within do_yes_or_no_p. */
1779 /* Don't kill the minibuffer now current. */
1780 if (EQ (buffer
, XWINDOW (minibuf_window
)->buffer
))
1783 /* When we kill an ordinary buffer which shares it's buffer text
1784 with indirect buffer(s), we must kill indirect buffer(s) too.
1785 We do it at this stage so nothing terrible happens if they
1786 ask questions or their hooks get errors. */
1787 if (!b
->base_buffer
&& b
->indirections
> 0)
1789 struct buffer
*other
;
1793 FOR_EACH_BUFFER (other
)
1794 if (other
->base_buffer
== b
)
1797 XSETBUFFER (buf
, other
);
1803 /* Exit if we now have killed the base buffer (Bug#11665). */
1804 if (!BUFFER_LIVE_P (b
))
1808 /* Run replace_buffer_in_windows before making another buffer current
1809 since set-window-buffer-start-and-point will refuse to make another
1810 buffer current if the selected window does not show the current
1811 buffer. (Bug#10114) */
1812 replace_buffer_in_windows (buffer
);
1814 /* Exit if replacing the buffer in windows has killed our buffer. */
1815 if (!BUFFER_LIVE_P (b
))
1818 /* Make this buffer not be current. Exit if it is the sole visible
1820 if (b
== current_buffer
)
1822 tem
= Fother_buffer (buffer
, Qnil
, Qnil
);
1824 if (b
== current_buffer
)
1828 /* If the buffer now current is shown in the minibuffer and our buffer
1829 is the sole other buffer give up. */
1830 XSETBUFFER (tem
, current_buffer
);
1831 if (EQ (tem
, XWINDOW (minibuf_window
)->buffer
)
1832 && EQ (buffer
, Fother_buffer (buffer
, Qnil
, Qnil
)))
1835 /* Now there is no question: we can kill the buffer. */
1837 #ifdef CLASH_DETECTION
1838 /* Unlock this buffer's file, if it is locked. */
1840 #endif /* CLASH_DETECTION */
1843 kill_buffer_processes (buffer
);
1846 /* Killing buffer processes may run sentinels which may have killed
1848 if (!BUFFER_LIVE_P (b
))
1851 /* These may run Lisp code and into infinite loops (if someone
1852 insisted on circular lists) so allow quitting here. */
1853 frames_discard_buffer (buffer
);
1855 clear_charpos_cache (b
);
1857 tem
= Vinhibit_quit
;
1859 /* Remove the buffer from the list of all buffers. */
1860 Vbuffer_alist
= Fdelq (Frassq (buffer
, Vbuffer_alist
), Vbuffer_alist
);
1861 /* If replace_buffer_in_windows didn't do its job fix that now. */
1862 replace_buffer_in_windows_safely (buffer
);
1863 Vinhibit_quit
= tem
;
1865 /* Delete any auto-save file, if we saved it in this session.
1866 But not if the buffer is modified. */
1867 if (STRINGP (BVAR (b
, auto_save_file_name
))
1868 && BUF_AUTOSAVE_MODIFF (b
) != 0
1869 && BUF_SAVE_MODIFF (b
) < BUF_AUTOSAVE_MODIFF (b
)
1870 && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
)
1871 && NILP (Fsymbol_value (intern ("auto-save-visited-file-name"))))
1874 delete = Fsymbol_value (intern ("delete-auto-save-files"));
1875 if (! NILP (delete))
1876 internal_delete_file (BVAR (b
, auto_save_file_name
));
1879 /* Deleting an auto-save file could have killed our buffer. */
1880 if (!BUFFER_LIVE_P (b
))
1885 /* Unchain all markers that belong to this indirect buffer.
1886 Don't unchain the markers that belong to the base buffer
1887 or its other indirect buffers. */
1888 for (m
= BUF_MARKERS (b
); m
; )
1890 struct Lisp_Marker
*next
= m
->next
;
1898 /* Unchain all markers of this buffer and its indirect buffers.
1899 and leave them pointing nowhere. */
1900 for (m
= BUF_MARKERS (b
); m
; )
1902 struct Lisp_Marker
*next
= m
->next
;
1907 BUF_MARKERS (b
) = NULL
;
1908 set_buffer_intervals (b
, NULL
);
1910 /* Perhaps we should explicitly free the interval tree here... */
1913 /* Reset the local variables, so that this buffer's local values
1914 won't be protected from GC. They would be protected
1915 if they happened to remain cached in their symbols.
1916 This gets rid of them for certain. */
1917 swap_out_buffer_local_variables (b
);
1918 reset_buffer_local_variables (b
, 1);
1920 bset_name (b
, Qnil
);
1925 /* Notify our base buffer that we don't share the text anymore. */
1926 eassert (b
->indirections
== -1);
1927 b
->base_buffer
->indirections
--;
1928 eassert (b
->base_buffer
->indirections
>= 0);
1931 /* No one shares our buffer text, can free it. */
1932 free_buffer_text (b
);
1934 if (b
->newline_cache
)
1936 free_region_cache (b
->newline_cache
);
1937 b
->newline_cache
= 0;
1939 if (b
->width_run_cache
)
1941 free_region_cache (b
->width_run_cache
);
1942 b
->width_run_cache
= 0;
1944 bset_width_table (b
, Qnil
);
1946 bset_undo_list (b
, Qnil
);
1948 /* Run buffer-list-update-hook. */
1949 if (!NILP (Vrun_hooks
))
1950 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1955 /* Move association for BUFFER to the front of buffer (a)lists. Since
1956 we do this each time BUFFER is selected visibly, the more recently
1957 selected buffers are always closer to the front of those lists. This
1958 means that other_buffer is more likely to choose a relevant buffer.
1960 Note that this moves BUFFER to the front of the buffer lists of the
1961 selected frame even if BUFFER is not shown there. If BUFFER is not
1962 shown in the selected frame, consider the present behavior a feature.
1963 `select-window' gets this right since it shows BUFFER in the selected
1964 window when calling us. */
1967 record_buffer (Lisp_Object buffer
)
1969 Lisp_Object aelt
, aelt_cons
, tem
;
1970 register struct frame
*f
= XFRAME (selected_frame
);
1972 CHECK_BUFFER (buffer
);
1974 /* Update Vbuffer_alist (we know that it has an entry for BUFFER).
1975 Don't allow quitting since this might leave the buffer list in an
1976 inconsistent state. */
1977 tem
= Vinhibit_quit
;
1979 aelt
= Frassq (buffer
, Vbuffer_alist
);
1980 aelt_cons
= Fmemq (aelt
, Vbuffer_alist
);
1981 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
1982 XSETCDR (aelt_cons
, Vbuffer_alist
);
1983 Vbuffer_alist
= aelt_cons
;
1984 Vinhibit_quit
= tem
;
1986 /* Update buffer list of selected frame. */
1987 fset_buffer_list (f
, Fcons (buffer
, Fdelq (buffer
, f
->buffer_list
)));
1988 fset_buried_buffer_list (f
, Fdelq (buffer
, f
->buried_buffer_list
));
1990 /* Run buffer-list-update-hook. */
1991 if (!NILP (Vrun_hooks
))
1992 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1996 /* Move BUFFER to the end of the buffer (a)lists. Do nothing if the
1997 buffer is killed. For the selected frame's buffer list this moves
1998 BUFFER to its end even if it was never shown in that frame. If
1999 this happens we have a feature, hence `bury-buffer-internal' should be
2000 called only when BUFFER was shown in the selected frame. */
2002 DEFUN ("bury-buffer-internal", Fbury_buffer_internal
, Sbury_buffer_internal
,
2004 doc
: /* Move BUFFER to the end of the buffer list. */)
2005 (Lisp_Object buffer
)
2007 Lisp_Object aelt
, aelt_cons
, tem
;
2008 register struct frame
*f
= XFRAME (selected_frame
);
2010 CHECK_BUFFER (buffer
);
2012 /* Update Vbuffer_alist (we know that it has an entry for BUFFER).
2013 Don't allow quitting since this might leave the buffer list in an
2014 inconsistent state. */
2015 tem
= Vinhibit_quit
;
2017 aelt
= Frassq (buffer
, Vbuffer_alist
);
2018 aelt_cons
= Fmemq (aelt
, Vbuffer_alist
);
2019 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
2020 XSETCDR (aelt_cons
, Qnil
);
2021 Vbuffer_alist
= nconc2 (Vbuffer_alist
, aelt_cons
);
2022 Vinhibit_quit
= tem
;
2024 /* Update buffer lists of selected frame. */
2025 fset_buffer_list (f
, Fdelq (buffer
, f
->buffer_list
));
2026 fset_buried_buffer_list
2027 (f
, Fcons (buffer
, Fdelq (buffer
, f
->buried_buffer_list
)));
2029 /* Run buffer-list-update-hook. */
2030 if (!NILP (Vrun_hooks
))
2031 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
2036 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode
, Sset_buffer_major_mode
, 1, 1, 0,
2037 doc
: /* Set an appropriate major mode for BUFFER.
2038 For the *scratch* buffer, use `initial-major-mode', otherwise choose a mode
2039 according to `default-major-mode'.
2040 Use this function before selecting the buffer, since it may need to inspect
2041 the current buffer's major mode. */)
2042 (Lisp_Object buffer
)
2045 Lisp_Object function
;
2047 CHECK_BUFFER (buffer
);
2049 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
2050 error ("Attempt to set major mode for a dead buffer");
2052 if (strcmp (SSDATA (BVAR (XBUFFER (buffer
), name
)), "*scratch*") == 0)
2053 function
= find_symbol_value (intern ("initial-major-mode"));
2056 function
= BVAR (&buffer_defaults
, major_mode
);
2058 && NILP (Fget (BVAR (current_buffer
, major_mode
), Qmode_class
)))
2059 function
= BVAR (current_buffer
, major_mode
);
2062 if (NILP (function
) || EQ (function
, Qfundamental_mode
))
2065 count
= SPECPDL_INDEX ();
2067 /* To select a nonfundamental mode,
2068 select the buffer temporarily and then call the mode function. */
2070 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2072 Fset_buffer (buffer
);
2075 return unbind_to (count
, Qnil
);
2078 DEFUN ("current-buffer", Fcurrent_buffer
, Scurrent_buffer
, 0, 0, 0,
2079 doc
: /* Return the current buffer as a Lisp object. */)
2082 register Lisp_Object buf
;
2083 XSETBUFFER (buf
, current_buffer
);
2087 /* Set the current buffer to B, and do not set windows_or_buffers_changed.
2088 This is used by redisplay. */
2091 set_buffer_internal_1 (register struct buffer
*b
)
2093 register struct buffer
*old_buf
;
2094 register Lisp_Object tail
;
2096 #ifdef USE_MMAP_FOR_BUFFERS
2097 if (b
->text
->beg
== NULL
)
2098 enlarge_buffer_text (b
, 0);
2099 #endif /* USE_MMAP_FOR_BUFFERS */
2101 if (current_buffer
== b
)
2104 old_buf
= current_buffer
;
2106 last_known_column_point
= -1; /* invalidate indentation cache */
2110 /* Put the undo list back in the base buffer, so that it appears
2111 that an indirect buffer shares the undo list of its base. */
2112 if (old_buf
->base_buffer
)
2113 bset_undo_list (old_buf
->base_buffer
, BVAR (old_buf
, undo_list
));
2115 /* If the old current buffer has markers to record PT, BEGV and ZV
2116 when it is not current, update them now. */
2117 record_buffer_markers (old_buf
);
2120 /* Get the undo list from the base buffer, so that it appears
2121 that an indirect buffer shares the undo list of its base. */
2123 bset_undo_list (b
, BVAR (b
->base_buffer
, undo_list
));
2125 /* If the new current buffer has markers to record PT, BEGV and ZV
2126 when it is not current, fetch them now. */
2127 fetch_buffer_markers (b
);
2129 /* Look down buffer's list of local Lisp variables
2130 to find and update any that forward into C variables. */
2134 for (tail
= BVAR (b
, local_var_alist
); CONSP (tail
); tail
= XCDR (tail
))
2136 Lisp_Object var
= XCAR (XCAR (tail
));
2137 struct Lisp_Symbol
*sym
= XSYMBOL (var
);
2138 if (sym
->redirect
== SYMBOL_LOCALIZED
/* Just to be sure. */
2139 && SYMBOL_BLV (sym
)->fwd
)
2140 /* Just reference the variable
2141 to cause it to become set for this buffer. */
2142 Fsymbol_value (var
);
2145 /* Do the same with any others that were local to the previous buffer */
2146 while (b
!= old_buf
&& (b
= old_buf
, b
));
2149 /* Switch to buffer B temporarily for redisplay purposes.
2150 This avoids certain things that don't need to be done within redisplay. */
2153 set_buffer_temp (struct buffer
*b
)
2155 register struct buffer
*old_buf
;
2157 if (current_buffer
== b
)
2160 old_buf
= current_buffer
;
2163 /* If the old current buffer has markers to record PT, BEGV and ZV
2164 when it is not current, update them now. */
2165 record_buffer_markers (old_buf
);
2167 /* If the new current buffer has markers to record PT, BEGV and ZV
2168 when it is not current, fetch them now. */
2169 fetch_buffer_markers (b
);
2172 DEFUN ("set-buffer", Fset_buffer
, Sset_buffer
, 1, 1, 0,
2173 doc
: /* Make buffer BUFFER-OR-NAME current for editing operations.
2174 BUFFER-OR-NAME may be a buffer or the name of an existing buffer. See
2175 also `save-excursion' when you want to make a buffer current
2176 temporarily. This function does not display the buffer, so its effect
2177 ends when the current command terminates. Use `switch-to-buffer' or
2178 `pop-to-buffer' to switch buffers permanently. */)
2179 (register Lisp_Object buffer_or_name
)
2181 register Lisp_Object buffer
;
2182 buffer
= Fget_buffer (buffer_or_name
);
2184 nsberror (buffer_or_name
);
2185 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
2186 error ("Selecting deleted buffer");
2187 set_buffer_internal (XBUFFER (buffer
));
2191 /* Set the current buffer to BUFFER provided if it is alive. */
2194 set_buffer_if_live (Lisp_Object buffer
)
2196 if (BUFFER_LIVE_P (XBUFFER (buffer
)))
2197 set_buffer_internal (XBUFFER (buffer
));
2201 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only
,
2202 Sbarf_if_buffer_read_only
, 0, 0, 0,
2203 doc
: /* Signal a `buffer-read-only' error if the current buffer is read-only. */)
2206 if (!NILP (BVAR (current_buffer
, read_only
))
2207 && NILP (Vinhibit_read_only
))
2208 xsignal1 (Qbuffer_read_only
, Fcurrent_buffer ());
2212 DEFUN ("erase-buffer", Ferase_buffer
, Serase_buffer
, 0, 0, "*",
2213 doc
: /* Delete the entire contents of the current buffer.
2214 Any narrowing restriction in effect (see `narrow-to-region') is removed,
2215 so the buffer is truly empty after this. */)
2222 current_buffer
->last_window_start
= 1;
2223 /* Prevent warnings, or suspension of auto saving, that would happen
2224 if future size is less than past size. Use of erase-buffer
2225 implies that the future text is not really related to the past text. */
2226 XSETFASTINT (BVAR (current_buffer
, save_length
), 0);
2231 validate_region (register Lisp_Object
*b
, register Lisp_Object
*e
)
2233 CHECK_NUMBER_COERCE_MARKER (*b
);
2234 CHECK_NUMBER_COERCE_MARKER (*e
);
2236 if (XINT (*b
) > XINT (*e
))
2239 tem
= *b
; *b
= *e
; *e
= tem
;
2242 if (! (BEGV
<= XINT (*b
) && XINT (*e
) <= ZV
))
2243 args_out_of_range (*b
, *e
);
2246 /* Advance BYTE_POS up to a character boundary
2247 and return the adjusted position. */
2250 advance_to_char_boundary (ptrdiff_t byte_pos
)
2254 if (byte_pos
== BEG
)
2255 /* Beginning of buffer is always a character boundary. */
2258 c
= FETCH_BYTE (byte_pos
);
2259 if (! CHAR_HEAD_P (c
))
2261 /* We should advance BYTE_POS only when C is a constituent of a
2262 multibyte sequence. */
2263 ptrdiff_t orig_byte_pos
= byte_pos
;
2268 c
= FETCH_BYTE (byte_pos
);
2270 while (! CHAR_HEAD_P (c
) && byte_pos
> BEG
);
2272 if (byte_pos
< orig_byte_pos
)
2273 byte_pos
= orig_byte_pos
;
2274 /* If C is a constituent of a multibyte sequence, BYTE_POS was
2275 surely advance to the correct character boundary. If C is
2276 not, BYTE_POS was unchanged. */
2282 DEFUN ("buffer-swap-text", Fbuffer_swap_text
, Sbuffer_swap_text
,
2284 doc
: /* Swap the text between current buffer and BUFFER. */)
2285 (Lisp_Object buffer
)
2287 struct buffer
*other_buffer
;
2288 CHECK_BUFFER (buffer
);
2289 other_buffer
= XBUFFER (buffer
);
2291 if (!BUFFER_LIVE_P (other_buffer
))
2292 error ("Cannot swap a dead buffer's text");
2294 /* Actually, it probably works just fine.
2295 * if (other_buffer == current_buffer)
2296 * error ("Cannot swap a buffer's text with itself"); */
2298 /* Actually, this may be workable as well, tho probably only if they're
2300 if (other_buffer
->base_buffer
2301 || current_buffer
->base_buffer
)
2302 error ("Cannot swap indirect buffers's text");
2304 { /* This is probably harder to make work. */
2305 struct buffer
*other
;
2306 FOR_EACH_BUFFER (other
)
2307 if (other
->base_buffer
== other_buffer
2308 || other
->base_buffer
== current_buffer
)
2309 error ("One of the buffers to swap has indirect buffers");
2312 #define swapfield(field, type) \
2314 type tmp##field = other_buffer->field; \
2315 other_buffer->field = current_buffer->field; \
2316 current_buffer->field = tmp##field; \
2318 #define swapfield_(field, type) \
2320 type tmp##field = BVAR (other_buffer, field); \
2321 bset_##field (other_buffer, BVAR (current_buffer, field)); \
2322 bset_##field (current_buffer, tmp##field); \
2325 swapfield (own_text
, struct buffer_text
);
2326 eassert (current_buffer
->text
== ¤t_buffer
->own_text
);
2327 eassert (other_buffer
->text
== &other_buffer
->own_text
);
2329 r_alloc_reset_variable ((void **) ¤t_buffer
->own_text
.beg
,
2330 (void **) &other_buffer
->own_text
.beg
);
2331 r_alloc_reset_variable ((void **) &other_buffer
->own_text
.beg
,
2332 (void **) ¤t_buffer
->own_text
.beg
);
2333 #endif /* REL_ALLOC */
2335 swapfield (pt
, ptrdiff_t);
2336 swapfield (pt_byte
, ptrdiff_t);
2337 swapfield (begv
, ptrdiff_t);
2338 swapfield (begv_byte
, ptrdiff_t);
2339 swapfield (zv
, ptrdiff_t);
2340 swapfield (zv_byte
, ptrdiff_t);
2341 eassert (!current_buffer
->base_buffer
);
2342 eassert (!other_buffer
->base_buffer
);
2343 swapfield (indirections
, ptrdiff_t);
2344 current_buffer
->clip_changed
= 1; other_buffer
->clip_changed
= 1;
2345 swapfield (newline_cache
, struct region_cache
*);
2346 swapfield (width_run_cache
, struct region_cache
*);
2347 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2348 other_buffer
->prevent_redisplay_optimizations_p
= 1;
2349 swapfield (overlays_before
, struct Lisp_Overlay
*);
2350 swapfield (overlays_after
, struct Lisp_Overlay
*);
2351 swapfield (overlay_center
, ptrdiff_t);
2352 swapfield_ (undo_list
, Lisp_Object
);
2353 swapfield_ (mark
, Lisp_Object
);
2354 swapfield_ (enable_multibyte_characters
, Lisp_Object
);
2355 swapfield_ (bidi_display_reordering
, Lisp_Object
);
2356 swapfield_ (bidi_paragraph_direction
, Lisp_Object
);
2357 /* FIXME: Not sure what we should do with these *_marker fields.
2358 Hopefully they're just nil anyway. */
2359 swapfield_ (pt_marker
, Lisp_Object
);
2360 swapfield_ (begv_marker
, Lisp_Object
);
2361 swapfield_ (zv_marker
, Lisp_Object
);
2362 bset_point_before_scroll (current_buffer
, Qnil
);
2363 bset_point_before_scroll (other_buffer
, Qnil
);
2365 current_buffer
->text
->modiff
++; other_buffer
->text
->modiff
++;
2366 current_buffer
->text
->chars_modiff
++; other_buffer
->text
->chars_modiff
++;
2367 current_buffer
->text
->overlay_modiff
++; other_buffer
->text
->overlay_modiff
++;
2368 current_buffer
->text
->beg_unchanged
= current_buffer
->text
->gpt
;
2369 current_buffer
->text
->end_unchanged
= current_buffer
->text
->gpt
;
2370 other_buffer
->text
->beg_unchanged
= other_buffer
->text
->gpt
;
2371 other_buffer
->text
->end_unchanged
= other_buffer
->text
->gpt
;
2373 struct Lisp_Marker
*m
;
2374 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
2375 if (m
->buffer
== other_buffer
)
2376 m
->buffer
= current_buffer
;
2378 /* Since there's no indirect buffer in sight, markers on
2379 BUF_MARKERS(buf) should either be for `buf' or dead. */
2380 eassert (!m
->buffer
);
2381 for (m
= BUF_MARKERS (other_buffer
); m
; m
= m
->next
)
2382 if (m
->buffer
== current_buffer
)
2383 m
->buffer
= other_buffer
;
2385 /* Since there's no indirect buffer in sight, markers on
2386 BUF_MARKERS(buf) should either be for `buf' or dead. */
2387 eassert (!m
->buffer
);
2389 { /* Some of the C code expects that w->buffer == w->pointm->buffer.
2390 So since we just swapped the markers between the two buffers, we need
2391 to undo the effect of this swap for window markers. */
2392 Lisp_Object w
= Fselected_window (), ws
= Qnil
;
2393 Lisp_Object buf1
, buf2
;
2394 XSETBUFFER (buf1
, current_buffer
); XSETBUFFER (buf2
, other_buffer
);
2396 while (NILP (Fmemq (w
, ws
)))
2399 if (MARKERP (XWINDOW (w
)->pointm
)
2400 && (EQ (XWINDOW (w
)->buffer
, buf1
)
2401 || EQ (XWINDOW (w
)->buffer
, buf2
)))
2402 Fset_marker (XWINDOW (w
)->pointm
,
2404 (BUF_BEGV (XBUFFER (XWINDOW (w
)->buffer
))),
2405 XWINDOW (w
)->buffer
);
2406 w
= Fnext_window (w
, Qt
, Qt
);
2410 if (current_buffer
->text
->intervals
)
2411 (eassert (EQ (current_buffer
->text
->intervals
->up
.obj
, buffer
)),
2412 XSETBUFFER (current_buffer
->text
->intervals
->up
.obj
, current_buffer
));
2413 if (other_buffer
->text
->intervals
)
2414 (eassert (EQ (other_buffer
->text
->intervals
->up
.obj
, Fcurrent_buffer ())),
2415 XSETBUFFER (other_buffer
->text
->intervals
->up
.obj
, other_buffer
));
2420 DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte
, Sset_buffer_multibyte
,
2422 doc
: /* Set the multibyte flag of the current buffer to FLAG.
2423 If FLAG is t, this makes the buffer a multibyte buffer.
2424 If FLAG is nil, this makes the buffer a single-byte buffer.
2425 In these cases, the buffer contents remain unchanged as a sequence of
2426 bytes but the contents viewed as characters do change.
2427 If FLAG is `to', this makes the buffer a multibyte buffer by changing
2428 all eight-bit bytes to eight-bit characters.
2429 If the multibyte flag was really changed, undo information of the
2430 current buffer is cleared. */)
2433 struct Lisp_Marker
*tail
, *markers
;
2434 struct buffer
*other
;
2436 bool narrowed
= (BEG
!= BEGV
|| Z
!= ZV
);
2437 bool modified_p
= !NILP (Fbuffer_modified_p (Qnil
));
2438 Lisp_Object old_undo
= BVAR (current_buffer
, undo_list
);
2439 struct gcpro gcpro1
;
2441 if (current_buffer
->base_buffer
)
2442 error ("Cannot do `set-buffer-multibyte' on an indirect buffer");
2444 /* Do nothing if nothing actually changes. */
2445 if (NILP (flag
) == NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
2450 /* Don't record these buffer changes. We will put a special undo entry
2452 bset_undo_list (current_buffer
, Qt
);
2454 /* If the cached position is for this buffer, clear it out. */
2455 clear_charpos_cache (current_buffer
);
2458 begv
= BEGV_BYTE
, zv
= ZV_BYTE
;
2460 begv
= BEGV
, zv
= ZV
;
2467 ptrdiff_t pos
, stop
;
2470 /* Do this first, so it can use CHAR_TO_BYTE
2471 to calculate the old correspondences. */
2472 set_intervals_multibyte (0);
2474 bset_enable_multibyte_characters (current_buffer
, Qnil
);
2480 TEMP_SET_PT_BOTH (PT_BYTE
, PT_BYTE
);
2483 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
2484 tail
->charpos
= tail
->bytepos
;
2486 /* Convert multibyte form of 8-bit characters to unibyte. */
2501 if (ASCII_BYTE_P (*p
))
2503 else if (CHAR_BYTE8_HEAD_P (*p
))
2505 c
= STRING_CHAR_AND_LENGTH (p
, bytes
);
2506 /* Delete all bytes for this 8-bit character but the
2507 last one, and change the last one to the character
2510 del_range_2 (pos
, pos
, pos
+ bytes
, pos
+ bytes
, 0);
2522 bytes
= BYTES_BY_CHAR_HEAD (*p
);
2523 p
+= bytes
, pos
+= bytes
;
2527 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2532 ptrdiff_t pos
, stop
;
2533 unsigned char *p
, *pend
;
2535 /* Be sure not to have a multibyte sequence striding over the GAP.
2536 Ex: We change this: "...abc\302 _GAP_ \241def..."
2537 to: "...abc _GAP_ \302\241def..." */
2540 && GPT_BYTE
> 1 && GPT_BYTE
< Z_BYTE
2541 && ! CHAR_HEAD_P (*(GAP_END_ADDR
)))
2543 unsigned char *q
= GPT_ADDR
- 1;
2545 while (! CHAR_HEAD_P (*q
) && q
> BEG_ADDR
) q
--;
2546 if (LEADING_CODE_P (*q
))
2548 ptrdiff_t new_gpt
= GPT_BYTE
- (GPT_ADDR
- q
);
2550 move_gap_both (new_gpt
, new_gpt
);
2554 /* Make the buffer contents valid as multibyte by converting
2555 8-bit characters to multibyte form. */
2573 if (ASCII_BYTE_P (*p
))
2575 else if (EQ (flag
, Qt
)
2576 && ! CHAR_BYTE8_HEAD_P (*p
)
2577 && (bytes
= MULTIBYTE_LENGTH (p
, pend
)) > 0)
2578 p
+= bytes
, pos
+= bytes
;
2581 unsigned char tmp
[MAX_MULTIBYTE_LENGTH
];
2584 c
= BYTE8_TO_CHAR (*p
);
2585 bytes
= CHAR_STRING (c
, tmp
);
2587 TEMP_SET_PT_BOTH (pos
+ 1, pos
+ 1);
2589 insert_1_both ((char *) tmp
+ 1, bytes
, bytes
, 1, 0, 0);
2590 /* Now the gap is after the just inserted data. */
2608 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2610 /* Do this first, so that chars_in_text asks the right question.
2611 set_intervals_multibyte needs it too. */
2612 bset_enable_multibyte_characters (current_buffer
, Qt
);
2614 GPT_BYTE
= advance_to_char_boundary (GPT_BYTE
);
2615 GPT
= chars_in_text (BEG_ADDR
, GPT_BYTE
- BEG_BYTE
) + BEG
;
2617 Z
= chars_in_text (GAP_END_ADDR
, Z_BYTE
- GPT_BYTE
) + GPT
;
2619 BEGV_BYTE
= advance_to_char_boundary (BEGV_BYTE
);
2620 if (BEGV_BYTE
> GPT_BYTE
)
2621 BEGV
= chars_in_text (GAP_END_ADDR
, BEGV_BYTE
- GPT_BYTE
) + GPT
;
2623 BEGV
= chars_in_text (BEG_ADDR
, BEGV_BYTE
- BEG_BYTE
) + BEG
;
2625 ZV_BYTE
= advance_to_char_boundary (ZV_BYTE
);
2626 if (ZV_BYTE
> GPT_BYTE
)
2627 ZV
= chars_in_text (GAP_END_ADDR
, ZV_BYTE
- GPT_BYTE
) + GPT
;
2629 ZV
= chars_in_text (BEG_ADDR
, ZV_BYTE
- BEG_BYTE
) + BEG
;
2632 ptrdiff_t byte
= advance_to_char_boundary (PT_BYTE
);
2635 if (byte
> GPT_BYTE
)
2636 position
= chars_in_text (GAP_END_ADDR
, byte
- GPT_BYTE
) + GPT
;
2638 position
= chars_in_text (BEG_ADDR
, byte
- BEG_BYTE
) + BEG
;
2639 TEMP_SET_PT_BOTH (position
, byte
);
2642 tail
= markers
= BUF_MARKERS (current_buffer
);
2644 /* This prevents BYTE_TO_CHAR (that is, buf_bytepos_to_charpos) from
2645 getting confused by the markers that have not yet been updated.
2646 It is also a signal that it should never create a marker. */
2647 BUF_MARKERS (current_buffer
) = NULL
;
2649 for (; tail
; tail
= tail
->next
)
2651 tail
->bytepos
= advance_to_char_boundary (tail
->bytepos
);
2652 tail
->charpos
= BYTE_TO_CHAR (tail
->bytepos
);
2655 /* Make sure no markers were put on the chain
2656 while the chain value was incorrect. */
2657 if (BUF_MARKERS (current_buffer
))
2660 BUF_MARKERS (current_buffer
) = markers
;
2662 /* Do this last, so it can calculate the new correspondences
2663 between chars and bytes. */
2664 set_intervals_multibyte (1);
2667 if (!EQ (old_undo
, Qt
))
2669 /* Represent all the above changes by a special undo entry. */
2670 bset_undo_list (current_buffer
,
2671 Fcons (list3 (Qapply
,
2672 intern ("set-buffer-multibyte"),
2673 NILP (flag
) ? Qt
: Qnil
),
2679 /* Changing the multibyteness of a buffer means that all windows
2680 showing that buffer must be updated thoroughly. */
2681 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2682 ++windows_or_buffers_changed
;
2684 /* Copy this buffer's new multibyte status
2685 into all of its indirect buffers. */
2686 FOR_EACH_BUFFER (other
)
2687 if (other
->base_buffer
== current_buffer
&& BUFFER_LIVE_P (other
))
2689 BVAR (other
, enable_multibyte_characters
)
2690 = BVAR (current_buffer
, enable_multibyte_characters
);
2691 other
->prevent_redisplay_optimizations_p
= 1;
2694 /* Restore the modifiedness of the buffer. */
2695 if (!modified_p
&& !NILP (Fbuffer_modified_p (Qnil
)))
2696 Fset_buffer_modified_p (Qnil
);
2698 /* Update coding systems of this buffer's process (if any). */
2700 Lisp_Object process
;
2702 process
= Fget_buffer_process (Fcurrent_buffer ());
2703 if (PROCESSP (process
))
2704 setup_process_coding_systems (process
);
2710 DEFUN ("kill-all-local-variables", Fkill_all_local_variables
,
2711 Skill_all_local_variables
, 0, 0, 0,
2712 doc
: /* Switch to Fundamental mode by killing current buffer's local variables.
2713 Most local variable bindings are eliminated so that the default values
2714 become effective once more. Also, the syntax table is set from
2715 `standard-syntax-table', the local keymap is set to nil,
2716 and the abbrev table from `fundamental-mode-abbrev-table'.
2717 This function also forces redisplay of the mode line.
2719 Every function to select a new major mode starts by
2720 calling this function.
2722 As a special exception, local variables whose names have
2723 a non-nil `permanent-local' property are not eliminated by this function.
2725 The first thing this function does is run
2726 the normal hook `change-major-mode-hook'. */)
2729 Frun_hooks (1, &Qchange_major_mode_hook
);
2731 /* Make sure none of the bindings in local_var_alist
2732 remain swapped in, in their symbols. */
2734 swap_out_buffer_local_variables (current_buffer
);
2736 /* Actually eliminate all local bindings of this buffer. */
2738 reset_buffer_local_variables (current_buffer
, 0);
2740 /* Force mode-line redisplay. Useful here because all major mode
2741 commands call this function. */
2742 update_mode_lines
++;
2747 /* Make sure no local variables remain set up with buffer B
2748 for their current values. */
2751 swap_out_buffer_local_variables (struct buffer
*b
)
2753 Lisp_Object oalist
, alist
, buffer
;
2755 XSETBUFFER (buffer
, b
);
2756 oalist
= BVAR (b
, local_var_alist
);
2758 for (alist
= oalist
; CONSP (alist
); alist
= XCDR (alist
))
2760 Lisp_Object sym
= XCAR (XCAR (alist
));
2761 eassert (XSYMBOL (sym
)->redirect
== SYMBOL_LOCALIZED
);
2762 /* Need not do anything if some other buffer's binding is
2764 if (EQ (SYMBOL_BLV (XSYMBOL (sym
))->where
, buffer
))
2766 /* Symbol is set up for this buffer's old local value:
2768 swap_in_global_binding (XSYMBOL (sym
));
2773 /* Find all the overlays in the current buffer that contain position POS.
2774 Return the number found, and store them in a vector in *VEC_PTR.
2775 Store in *LEN_PTR the size allocated for the vector.
2776 Store in *NEXT_PTR the next position after POS where an overlay starts,
2777 or ZV if there are no more overlays between POS and ZV.
2778 Store in *PREV_PTR the previous position before POS where an overlay ends,
2779 or where an overlay starts which ends at or after POS;
2780 or BEGV if there are no such overlays from BEGV to POS.
2781 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2783 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2784 when this function is called.
2786 If EXTEND, make the vector bigger if necessary.
2787 If not, never extend the vector,
2788 and store only as many overlays as will fit.
2789 But still return the total number of overlays.
2791 If CHANGE_REQ, any position written into *PREV_PTR or
2792 *NEXT_PTR is guaranteed to be not equal to POS, unless it is the
2793 default (BEGV or ZV). */
2796 overlays_at (EMACS_INT pos
, bool extend
, Lisp_Object
**vec_ptr
,
2798 ptrdiff_t *next_ptr
, ptrdiff_t *prev_ptr
, bool change_req
)
2800 Lisp_Object overlay
, start
, end
;
2801 struct Lisp_Overlay
*tail
;
2803 ptrdiff_t len
= *len_ptr
;
2804 Lisp_Object
*vec
= *vec_ptr
;
2805 ptrdiff_t next
= ZV
;
2806 ptrdiff_t prev
= BEGV
;
2807 bool inhibit_storing
= 0;
2809 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2811 ptrdiff_t startpos
, endpos
;
2813 XSETMISC (overlay
, tail
);
2815 start
= OVERLAY_START (overlay
);
2816 end
= OVERLAY_END (overlay
);
2817 endpos
= OVERLAY_POSITION (end
);
2824 startpos
= OVERLAY_POSITION (start
);
2825 /* This one ends at or after POS
2826 so its start counts for PREV_PTR if it's before POS. */
2827 if (prev
< startpos
&& startpos
< pos
)
2831 if (startpos
<= pos
)
2835 /* The supplied vector is full.
2836 Either make it bigger, or don't store any more in it. */
2839 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2845 inhibit_storing
= 1;
2848 if (!inhibit_storing
)
2850 /* Keep counting overlays even if we can't return them all. */
2853 else if (startpos
< next
)
2857 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2859 ptrdiff_t startpos
, endpos
;
2861 XSETMISC (overlay
, tail
);
2863 start
= OVERLAY_START (overlay
);
2864 end
= OVERLAY_END (overlay
);
2865 startpos
= OVERLAY_POSITION (start
);
2868 if (startpos
< next
)
2872 endpos
= OVERLAY_POSITION (end
);
2879 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2885 inhibit_storing
= 1;
2888 if (!inhibit_storing
)
2892 if (startpos
< pos
&& startpos
> prev
)
2895 else if (endpos
< pos
&& endpos
> prev
)
2897 else if (endpos
== pos
&& startpos
> prev
2898 && (!change_req
|| startpos
< pos
))
2909 /* Find all the overlays in the current buffer that overlap the range
2910 BEG-END, or are empty at BEG, or are empty at END provided END
2911 denotes the position at the end of the current buffer.
2913 Return the number found, and store them in a vector in *VEC_PTR.
2914 Store in *LEN_PTR the size allocated for the vector.
2915 Store in *NEXT_PTR the next position after POS where an overlay starts,
2916 or ZV if there are no more overlays.
2917 Store in *PREV_PTR the previous position before POS where an overlay ends,
2918 or BEGV if there are no previous overlays.
2919 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2921 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2922 when this function is called.
2924 If EXTEND, make the vector bigger if necessary.
2925 If not, never extend the vector,
2926 and store only as many overlays as will fit.
2927 But still return the total number of overlays. */
2930 overlays_in (EMACS_INT beg
, EMACS_INT end
, bool extend
,
2931 Lisp_Object
**vec_ptr
, ptrdiff_t *len_ptr
,
2932 ptrdiff_t *next_ptr
, ptrdiff_t *prev_ptr
)
2934 Lisp_Object overlay
, ostart
, oend
;
2935 struct Lisp_Overlay
*tail
;
2937 ptrdiff_t len
= *len_ptr
;
2938 Lisp_Object
*vec
= *vec_ptr
;
2939 ptrdiff_t next
= ZV
;
2940 ptrdiff_t prev
= BEGV
;
2941 bool inhibit_storing
= 0;
2942 bool end_is_Z
= end
== Z
;
2944 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2946 ptrdiff_t startpos
, endpos
;
2948 XSETMISC (overlay
, tail
);
2950 ostart
= OVERLAY_START (overlay
);
2951 oend
= OVERLAY_END (overlay
);
2952 endpos
= OVERLAY_POSITION (oend
);
2959 startpos
= OVERLAY_POSITION (ostart
);
2960 /* Count an interval if it overlaps the range, is empty at the
2961 start of the range, or is empty at END provided END denotes the
2962 end of the buffer. */
2963 if ((beg
< endpos
&& startpos
< end
)
2964 || (startpos
== endpos
2965 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
2969 /* The supplied vector is full.
2970 Either make it bigger, or don't store any more in it. */
2973 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2979 inhibit_storing
= 1;
2982 if (!inhibit_storing
)
2984 /* Keep counting overlays even if we can't return them all. */
2987 else if (startpos
< next
)
2991 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2993 ptrdiff_t startpos
, endpos
;
2995 XSETMISC (overlay
, tail
);
2997 ostart
= OVERLAY_START (overlay
);
2998 oend
= OVERLAY_END (overlay
);
2999 startpos
= OVERLAY_POSITION (ostart
);
3002 if (startpos
< next
)
3006 endpos
= OVERLAY_POSITION (oend
);
3007 /* Count an interval if it overlaps the range, is empty at the
3008 start of the range, or is empty at END provided END denotes the
3009 end of the buffer. */
3010 if ((beg
< endpos
&& startpos
< end
)
3011 || (startpos
== endpos
3012 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
3018 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
3024 inhibit_storing
= 1;
3027 if (!inhibit_storing
)
3031 else if (endpos
< beg
&& endpos
> prev
)
3043 /* Return true if there exists an overlay with a non-nil
3044 `mouse-face' property overlapping OVERLAY. */
3047 mouse_face_overlay_overlaps (Lisp_Object overlay
)
3049 ptrdiff_t start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3050 ptrdiff_t end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3051 ptrdiff_t n
, i
, size
;
3052 Lisp_Object
*v
, tem
;
3055 v
= alloca (size
* sizeof *v
);
3056 n
= overlays_in (start
, end
, 0, &v
, &size
, NULL
, NULL
);
3059 v
= alloca (n
* sizeof *v
);
3060 overlays_in (start
, end
, 0, &v
, &n
, NULL
, NULL
);
3063 for (i
= 0; i
< n
; ++i
)
3064 if (!EQ (v
[i
], overlay
)
3065 && (tem
= Foverlay_get (overlay
, Qmouse_face
),
3074 /* Fast function to just test if we're at an overlay boundary. */
3076 overlay_touches_p (ptrdiff_t pos
)
3078 Lisp_Object overlay
;
3079 struct Lisp_Overlay
*tail
;
3081 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
3085 XSETMISC (overlay
,tail
);
3086 eassert (OVERLAYP (overlay
));
3088 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3091 if (endpos
== pos
|| OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
)
3095 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
3099 XSETMISC (overlay
, tail
);
3100 eassert (OVERLAYP (overlay
));
3102 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3105 if (startpos
== pos
|| OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
)
3113 Lisp_Object overlay
;
3119 compare_overlays (const void *v1
, const void *v2
)
3121 const struct sortvec
*s1
= (const struct sortvec
*) v1
;
3122 const struct sortvec
*s2
= (const struct sortvec
*) v2
;
3123 if (s1
->priority
!= s2
->priority
)
3124 return s1
->priority
< s2
->priority
? -1 : 1;
3125 if (s1
->beg
!= s2
->beg
)
3126 return s1
->beg
< s2
->beg
? -1 : 1;
3127 if (s1
->end
!= s2
->end
)
3128 return s2
->end
< s1
->end
? -1 : 1;
3129 /* Avoid the non-determinism of qsort by choosing an arbitrary ordering
3130 between "equal" overlays. The result can still change between
3131 invocations of Emacs, but it won't change in the middle of
3132 `find_field' (bug#6830). */
3133 if (XHASH (s1
->overlay
) != XHASH (s2
->overlay
))
3134 return XHASH (s1
->overlay
) < XHASH (s2
->overlay
) ? -1 : 1;
3138 /* Sort an array of overlays by priority. The array is modified in place.
3139 The return value is the new size; this may be smaller than the original
3140 size if some of the overlays were invalid or were window-specific. */
3142 sort_overlays (Lisp_Object
*overlay_vec
, ptrdiff_t noverlays
, struct window
*w
)
3145 struct sortvec
*sortvec
= alloca (noverlays
* sizeof *sortvec
);
3147 /* Put the valid and relevant overlays into sortvec. */
3149 for (i
= 0, j
= 0; i
< noverlays
; i
++)
3152 Lisp_Object overlay
;
3154 overlay
= overlay_vec
[i
];
3155 if (OVERLAYP (overlay
)
3156 && OVERLAY_POSITION (OVERLAY_START (overlay
)) > 0
3157 && OVERLAY_POSITION (OVERLAY_END (overlay
)) > 0)
3159 /* If we're interested in a specific window, then ignore
3160 overlays that are limited to some other window. */
3165 window
= Foverlay_get (overlay
, Qwindow
);
3166 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3170 /* This overlay is good and counts: put it into sortvec. */
3171 sortvec
[j
].overlay
= overlay
;
3172 sortvec
[j
].beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3173 sortvec
[j
].end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3174 tem
= Foverlay_get (overlay
, Qpriority
);
3176 sortvec
[j
].priority
= XINT (tem
);
3178 sortvec
[j
].priority
= 0;
3184 /* Sort the overlays into the proper order: increasing priority. */
3187 qsort (sortvec
, noverlays
, sizeof (struct sortvec
), compare_overlays
);
3189 for (i
= 0; i
< noverlays
; i
++)
3190 overlay_vec
[i
] = sortvec
[i
].overlay
;
3196 Lisp_Object string
, string2
;
3203 struct sortstr
*buf
; /* An array that expands as needed; never freed. */
3204 ptrdiff_t size
; /* Allocated length of that array. */
3205 ptrdiff_t used
; /* How much of the array is currently in use. */
3206 ptrdiff_t bytes
; /* Total length of the strings in buf. */
3209 /* Buffers for storing information about the overlays touching a given
3210 position. These could be automatic variables in overlay_strings, but
3211 it's more efficient to hold onto the memory instead of repeatedly
3212 allocating and freeing it. */
3213 static struct sortstrlist overlay_heads
, overlay_tails
;
3214 static unsigned char *overlay_str_buf
;
3216 /* Allocated length of overlay_str_buf. */
3217 static ptrdiff_t overlay_str_len
;
3219 /* A comparison function suitable for passing to qsort. */
3221 cmp_for_strings (const void *as1
, const void *as2
)
3223 struct sortstr
*s1
= (struct sortstr
*)as1
;
3224 struct sortstr
*s2
= (struct sortstr
*)as2
;
3225 if (s1
->size
!= s2
->size
)
3226 return s2
->size
< s1
->size
? -1 : 1;
3227 if (s1
->priority
!= s2
->priority
)
3228 return s1
->priority
< s2
->priority
? -1 : 1;
3233 record_overlay_string (struct sortstrlist
*ssl
, Lisp_Object str
,
3234 Lisp_Object str2
, Lisp_Object pri
, ptrdiff_t size
)
3238 if (ssl
->used
== ssl
->size
)
3239 ssl
->buf
= xpalloc (ssl
->buf
, &ssl
->size
, 5, -1, sizeof *ssl
->buf
);
3240 ssl
->buf
[ssl
->used
].string
= str
;
3241 ssl
->buf
[ssl
->used
].string2
= str2
;
3242 ssl
->buf
[ssl
->used
].size
= size
;
3243 ssl
->buf
[ssl
->used
].priority
= (INTEGERP (pri
) ? XINT (pri
) : 0);
3246 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3247 nbytes
= SCHARS (str
);
3248 else if (! STRING_MULTIBYTE (str
))
3249 nbytes
= count_size_as_multibyte (SDATA (str
),
3252 nbytes
= SBYTES (str
);
3254 if (INT_ADD_OVERFLOW (ssl
->bytes
, nbytes
))
3255 memory_full (SIZE_MAX
);
3256 ssl
->bytes
+= nbytes
;
3260 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3261 nbytes
= SCHARS (str2
);
3262 else if (! STRING_MULTIBYTE (str2
))
3263 nbytes
= count_size_as_multibyte (SDATA (str2
),
3266 nbytes
= SBYTES (str2
);
3268 if (INT_ADD_OVERFLOW (ssl
->bytes
, nbytes
))
3269 memory_full (SIZE_MAX
);
3270 ssl
->bytes
+= nbytes
;
3274 /* Return the concatenation of the strings associated with overlays that
3275 begin or end at POS, ignoring overlays that are specific to a window
3276 other than W. The strings are concatenated in the appropriate order:
3277 shorter overlays nest inside longer ones, and higher priority inside
3278 lower. Normally all of the after-strings come first, but zero-sized
3279 overlays have their after-strings ride along with the before-strings
3280 because it would look strange to print them inside-out.
3282 Returns the string length, and stores the contents indirectly through
3283 PSTR, if that variable is non-null. The string may be overwritten by
3284 subsequent calls. */
3287 overlay_strings (ptrdiff_t pos
, struct window
*w
, unsigned char **pstr
)
3289 Lisp_Object overlay
, window
, str
;
3290 struct Lisp_Overlay
*ov
;
3291 ptrdiff_t startpos
, endpos
;
3292 bool multibyte
= ! NILP (BVAR (current_buffer
, enable_multibyte_characters
));
3294 overlay_heads
.used
= overlay_heads
.bytes
= 0;
3295 overlay_tails
.used
= overlay_tails
.bytes
= 0;
3296 for (ov
= current_buffer
->overlays_before
; ov
; ov
= ov
->next
)
3298 XSETMISC (overlay
, ov
);
3299 eassert (OVERLAYP (overlay
));
3301 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3302 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3305 if (endpos
!= pos
&& startpos
!= pos
)
3307 window
= Foverlay_get (overlay
, Qwindow
);
3308 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3311 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3312 record_overlay_string (&overlay_heads
, str
,
3314 ? Foverlay_get (overlay
, Qafter_string
)
3316 Foverlay_get (overlay
, Qpriority
),
3318 else if (endpos
== pos
3319 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3320 record_overlay_string (&overlay_tails
, str
, Qnil
,
3321 Foverlay_get (overlay
, Qpriority
),
3324 for (ov
= current_buffer
->overlays_after
; ov
; ov
= ov
->next
)
3326 XSETMISC (overlay
, ov
);
3327 eassert (OVERLAYP (overlay
));
3329 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3330 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3333 if (endpos
!= pos
&& startpos
!= pos
)
3335 window
= Foverlay_get (overlay
, Qwindow
);
3336 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3339 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3340 record_overlay_string (&overlay_heads
, str
,
3342 ? Foverlay_get (overlay
, Qafter_string
)
3344 Foverlay_get (overlay
, Qpriority
),
3346 else if (endpos
== pos
3347 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3348 record_overlay_string (&overlay_tails
, str
, Qnil
,
3349 Foverlay_get (overlay
, Qpriority
),
3352 if (overlay_tails
.used
> 1)
3353 qsort (overlay_tails
.buf
, overlay_tails
.used
, sizeof (struct sortstr
),
3355 if (overlay_heads
.used
> 1)
3356 qsort (overlay_heads
.buf
, overlay_heads
.used
, sizeof (struct sortstr
),
3358 if (overlay_heads
.bytes
|| overlay_tails
.bytes
)
3365 if (INT_ADD_OVERFLOW (overlay_heads
.bytes
, overlay_tails
.bytes
))
3366 memory_full (SIZE_MAX
);
3367 total
= overlay_heads
.bytes
+ overlay_tails
.bytes
;
3368 if (total
> overlay_str_len
)
3369 overlay_str_buf
= xpalloc (overlay_str_buf
, &overlay_str_len
,
3370 total
- overlay_str_len
, -1, 1);
3372 p
= overlay_str_buf
;
3373 for (i
= overlay_tails
.used
; --i
>= 0;)
3376 tem
= overlay_tails
.buf
[i
].string
;
3377 nbytes
= copy_text (SDATA (tem
), p
,
3379 STRING_MULTIBYTE (tem
), multibyte
);
3382 for (i
= 0; i
< overlay_heads
.used
; ++i
)
3385 tem
= overlay_heads
.buf
[i
].string
;
3386 nbytes
= copy_text (SDATA (tem
), p
,
3388 STRING_MULTIBYTE (tem
), multibyte
);
3390 tem
= overlay_heads
.buf
[i
].string2
;
3393 nbytes
= copy_text (SDATA (tem
), p
,
3395 STRING_MULTIBYTE (tem
), multibyte
);
3399 if (p
!= overlay_str_buf
+ total
)
3402 *pstr
= overlay_str_buf
;
3408 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
3411 recenter_overlay_lists (struct buffer
*buf
, ptrdiff_t pos
)
3413 Lisp_Object overlay
, beg
, end
;
3414 struct Lisp_Overlay
*prev
, *tail
, *next
;
3416 /* See if anything in overlays_before should move to overlays_after. */
3418 /* We don't strictly need prev in this loop; it should always be nil.
3419 But we use it for symmetry and in case that should cease to be true
3420 with some future change. */
3422 for (tail
= buf
->overlays_before
; tail
; prev
= tail
, tail
= next
)
3425 XSETMISC (overlay
, tail
);
3426 eassert (OVERLAYP (overlay
));
3428 beg
= OVERLAY_START (overlay
);
3429 end
= OVERLAY_END (overlay
);
3431 if (OVERLAY_POSITION (end
) > pos
)
3433 /* OVERLAY needs to be moved. */
3434 ptrdiff_t where
= OVERLAY_POSITION (beg
);
3435 struct Lisp_Overlay
*other
, *other_prev
;
3437 /* Splice the cons cell TAIL out of overlays_before. */
3441 set_buffer_overlays_before (buf
, next
);
3443 /* Search thru overlays_after for where to put it. */
3445 for (other
= buf
->overlays_after
; other
;
3446 other_prev
= other
, other
= other
->next
)
3448 Lisp_Object otherbeg
, otheroverlay
;
3450 XSETMISC (otheroverlay
, other
);
3451 eassert (OVERLAYP (otheroverlay
));
3453 otherbeg
= OVERLAY_START (otheroverlay
);
3454 if (OVERLAY_POSITION (otherbeg
) >= where
)
3458 /* Add TAIL to overlays_after before OTHER. */
3461 other_prev
->next
= tail
;
3463 set_buffer_overlays_after (buf
, tail
);
3467 /* We've reached the things that should stay in overlays_before.
3468 All the rest of overlays_before must end even earlier,
3473 /* See if anything in overlays_after should be in overlays_before. */
3475 for (tail
= buf
->overlays_after
; tail
; prev
= tail
, tail
= next
)
3478 XSETMISC (overlay
, tail
);
3479 eassert (OVERLAYP (overlay
));
3481 beg
= OVERLAY_START (overlay
);
3482 end
= OVERLAY_END (overlay
);
3484 /* Stop looking, when we know that nothing further
3485 can possibly end before POS. */
3486 if (OVERLAY_POSITION (beg
) > pos
)
3489 if (OVERLAY_POSITION (end
) <= pos
)
3491 /* OVERLAY needs to be moved. */
3492 ptrdiff_t where
= OVERLAY_POSITION (end
);
3493 struct Lisp_Overlay
*other
, *other_prev
;
3495 /* Splice the cons cell TAIL out of overlays_after. */
3499 set_buffer_overlays_after (buf
, next
);
3501 /* Search thru overlays_before for where to put it. */
3503 for (other
= buf
->overlays_before
; other
;
3504 other_prev
= other
, other
= other
->next
)
3506 Lisp_Object otherend
, otheroverlay
;
3508 XSETMISC (otheroverlay
, other
);
3509 eassert (OVERLAYP (otheroverlay
));
3511 otherend
= OVERLAY_END (otheroverlay
);
3512 if (OVERLAY_POSITION (otherend
) <= where
)
3516 /* Add TAIL to overlays_before before OTHER. */
3519 other_prev
->next
= tail
;
3521 set_buffer_overlays_before (buf
, tail
);
3526 buf
->overlay_center
= pos
;
3530 adjust_overlays_for_insert (ptrdiff_t pos
, ptrdiff_t length
)
3532 /* After an insertion, the lists are still sorted properly,
3533 but we may need to update the value of the overlay center. */
3534 if (current_buffer
->overlay_center
>= pos
)
3535 current_buffer
->overlay_center
+= length
;
3539 adjust_overlays_for_delete (ptrdiff_t pos
, ptrdiff_t length
)
3541 if (current_buffer
->overlay_center
< pos
)
3542 /* The deletion was to our right. No change needed; the before- and
3543 after-lists are still consistent. */
3545 else if (current_buffer
->overlay_center
- pos
> length
)
3546 /* The deletion was to our left. We need to adjust the center value
3547 to account for the change in position, but the lists are consistent
3548 given the new value. */
3549 current_buffer
->overlay_center
-= length
;
3551 /* We're right in the middle. There might be things on the after-list
3552 that now belong on the before-list. Recentering will move them,
3553 and also update the center point. */
3554 recenter_overlay_lists (current_buffer
, pos
);
3557 /* Fix up overlays that were garbled as a result of permuting markers
3558 in the range START through END. Any overlay with at least one
3559 endpoint in this range will need to be unlinked from the overlay
3560 list and reinserted in its proper place.
3561 Such an overlay might even have negative size at this point.
3562 If so, we'll make the overlay empty. */
3564 fix_start_end_in_overlays (register ptrdiff_t start
, register ptrdiff_t end
)
3566 Lisp_Object overlay
;
3567 struct Lisp_Overlay
*before_list
IF_LINT (= NULL
);
3568 struct Lisp_Overlay
*after_list
IF_LINT (= NULL
);
3569 /* These are either nil, indicating that before_list or after_list
3570 should be assigned, or the cons cell the cdr of which should be
3572 struct Lisp_Overlay
*beforep
= NULL
, *afterp
= NULL
;
3573 /* 'Parent', likewise, indicates a cons cell or
3574 current_buffer->overlays_before or overlays_after, depending
3575 which loop we're in. */
3576 struct Lisp_Overlay
*tail
, *parent
;
3577 ptrdiff_t startpos
, endpos
;
3579 /* This algorithm shifts links around instead of consing and GCing.
3580 The loop invariant is that before_list (resp. after_list) is a
3581 well-formed list except that its last element, the CDR of beforep
3582 (resp. afterp) if beforep (afterp) isn't nil or before_list
3583 (after_list) if it is, is still uninitialized. So it's not a bug
3584 that before_list isn't initialized, although it may look
3586 for (parent
= NULL
, tail
= current_buffer
->overlays_before
; tail
;)
3588 XSETMISC (overlay
, tail
);
3590 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3591 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3593 /* If the overlay is backwards, make it empty. */
3594 if (endpos
< startpos
)
3597 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3605 || (startpos
>= start
&& startpos
< end
))
3607 /* Add it to the end of the wrong list. Later on,
3608 recenter_overlay_lists will move it to the right place. */
3609 if (endpos
< current_buffer
->overlay_center
)
3614 afterp
->next
= tail
;
3622 beforep
->next
= tail
;
3626 set_buffer_overlays_before (current_buffer
, tail
->next
);
3628 parent
->next
= tail
->next
;
3632 parent
= tail
, tail
= parent
->next
;
3634 for (parent
= NULL
, tail
= current_buffer
->overlays_after
; tail
;)
3636 XSETMISC (overlay
, tail
);
3638 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3639 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3641 /* If the overlay is backwards, make it empty. */
3642 if (endpos
< startpos
)
3645 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3649 if (startpos
>= end
)
3652 if (startpos
>= start
3653 || (endpos
>= start
&& endpos
< end
))
3655 if (endpos
< current_buffer
->overlay_center
)
3660 afterp
->next
= tail
;
3668 beforep
->next
= tail
;
3672 set_buffer_overlays_after (current_buffer
, tail
->next
);
3674 parent
->next
= tail
->next
;
3678 parent
= tail
, tail
= parent
->next
;
3681 /* Splice the constructed (wrong) lists into the buffer's lists,
3682 and let the recenter function make it sane again. */
3685 beforep
->next
= current_buffer
->overlays_before
;
3686 set_buffer_overlays_before (current_buffer
, before_list
);
3688 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3692 afterp
->next
= current_buffer
->overlays_after
;
3693 set_buffer_overlays_after (current_buffer
, after_list
);
3695 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3698 /* We have two types of overlay: the one whose ending marker is
3699 after-insertion-marker (this is the usual case) and the one whose
3700 ending marker is before-insertion-marker. When `overlays_before'
3701 contains overlays of the latter type and the former type in this
3702 order and both overlays end at inserting position, inserting a text
3703 increases only the ending marker of the latter type, which results
3704 in incorrect ordering of `overlays_before'.
3706 This function fixes ordering of overlays in the slot
3707 `overlays_before' of the buffer *BP. Before the insertion, `point'
3708 was at PREV, and now is at POS. */
3711 fix_overlays_before (struct buffer
*bp
, ptrdiff_t prev
, ptrdiff_t pos
)
3713 /* If parent is nil, replace overlays_before; otherwise, parent->next. */
3714 struct Lisp_Overlay
*tail
= bp
->overlays_before
, *parent
= NULL
, *right_pair
;
3716 ptrdiff_t end
IF_LINT (= 0);
3718 /* After the insertion, the several overlays may be in incorrect
3719 order. The possibility is that, in the list `overlays_before',
3720 an overlay which ends at POS appears after an overlay which ends
3721 at PREV. Since POS is greater than PREV, we must fix the
3722 ordering of these overlays, by moving overlays ends at POS before
3723 the overlays ends at PREV. */
3725 /* At first, find a place where disordered overlays should be linked
3726 in. It is where an overlay which end before POS exists. (i.e. an
3727 overlay whose ending marker is after-insertion-marker if disorder
3730 && (XSETMISC (tem
, tail
),
3731 (end
= OVERLAY_POSITION (OVERLAY_END (tem
))) >= pos
))
3737 /* If we don't find such an overlay,
3738 or the found one ends before PREV,
3739 or the found one is the last one in the list,
3740 we don't have to fix anything. */
3741 if (!tail
|| end
< prev
|| !tail
->next
)
3744 right_pair
= parent
;
3748 /* Now, end position of overlays in the list TAIL should be before
3749 or equal to PREV. In the loop, an overlay which ends at POS is
3750 moved ahead to the place indicated by the CDR of RIGHT_PAIR. If
3751 we found an overlay which ends before PREV, the remaining
3752 overlays are in correct order. */
3755 XSETMISC (tem
, tail
);
3756 end
= OVERLAY_POSITION (OVERLAY_END (tem
));
3759 { /* This overlay is disordered. */
3760 struct Lisp_Overlay
*found
= tail
;
3762 /* Unlink the found overlay. */
3764 parent
->next
= tail
;
3765 /* Move an overlay at RIGHT_PLACE to the next of the found one,
3766 and link it into the right place. */
3769 found
->next
= bp
->overlays_before
;
3770 set_buffer_overlays_before (bp
, found
);
3774 found
->next
= right_pair
->next
;
3775 right_pair
->next
= found
;
3778 else if (end
== prev
)
3783 else /* No more disordered overlay. */
3788 DEFUN ("overlayp", Foverlayp
, Soverlayp
, 1, 1, 0,
3789 doc
: /* Return t if OBJECT is an overlay. */)
3790 (Lisp_Object object
)
3792 return (OVERLAYP (object
) ? Qt
: Qnil
);
3795 DEFUN ("make-overlay", Fmake_overlay
, Smake_overlay
, 2, 5, 0,
3796 doc
: /* Create a new overlay with range BEG to END in BUFFER.
3797 If omitted, BUFFER defaults to the current buffer.
3798 BEG and END may be integers or markers.
3799 The fourth arg FRONT-ADVANCE, if non-nil, makes the marker
3800 for the front of the overlay advance when text is inserted there
3801 \(which means the text *is not* included in the overlay).
3802 The fifth arg REAR-ADVANCE, if non-nil, makes the marker
3803 for the rear of the overlay advance when text is inserted there
3804 \(which means the text *is* included in the overlay). */)
3805 (Lisp_Object beg
, Lisp_Object end
, Lisp_Object buffer
, Lisp_Object front_advance
, Lisp_Object rear_advance
)
3807 Lisp_Object overlay
;
3811 XSETBUFFER (buffer
, current_buffer
);
3813 CHECK_BUFFER (buffer
);
3815 && ! EQ (Fmarker_buffer (beg
), buffer
))
3816 error ("Marker points into wrong buffer");
3818 && ! EQ (Fmarker_buffer (end
), buffer
))
3819 error ("Marker points into wrong buffer");
3821 CHECK_NUMBER_COERCE_MARKER (beg
);
3822 CHECK_NUMBER_COERCE_MARKER (end
);
3824 if (XINT (beg
) > XINT (end
))
3827 temp
= beg
; beg
= end
; end
= temp
;
3830 b
= XBUFFER (buffer
);
3832 beg
= Fset_marker (Fmake_marker (), beg
, buffer
);
3833 end
= Fset_marker (Fmake_marker (), end
, buffer
);
3835 if (!NILP (front_advance
))
3836 XMARKER (beg
)->insertion_type
= 1;
3837 if (!NILP (rear_advance
))
3838 XMARKER (end
)->insertion_type
= 1;
3840 overlay
= build_overlay (beg
, end
, Qnil
);
3842 /* Put the new overlay on the wrong list. */
3843 end
= OVERLAY_END (overlay
);
3844 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
3846 if (b
->overlays_after
)
3847 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3848 set_buffer_overlays_after (b
, XOVERLAY (overlay
));
3852 if (b
->overlays_before
)
3853 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3854 set_buffer_overlays_before (b
, XOVERLAY (overlay
));
3857 /* This puts it in the right list, and in the right order. */
3858 recenter_overlay_lists (b
, b
->overlay_center
);
3860 /* We don't need to redisplay the region covered by the overlay, because
3861 the overlay has no properties at the moment. */
3866 /* Mark a section of BUF as needing redisplay because of overlays changes. */
3869 modify_overlay (struct buffer
*buf
, ptrdiff_t start
, ptrdiff_t end
)
3873 ptrdiff_t temp
= start
;
3878 BUF_COMPUTE_UNCHANGED (buf
, start
, end
);
3880 /* If this is a buffer not in the selected window,
3881 we must do other windows. */
3882 if (buf
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
3883 windows_or_buffers_changed
= 1;
3884 /* If multiple windows show this buffer, we must do other windows. */
3885 else if (buffer_shared
> 1)
3886 windows_or_buffers_changed
= 1;
3887 /* If we modify an overlay at the end of the buffer, we cannot
3888 be sure that window end is still valid. */
3889 else if (end
>= ZV
&& start
<= ZV
)
3890 windows_or_buffers_changed
= 1;
3892 ++BUF_OVERLAY_MODIFF (buf
);
3895 /* Remove OVERLAY from LIST. */
3897 static struct Lisp_Overlay
*
3898 unchain_overlay (struct Lisp_Overlay
*list
, struct Lisp_Overlay
*overlay
)
3900 register struct Lisp_Overlay
*tail
, **prev
= &list
;
3902 for (tail
= list
; tail
; prev
= &tail
->next
, tail
= *prev
)
3903 if (tail
== overlay
)
3905 *prev
= overlay
->next
;
3906 overlay
->next
= NULL
;
3912 /* Remove OVERLAY from both overlay lists of B. */
3915 unchain_both (struct buffer
*b
, Lisp_Object overlay
)
3917 struct Lisp_Overlay
*ov
= XOVERLAY (overlay
);
3919 set_buffer_overlays_before (b
, unchain_overlay (b
->overlays_before
, ov
));
3920 set_buffer_overlays_after (b
, unchain_overlay (b
->overlays_after
, ov
));
3921 eassert (XOVERLAY (overlay
)->next
== NULL
);
3924 DEFUN ("move-overlay", Fmove_overlay
, Smove_overlay
, 3, 4, 0,
3925 doc
: /* Set the endpoints of OVERLAY to BEG and END in BUFFER.
3926 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.
3927 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current
3929 (Lisp_Object overlay
, Lisp_Object beg
, Lisp_Object end
, Lisp_Object buffer
)
3931 struct buffer
*b
, *ob
= 0;
3932 Lisp_Object obuffer
;
3933 ptrdiff_t count
= SPECPDL_INDEX ();
3934 ptrdiff_t n_beg
, n_end
, o_beg
IF_LINT (= 0), o_end
IF_LINT (= 0);
3936 CHECK_OVERLAY (overlay
);
3938 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3940 XSETBUFFER (buffer
, current_buffer
);
3941 CHECK_BUFFER (buffer
);
3943 if (NILP (Fbuffer_live_p (buffer
)))
3944 error ("Attempt to move overlay to a dead buffer");
3947 && ! EQ (Fmarker_buffer (beg
), buffer
))
3948 error ("Marker points into wrong buffer");
3950 && ! EQ (Fmarker_buffer (end
), buffer
))
3951 error ("Marker points into wrong buffer");
3953 CHECK_NUMBER_COERCE_MARKER (beg
);
3954 CHECK_NUMBER_COERCE_MARKER (end
);
3956 if (XINT (beg
) > XINT (end
))
3959 temp
= beg
; beg
= end
; end
= temp
;
3962 specbind (Qinhibit_quit
, Qt
);
3964 obuffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3965 b
= XBUFFER (buffer
);
3967 if (!NILP (obuffer
))
3969 ob
= XBUFFER (obuffer
);
3971 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3972 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3974 unchain_both (ob
, overlay
);
3977 /* Set the overlay boundaries, which may clip them. */
3978 Fset_marker (OVERLAY_START (overlay
), beg
, buffer
);
3979 Fset_marker (OVERLAY_END (overlay
), end
, buffer
);
3981 n_beg
= marker_position (OVERLAY_START (overlay
));
3982 n_end
= marker_position (OVERLAY_END (overlay
));
3984 /* If the overlay has changed buffers, do a thorough redisplay. */
3985 if (!EQ (buffer
, obuffer
))
3987 /* Redisplay where the overlay was. */
3989 modify_overlay (ob
, o_beg
, o_end
);
3991 /* Redisplay where the overlay is going to be. */
3992 modify_overlay (b
, n_beg
, n_end
);
3995 /* Redisplay the area the overlay has just left, or just enclosed. */
3998 modify_overlay (b
, o_end
, n_end
);
3999 else if (o_end
== n_end
)
4000 modify_overlay (b
, o_beg
, n_beg
);
4002 modify_overlay (b
, min (o_beg
, n_beg
), max (o_end
, n_end
));
4005 /* Delete the overlay if it is empty after clipping and has the
4006 evaporate property. */
4007 if (n_beg
== n_end
&& !NILP (Foverlay_get (overlay
, Qevaporate
)))
4008 return unbind_to (count
, Fdelete_overlay (overlay
));
4010 /* Put the overlay into the new buffer's overlay lists, first on the
4012 if (n_end
< b
->overlay_center
)
4014 XOVERLAY (overlay
)->next
= b
->overlays_after
;
4015 set_buffer_overlays_after (b
, XOVERLAY (overlay
));
4019 XOVERLAY (overlay
)->next
= b
->overlays_before
;
4020 set_buffer_overlays_before (b
, XOVERLAY (overlay
));
4023 /* This puts it in the right list, and in the right order. */
4024 recenter_overlay_lists (b
, b
->overlay_center
);
4026 return unbind_to (count
, overlay
);
4029 DEFUN ("delete-overlay", Fdelete_overlay
, Sdelete_overlay
, 1, 1, 0,
4030 doc
: /* Delete the overlay OVERLAY from its buffer. */)
4031 (Lisp_Object overlay
)
4035 ptrdiff_t count
= SPECPDL_INDEX ();
4037 CHECK_OVERLAY (overlay
);
4039 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4043 b
= XBUFFER (buffer
);
4044 specbind (Qinhibit_quit
, Qt
);
4046 unchain_both (b
, overlay
);
4047 drop_overlay (b
, XOVERLAY (overlay
));
4049 /* When deleting an overlay with before or after strings, turn off
4050 display optimizations for the affected buffer, on the basis that
4051 these strings may contain newlines. This is easier to do than to
4052 check for that situation during redisplay. */
4053 if (!windows_or_buffers_changed
4054 && (!NILP (Foverlay_get (overlay
, Qbefore_string
))
4055 || !NILP (Foverlay_get (overlay
, Qafter_string
))))
4056 b
->prevent_redisplay_optimizations_p
= 1;
4058 return unbind_to (count
, Qnil
);
4061 DEFUN ("delete-all-overlays", Fdelete_all_overlays
, Sdelete_all_overlays
, 0, 1, 0,
4062 doc
: /* Delete all overlays of BUFFER.
4063 BUFFER omitted or nil means delete all overlays of the current
4065 (Lisp_Object buffer
)
4067 register struct buffer
*buf
;
4070 buf
= current_buffer
;
4073 CHECK_BUFFER (buffer
);
4074 buf
= XBUFFER (buffer
);
4077 delete_all_overlays (buf
);
4081 /* Overlay dissection functions. */
4083 DEFUN ("overlay-start", Foverlay_start
, Soverlay_start
, 1, 1, 0,
4084 doc
: /* Return the position at which OVERLAY starts. */)
4085 (Lisp_Object overlay
)
4087 CHECK_OVERLAY (overlay
);
4089 return (Fmarker_position (OVERLAY_START (overlay
)));
4092 DEFUN ("overlay-end", Foverlay_end
, Soverlay_end
, 1, 1, 0,
4093 doc
: /* Return the position at which OVERLAY ends. */)
4094 (Lisp_Object overlay
)
4096 CHECK_OVERLAY (overlay
);
4098 return (Fmarker_position (OVERLAY_END (overlay
)));
4101 DEFUN ("overlay-buffer", Foverlay_buffer
, Soverlay_buffer
, 1, 1, 0,
4102 doc
: /* Return the buffer OVERLAY belongs to.
4103 Return nil if OVERLAY has been deleted. */)
4104 (Lisp_Object overlay
)
4106 CHECK_OVERLAY (overlay
);
4108 return Fmarker_buffer (OVERLAY_START (overlay
));
4111 DEFUN ("overlay-properties", Foverlay_properties
, Soverlay_properties
, 1, 1, 0,
4112 doc
: /* Return a list of the properties on OVERLAY.
4113 This is a copy of OVERLAY's plist; modifying its conses has no effect on
4115 (Lisp_Object overlay
)
4117 CHECK_OVERLAY (overlay
);
4119 return Fcopy_sequence (XOVERLAY (overlay
)->plist
);
4123 DEFUN ("overlays-at", Foverlays_at
, Soverlays_at
, 1, 1, 0,
4124 doc
: /* Return a list of the overlays that contain the character at POS. */)
4127 ptrdiff_t len
, noverlays
;
4128 Lisp_Object
*overlay_vec
;
4131 CHECK_NUMBER_COERCE_MARKER (pos
);
4134 /* We can't use alloca here because overlays_at can call xrealloc. */
4135 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4137 /* Put all the overlays we want in a vector in overlay_vec.
4138 Store the length in len. */
4139 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4142 /* Make a list of them all. */
4143 result
= Flist (noverlays
, overlay_vec
);
4145 xfree (overlay_vec
);
4149 DEFUN ("overlays-in", Foverlays_in
, Soverlays_in
, 2, 2, 0,
4150 doc
: /* Return a list of the overlays that overlap the region BEG ... END.
4151 Overlap means that at least one character is contained within the overlay
4152 and also contained within the specified region.
4153 Empty overlays are included in the result if they are located at BEG,
4154 between BEG and END, or at END provided END denotes the position at the
4155 end of the buffer. */)
4156 (Lisp_Object beg
, Lisp_Object end
)
4158 ptrdiff_t len
, noverlays
;
4159 Lisp_Object
*overlay_vec
;
4162 CHECK_NUMBER_COERCE_MARKER (beg
);
4163 CHECK_NUMBER_COERCE_MARKER (end
);
4166 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4168 /* Put all the overlays we want in a vector in overlay_vec.
4169 Store the length in len. */
4170 noverlays
= overlays_in (XINT (beg
), XINT (end
), 1, &overlay_vec
, &len
,
4173 /* Make a list of them all. */
4174 result
= Flist (noverlays
, overlay_vec
);
4176 xfree (overlay_vec
);
4180 DEFUN ("next-overlay-change", Fnext_overlay_change
, Snext_overlay_change
,
4182 doc
: /* Return the next position after POS where an overlay starts or ends.
4183 If there are no overlay boundaries from POS to (point-max),
4184 the value is (point-max). */)
4187 ptrdiff_t i
, len
, noverlays
;
4189 Lisp_Object
*overlay_vec
;
4191 CHECK_NUMBER_COERCE_MARKER (pos
);
4194 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4196 /* Put all the overlays we want in a vector in overlay_vec.
4197 Store the length in len.
4198 endpos gets the position where the next overlay starts. */
4199 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4202 /* If any of these overlays ends before endpos,
4203 use its ending point instead. */
4204 for (i
= 0; i
< noverlays
; i
++)
4209 oend
= OVERLAY_END (overlay_vec
[i
]);
4210 oendpos
= OVERLAY_POSITION (oend
);
4211 if (oendpos
< endpos
)
4215 xfree (overlay_vec
);
4216 return make_number (endpos
);
4219 DEFUN ("previous-overlay-change", Fprevious_overlay_change
,
4220 Sprevious_overlay_change
, 1, 1, 0,
4221 doc
: /* Return the previous position before POS where an overlay starts or ends.
4222 If there are no overlay boundaries from (point-min) to POS,
4223 the value is (point-min). */)
4227 Lisp_Object
*overlay_vec
;
4230 CHECK_NUMBER_COERCE_MARKER (pos
);
4232 /* At beginning of buffer, we know the answer;
4233 avoid bug subtracting 1 below. */
4234 if (XINT (pos
) == BEGV
)
4238 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4240 /* Put all the overlays we want in a vector in overlay_vec.
4241 Store the length in len.
4242 prevpos gets the position of the previous change. */
4243 overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4246 xfree (overlay_vec
);
4247 return make_number (prevpos
);
4250 /* These functions are for debugging overlays. */
4252 DEFUN ("overlay-lists", Foverlay_lists
, Soverlay_lists
, 0, 0, 0,
4253 doc
: /* Return a pair of lists giving all the overlays of the current buffer.
4254 The car has all the overlays before the overlay center;
4255 the cdr has all the overlays after the overlay center.
4256 Recentering overlays moves overlays between these lists.
4257 The lists you get are copies, so that changing them has no effect.
4258 However, the overlays you get are the real objects that the buffer uses. */)
4261 struct Lisp_Overlay
*ol
;
4262 Lisp_Object before
= Qnil
, after
= Qnil
, tmp
;
4264 for (ol
= current_buffer
->overlays_before
; ol
; ol
= ol
->next
)
4267 before
= Fcons (tmp
, before
);
4269 for (ol
= current_buffer
->overlays_after
; ol
; ol
= ol
->next
)
4272 after
= Fcons (tmp
, after
);
4275 return Fcons (Fnreverse (before
), Fnreverse (after
));
4278 DEFUN ("overlay-recenter", Foverlay_recenter
, Soverlay_recenter
, 1, 1, 0,
4279 doc
: /* Recenter the overlays of the current buffer around position POS.
4280 That makes overlay lookup faster for positions near POS (but perhaps slower
4281 for positions far away from POS). */)
4285 CHECK_NUMBER_COERCE_MARKER (pos
);
4287 p
= clip_to_bounds (PTRDIFF_MIN
, XINT (pos
), PTRDIFF_MAX
);
4288 recenter_overlay_lists (current_buffer
, p
);
4292 DEFUN ("overlay-get", Foverlay_get
, Soverlay_get
, 2, 2, 0,
4293 doc
: /* Get the property of overlay OVERLAY with property name PROP. */)
4294 (Lisp_Object overlay
, Lisp_Object prop
)
4296 CHECK_OVERLAY (overlay
);
4297 return lookup_char_property (XOVERLAY (overlay
)->plist
, prop
, 0);
4300 DEFUN ("overlay-put", Foverlay_put
, Soverlay_put
, 3, 3, 0,
4301 doc
: /* Set one property of overlay OVERLAY: give property PROP value VALUE.
4302 VALUE will be returned.*/)
4303 (Lisp_Object overlay
, Lisp_Object prop
, Lisp_Object value
)
4305 Lisp_Object tail
, buffer
;
4308 CHECK_OVERLAY (overlay
);
4310 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4312 for (tail
= XOVERLAY (overlay
)->plist
;
4313 CONSP (tail
) && CONSP (XCDR (tail
));
4314 tail
= XCDR (XCDR (tail
)))
4315 if (EQ (XCAR (tail
), prop
))
4317 changed
= !EQ (XCAR (XCDR (tail
)), value
);
4318 XSETCAR (XCDR (tail
), value
);
4321 /* It wasn't in the list, so add it to the front. */
4322 changed
= !NILP (value
);
4324 (overlay
, Fcons (prop
, Fcons (value
, XOVERLAY (overlay
)->plist
)));
4326 if (! NILP (buffer
))
4329 modify_overlay (XBUFFER (buffer
),
4330 marker_position (OVERLAY_START (overlay
)),
4331 marker_position (OVERLAY_END (overlay
)));
4332 if (EQ (prop
, Qevaporate
) && ! NILP (value
)
4333 && (OVERLAY_POSITION (OVERLAY_START (overlay
))
4334 == OVERLAY_POSITION (OVERLAY_END (overlay
))))
4335 Fdelete_overlay (overlay
);
4341 /* Subroutine of report_overlay_modification. */
4343 /* Lisp vector holding overlay hook functions to call.
4344 Vector elements come in pairs.
4345 Each even-index element is a list of hook functions.
4346 The following odd-index element is the overlay they came from.
4348 Before the buffer change, we fill in this vector
4349 as we call overlay hook functions.
4350 After the buffer change, we get the functions to call from this vector.
4351 This way we always call the same functions before and after the change. */
4352 static Lisp_Object last_overlay_modification_hooks
;
4354 /* Number of elements actually used in last_overlay_modification_hooks. */
4355 static ptrdiff_t last_overlay_modification_hooks_used
;
4357 /* Add one functionlist/overlay pair
4358 to the end of last_overlay_modification_hooks. */
4361 add_overlay_mod_hooklist (Lisp_Object functionlist
, Lisp_Object overlay
)
4363 ptrdiff_t oldsize
= ASIZE (last_overlay_modification_hooks
);
4365 if (oldsize
- 1 <= last_overlay_modification_hooks_used
)
4366 last_overlay_modification_hooks
=
4367 larger_vector (last_overlay_modification_hooks
, 2, -1);
4368 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4369 functionlist
); last_overlay_modification_hooks_used
++;
4370 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4371 overlay
); last_overlay_modification_hooks_used
++;
4374 /* Run the modification-hooks of overlays that include
4375 any part of the text in START to END.
4376 If this change is an insertion, also
4377 run the insert-before-hooks of overlay starting at END,
4378 and the insert-after-hooks of overlay ending at START.
4380 This is called both before and after the modification.
4381 AFTER is true when we call after the modification.
4383 ARG1, ARG2, ARG3 are arguments to pass to the hook functions.
4384 When AFTER is nonzero, they are the start position,
4385 the position after the inserted new text,
4386 and the length of deleted or replaced old text. */
4389 report_overlay_modification (Lisp_Object start
, Lisp_Object end
, bool after
,
4390 Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
)
4392 Lisp_Object prop
, overlay
;
4393 struct Lisp_Overlay
*tail
;
4394 /* True if this change is an insertion. */
4395 bool insertion
= (after
? XFASTINT (arg3
) == 0 : EQ (start
, end
));
4396 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4401 /* We used to run the functions as soon as we found them and only register
4402 them in last_overlay_modification_hooks for the purpose of the `after'
4403 case. But running elisp code as we traverse the list of overlays is
4404 painful because the list can be modified by the elisp code so we had to
4405 copy at several places. We now simply do a read-only traversal that
4406 only collects the functions to run and we run them afterwards. It's
4407 simpler, especially since all the code was already there. -stef */
4411 /* We are being called before a change.
4412 Scan the overlays to find the functions to call. */
4413 last_overlay_modification_hooks_used
= 0;
4414 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4416 ptrdiff_t startpos
, endpos
;
4417 Lisp_Object ostart
, oend
;
4419 XSETMISC (overlay
, tail
);
4421 ostart
= OVERLAY_START (overlay
);
4422 oend
= OVERLAY_END (overlay
);
4423 endpos
= OVERLAY_POSITION (oend
);
4424 if (XFASTINT (start
) > endpos
)
4426 startpos
= OVERLAY_POSITION (ostart
);
4427 if (insertion
&& (XFASTINT (start
) == startpos
4428 || XFASTINT (end
) == startpos
))
4430 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4432 add_overlay_mod_hooklist (prop
, overlay
);
4434 if (insertion
&& (XFASTINT (start
) == endpos
4435 || XFASTINT (end
) == endpos
))
4437 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4439 add_overlay_mod_hooklist (prop
, overlay
);
4441 /* Test for intersecting intervals. This does the right thing
4442 for both insertion and deletion. */
4443 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4445 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4447 add_overlay_mod_hooklist (prop
, overlay
);
4451 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4453 ptrdiff_t startpos
, endpos
;
4454 Lisp_Object ostart
, oend
;
4456 XSETMISC (overlay
, tail
);
4458 ostart
= OVERLAY_START (overlay
);
4459 oend
= OVERLAY_END (overlay
);
4460 startpos
= OVERLAY_POSITION (ostart
);
4461 endpos
= OVERLAY_POSITION (oend
);
4462 if (XFASTINT (end
) < startpos
)
4464 if (insertion
&& (XFASTINT (start
) == startpos
4465 || XFASTINT (end
) == startpos
))
4467 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4469 add_overlay_mod_hooklist (prop
, overlay
);
4471 if (insertion
&& (XFASTINT (start
) == endpos
4472 || XFASTINT (end
) == endpos
))
4474 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4476 add_overlay_mod_hooklist (prop
, overlay
);
4478 /* Test for intersecting intervals. This does the right thing
4479 for both insertion and deletion. */
4480 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4482 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4484 add_overlay_mod_hooklist (prop
, overlay
);
4489 GCPRO4 (overlay
, arg1
, arg2
, arg3
);
4491 /* Call the functions recorded in last_overlay_modification_hooks.
4492 First copy the vector contents, in case some of these hooks
4493 do subsequent modification of the buffer. */
4494 ptrdiff_t size
= last_overlay_modification_hooks_used
;
4495 Lisp_Object
*copy
= alloca (size
* sizeof *copy
);
4498 memcpy (copy
, XVECTOR (last_overlay_modification_hooks
)->contents
,
4501 gcpro1
.nvars
= size
;
4503 for (i
= 0; i
< size
;)
4505 Lisp_Object prop_i
, overlay_i
;
4507 overlay_i
= copy
[i
++];
4508 call_overlay_mod_hooks (prop_i
, overlay_i
, after
, arg1
, arg2
, arg3
);
4515 call_overlay_mod_hooks (Lisp_Object list
, Lisp_Object overlay
, bool after
,
4516 Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
)
4518 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4520 GCPRO4 (list
, arg1
, arg2
, arg3
);
4522 while (CONSP (list
))
4525 call4 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
);
4527 call5 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
, arg3
);
4533 /* Delete any zero-sized overlays at position POS, if the `evaporate'
4536 evaporate_overlays (ptrdiff_t pos
)
4538 Lisp_Object overlay
, hit_list
;
4539 struct Lisp_Overlay
*tail
;
4542 if (pos
<= current_buffer
->overlay_center
)
4543 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4546 XSETMISC (overlay
, tail
);
4547 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4550 if (endpos
== pos
&& OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
4551 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4552 hit_list
= Fcons (overlay
, hit_list
);
4555 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4558 XSETMISC (overlay
, tail
);
4559 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4562 if (startpos
== pos
&& OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
4563 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4564 hit_list
= Fcons (overlay
, hit_list
);
4566 for (; CONSP (hit_list
); hit_list
= XCDR (hit_list
))
4567 Fdelete_overlay (XCAR (hit_list
));
4570 /* Somebody has tried to store a value with an unacceptable type
4571 in the slot with offset OFFSET. */
4574 buffer_slot_type_mismatch (Lisp_Object newval
, int type
)
4576 Lisp_Object predicate
;
4580 case_Lisp_Int
: predicate
= Qintegerp
; break;
4581 case Lisp_String
: predicate
= Qstringp
; break;
4582 case Lisp_Symbol
: predicate
= Qsymbolp
; break;
4583 default: emacs_abort ();
4586 wrong_type_argument (predicate
, newval
);
4590 /***********************************************************************
4591 Allocation with mmap
4592 ***********************************************************************/
4594 #ifdef USE_MMAP_FOR_BUFFERS
4596 #include <sys/types.h>
4597 #include <sys/mman.h>
4600 #ifdef MAP_ANONYMOUS
4601 #define MAP_ANON MAP_ANONYMOUS
4608 #define MAP_FAILED ((void *) -1)
4620 /* Memory is allocated in regions which are mapped using mmap(2).
4621 The current implementation lets the system select mapped
4622 addresses; we're not using MAP_FIXED in general, except when
4623 trying to enlarge regions.
4625 Each mapped region starts with a mmap_region structure, the user
4626 area starts after that structure, aligned to MEM_ALIGN.
4628 +-----------------------+
4629 | struct mmap_info + |
4631 +-----------------------+
4635 +-----------------------+ */
4639 /* User-specified size. */
4640 size_t nbytes_specified
;
4642 /* Number of bytes mapped */
4643 size_t nbytes_mapped
;
4645 /* Pointer to the location holding the address of the memory
4646 allocated with the mmap'd block. The variable actually points
4647 after this structure. */
4650 /* Next and previous in list of all mmap'd regions. */
4651 struct mmap_region
*next
, *prev
;
4654 /* Doubly-linked list of mmap'd regions. */
4656 static struct mmap_region
*mmap_regions
;
4658 /* File descriptor for mmap. If we don't have anonymous mapping,
4659 /dev/zero will be opened on it. */
4663 /* Temporary storage for mmap_set_vars, see there. */
4665 static struct mmap_region
*mmap_regions_1
;
4666 static int mmap_fd_1
;
4668 /* Page size on this system. */
4670 static int mmap_page_size
;
4672 /* 1 means mmap has been initialized. */
4674 static bool mmap_initialized_p
;
4676 /* Value is X rounded up to the next multiple of N. */
4678 #define ROUND(X, N) (((X) + (N) - 1) / (N) * (N))
4680 /* Size of mmap_region structure plus padding. */
4682 #define MMAP_REGION_STRUCT_SIZE \
4683 ROUND (sizeof (struct mmap_region), MEM_ALIGN)
4685 /* Given a pointer P to the start of the user-visible part of a mapped
4686 region, return a pointer to the start of the region. */
4688 #define MMAP_REGION(P) \
4689 ((struct mmap_region *) ((char *) (P) - MMAP_REGION_STRUCT_SIZE))
4691 /* Given a pointer P to the start of a mapped region, return a pointer
4692 to the start of the user-visible part of the region. */
4694 #define MMAP_USER_AREA(P) \
4695 ((void *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
4697 #define MEM_ALIGN sizeof (double)
4699 /* Predicate returning true if part of the address range [START .. END]
4700 is currently mapped. Used to prevent overwriting an existing
4703 Default is to conservatively assume the address range is occupied by
4704 something else. This can be overridden by system configuration
4705 files if system-specific means to determine this exists. */
4707 #ifndef MMAP_ALLOCATED_P
4708 #define MMAP_ALLOCATED_P(start, end) 1
4711 /* Perform necessary initializations for the use of mmap. */
4717 /* The value of mmap_fd is initially 0 in temacs, and -1
4718 in a dumped Emacs. */
4721 /* No anonymous mmap -- we need the file descriptor. */
4722 mmap_fd
= open ("/dev/zero", O_RDONLY
);
4724 fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno
));
4726 #endif /* MAP_ANON == 0 */
4728 if (mmap_initialized_p
)
4730 mmap_initialized_p
= 1;
4736 mmap_page_size
= getpagesize ();
4739 /* Return a region overlapping address range START...END, or null if
4740 none. END is not including, i.e. the last byte in the range
4743 static struct mmap_region
*
4744 mmap_find (void *start
, void *end
)
4746 struct mmap_region
*r
;
4747 char *s
= (char *) start
, *e
= (char *) end
;
4749 for (r
= mmap_regions
; r
; r
= r
->next
)
4751 char *rstart
= (char *) r
;
4752 char *rend
= rstart
+ r
->nbytes_mapped
;
4754 if (/* First byte of range, i.e. START, in this region? */
4755 (s
>= rstart
&& s
< rend
)
4756 /* Last byte of range, i.e. END - 1, in this region? */
4757 || (e
> rstart
&& e
<= rend
)
4758 /* First byte of this region in the range? */
4759 || (rstart
>= s
&& rstart
< e
)
4760 /* Last byte of this region in the range? */
4761 || (rend
> s
&& rend
<= e
))
4769 /* Unmap a region. P is a pointer to the start of the user-araa of
4773 mmap_free_1 (struct mmap_region
*r
)
4776 r
->next
->prev
= r
->prev
;
4778 r
->prev
->next
= r
->next
;
4780 mmap_regions
= r
->next
;
4782 if (munmap (r
, r
->nbytes_mapped
) == -1)
4783 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4787 /* Enlarge region R by NPAGES pages. NPAGES < 0 means shrink R.
4788 Value is true if successful. */
4791 mmap_enlarge (struct mmap_region
*r
, int npages
)
4793 char *region_end
= (char *) r
+ r
->nbytes_mapped
;
4799 /* Unmap pages at the end of the region. */
4800 nbytes
= - npages
* mmap_page_size
;
4801 if (munmap (region_end
- nbytes
, nbytes
) == -1)
4802 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4805 r
->nbytes_mapped
-= nbytes
;
4809 else if (npages
> 0)
4811 nbytes
= npages
* mmap_page_size
;
4813 /* Try to map additional pages at the end of the region. We
4814 cannot do this if the address range is already occupied by
4815 something else because mmap deletes any previous mapping.
4816 I'm not sure this is worth doing, let's see. */
4817 if (!MMAP_ALLOCATED_P (region_end
, region_end
+ nbytes
))
4821 p
= mmap (region_end
, nbytes
, PROT_READ
| PROT_WRITE
,
4822 MAP_ANON
| MAP_PRIVATE
| MAP_FIXED
, mmap_fd
, 0);
4823 if (p
== MAP_FAILED
)
4824 ; /* fprintf (stderr, "mmap: %s\n", emacs_strerror (errno)); */
4825 else if (p
!= region_end
)
4827 /* Kernels are free to choose a different address. In
4828 that case, unmap what we've mapped above; we have
4830 if (munmap (p
, nbytes
) == -1)
4831 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4835 r
->nbytes_mapped
+= nbytes
;
4845 /* Set or reset variables holding references to mapped regions.
4846 If not RESTORE_P, set all variables to null. If RESTORE_P, set all
4847 variables to the start of the user-areas of mapped regions.
4849 This function is called from Fdump_emacs to ensure that the dumped
4850 Emacs doesn't contain references to memory that won't be mapped
4851 when Emacs starts. */
4854 mmap_set_vars (bool restore_p
)
4856 struct mmap_region
*r
;
4860 mmap_regions
= mmap_regions_1
;
4861 mmap_fd
= mmap_fd_1
;
4862 for (r
= mmap_regions
; r
; r
= r
->next
)
4863 *r
->var
= MMAP_USER_AREA (r
);
4867 for (r
= mmap_regions
; r
; r
= r
->next
)
4869 mmap_regions_1
= mmap_regions
;
4870 mmap_regions
= NULL
;
4871 mmap_fd_1
= mmap_fd
;
4877 /* Allocate a block of storage large enough to hold NBYTES bytes of
4878 data. A pointer to the data is returned in *VAR. VAR is thus the
4879 address of some variable which will use the data area.
4881 The allocation of 0 bytes is valid.
4883 If we can't allocate the necessary memory, set *VAR to null, and
4887 mmap_alloc (void **var
, size_t nbytes
)
4894 map
= ROUND (nbytes
+ MMAP_REGION_STRUCT_SIZE
, mmap_page_size
);
4895 p
= mmap (NULL
, map
, PROT_READ
| PROT_WRITE
, MAP_ANON
| MAP_PRIVATE
,
4898 if (p
== MAP_FAILED
)
4900 if (errno
!= ENOMEM
)
4901 fprintf (stderr
, "mmap: %s\n", emacs_strerror (errno
));
4906 struct mmap_region
*r
= (struct mmap_region
*) p
;
4908 r
->nbytes_specified
= nbytes
;
4909 r
->nbytes_mapped
= map
;
4912 r
->next
= mmap_regions
;
4917 p
= MMAP_USER_AREA (p
);
4924 /* Free a block of relocatable storage whose data is pointed to by
4925 PTR. Store 0 in *PTR to show there's no block allocated. */
4928 mmap_free (void **var
)
4934 mmap_free_1 (MMAP_REGION (*var
));
4940 /* Given a pointer at address VAR to data allocated with mmap_alloc,
4941 resize it to size NBYTES. Change *VAR to reflect the new block,
4942 and return this value. If more memory cannot be allocated, then
4943 leave *VAR unchanged, and return null. */
4946 mmap_realloc (void **var
, size_t nbytes
)
4953 result
= mmap_alloc (var
, nbytes
);
4954 else if (nbytes
== 0)
4957 result
= mmap_alloc (var
, nbytes
);
4961 struct mmap_region
*r
= MMAP_REGION (*var
);
4962 size_t room
= r
->nbytes_mapped
- MMAP_REGION_STRUCT_SIZE
;
4967 void *old_ptr
= *var
;
4969 /* Try to map additional pages at the end of the region.
4970 If that fails, allocate a new region, copy data
4971 from the old region, then free it. */
4972 if (mmap_enlarge (r
, (ROUND (nbytes
- room
, mmap_page_size
)
4975 r
->nbytes_specified
= nbytes
;
4976 *var
= result
= old_ptr
;
4978 else if (mmap_alloc (var
, nbytes
))
4980 memcpy (*var
, old_ptr
, r
->nbytes_specified
);
4981 mmap_free_1 (MMAP_REGION (old_ptr
));
4983 r
= MMAP_REGION (result
);
4984 r
->nbytes_specified
= nbytes
;
4992 else if (room
- nbytes
>= mmap_page_size
)
4994 /* Shrinking by at least a page. Let's give some
4995 memory back to the system.
4997 The extra parens are to make the division happens first,
4998 on positive values, so we know it will round towards
5000 mmap_enlarge (r
, - ((room
- nbytes
) / mmap_page_size
));
5002 r
->nbytes_specified
= nbytes
;
5006 /* Leave it alone. */
5008 r
->nbytes_specified
= nbytes
;
5016 #endif /* USE_MMAP_FOR_BUFFERS */
5020 /***********************************************************************
5021 Buffer-text Allocation
5022 ***********************************************************************/
5024 /* Allocate NBYTES bytes for buffer B's text buffer. */
5027 alloc_buffer_text (struct buffer
*b
, ptrdiff_t nbytes
)
5032 #if defined USE_MMAP_FOR_BUFFERS
5033 p
= mmap_alloc ((void **) &b
->text
->beg
, nbytes
);
5034 #elif defined REL_ALLOC
5035 p
= r_alloc ((void **) &b
->text
->beg
, nbytes
);
5037 p
= xmalloc (nbytes
);
5043 memory_full (nbytes
);
5046 b
->text
->beg
= (unsigned char *) p
;
5050 /* Enlarge buffer B's text buffer by DELTA bytes. DELTA < 0 means
5054 enlarge_buffer_text (struct buffer
*b
, ptrdiff_t delta
)
5057 ptrdiff_t nbytes
= (BUF_Z_BYTE (b
) - BUF_BEG_BYTE (b
) + BUF_GAP_SIZE (b
) + 1
5060 #if defined USE_MMAP_FOR_BUFFERS
5061 p
= mmap_realloc ((void **) &b
->text
->beg
, nbytes
);
5062 #elif defined REL_ALLOC
5063 p
= r_re_alloc ((void **) &b
->text
->beg
, nbytes
);
5065 p
= xrealloc (b
->text
->beg
, nbytes
);
5071 memory_full (nbytes
);
5074 BUF_BEG_ADDR (b
) = (unsigned char *) p
;
5079 /* Free buffer B's text buffer. */
5082 free_buffer_text (struct buffer
*b
)
5086 #if defined USE_MMAP_FOR_BUFFERS
5087 mmap_free ((void **) &b
->text
->beg
);
5088 #elif defined REL_ALLOC
5089 r_alloc_free ((void **) &b
->text
->beg
);
5091 xfree (b
->text
->beg
);
5094 BUF_BEG_ADDR (b
) = NULL
;
5100 /***********************************************************************
5102 ***********************************************************************/
5105 init_buffer_once (void)
5108 /* If you add, remove, or reorder Lisp_Objects in a struct buffer, make
5109 sure that this is still correct. Otherwise, mark_vectorlike may not
5110 trace all Lisp_Objects in buffer_defaults and buffer_local_symbols. */
5112 = (offsetof (struct buffer
, own_text
) - header_size
) / word_size
;
5114 memset (buffer_permanent_local_flags
, 0, sizeof buffer_permanent_local_flags
);
5116 /* Make sure all markable slots in buffer_defaults
5117 are initialized reasonably, so mark_buffer won't choke. */
5118 reset_buffer (&buffer_defaults
);
5119 eassert (EQ (BVAR (&buffer_defaults
, name
), make_number (0)));
5120 reset_buffer_local_variables (&buffer_defaults
, 1);
5121 eassert (EQ (BVAR (&buffer_local_symbols
, name
), make_number (0)));
5122 reset_buffer (&buffer_local_symbols
);
5123 reset_buffer_local_variables (&buffer_local_symbols
, 1);
5124 /* Prevent GC from getting confused. */
5125 buffer_defaults
.text
= &buffer_defaults
.own_text
;
5126 buffer_local_symbols
.text
= &buffer_local_symbols
.own_text
;
5127 /* No one will share the text with these buffers, but let's play it safe. */
5128 buffer_defaults
.indirections
= 0;
5129 buffer_local_symbols
.indirections
= 0;
5130 set_buffer_intervals (&buffer_defaults
, NULL
);
5131 set_buffer_intervals (&buffer_local_symbols
, NULL
);
5132 /* This is not strictly necessary, but let's make them initialized. */
5133 bset_name (&buffer_defaults
, build_pure_c_string (" *buffer-defaults*"));
5134 bset_name (&buffer_local_symbols
, build_pure_c_string (" *buffer-local-symbols*"));
5135 XSETPVECTYPESIZE (&buffer_defaults
, PVEC_BUFFER
, pvecsize
);
5136 XSETPVECTYPESIZE (&buffer_local_symbols
, PVEC_BUFFER
, pvecsize
);
5138 /* Set up the default values of various buffer slots. */
5139 /* Must do these before making the first buffer! */
5141 /* real setup is done in bindings.el */
5142 bset_mode_line_format (&buffer_defaults
, build_pure_c_string ("%-"));
5143 bset_header_line_format (&buffer_defaults
, Qnil
);
5144 bset_abbrev_mode (&buffer_defaults
, Qnil
);
5145 bset_overwrite_mode (&buffer_defaults
, Qnil
);
5146 bset_case_fold_search (&buffer_defaults
, Qt
);
5147 bset_auto_fill_function (&buffer_defaults
, Qnil
);
5148 bset_selective_display (&buffer_defaults
, Qnil
);
5149 bset_selective_display_ellipses (&buffer_defaults
, Qt
);
5150 bset_abbrev_table (&buffer_defaults
, Qnil
);
5151 bset_display_table (&buffer_defaults
, Qnil
);
5152 bset_undo_list (&buffer_defaults
, Qnil
);
5153 bset_mark_active (&buffer_defaults
, Qnil
);
5154 bset_file_format (&buffer_defaults
, Qnil
);
5155 bset_auto_save_file_format (&buffer_defaults
, Qt
);
5156 set_buffer_overlays_before (&buffer_defaults
, NULL
);
5157 set_buffer_overlays_after (&buffer_defaults
, NULL
);
5158 buffer_defaults
.overlay_center
= BEG
;
5160 XSETFASTINT (BVAR (&buffer_defaults
, tab_width
), 8);
5161 bset_truncate_lines (&buffer_defaults
, Qnil
);
5162 bset_word_wrap (&buffer_defaults
, Qnil
);
5163 bset_ctl_arrow (&buffer_defaults
, Qt
);
5164 bset_bidi_display_reordering (&buffer_defaults
, Qt
);
5165 bset_bidi_paragraph_direction (&buffer_defaults
, Qnil
);
5166 bset_cursor_type (&buffer_defaults
, Qt
);
5167 bset_extra_line_spacing (&buffer_defaults
, Qnil
);
5168 bset_cursor_in_non_selected_windows (&buffer_defaults
, Qt
);
5170 bset_enable_multibyte_characters (&buffer_defaults
, Qt
);
5171 bset_buffer_file_coding_system (&buffer_defaults
, Qnil
);
5172 XSETFASTINT (BVAR (&buffer_defaults
, fill_column
), 70);
5173 XSETFASTINT (BVAR (&buffer_defaults
, left_margin
), 0);
5174 bset_cache_long_line_scans (&buffer_defaults
, Qnil
);
5175 bset_file_truename (&buffer_defaults
, Qnil
);
5176 XSETFASTINT (BVAR (&buffer_defaults
, display_count
), 0);
5177 XSETFASTINT (BVAR (&buffer_defaults
, left_margin_cols
), 0);
5178 XSETFASTINT (BVAR (&buffer_defaults
, right_margin_cols
), 0);
5179 bset_left_fringe_width (&buffer_defaults
, Qnil
);
5180 bset_right_fringe_width (&buffer_defaults
, Qnil
);
5181 bset_fringes_outside_margins (&buffer_defaults
, Qnil
);
5182 bset_scroll_bar_width (&buffer_defaults
, Qnil
);
5183 bset_vertical_scroll_bar_type (&buffer_defaults
, Qt
);
5184 bset_indicate_empty_lines (&buffer_defaults
, Qnil
);
5185 bset_indicate_buffer_boundaries (&buffer_defaults
, Qnil
);
5186 bset_fringe_indicator_alist (&buffer_defaults
, Qnil
);
5187 bset_fringe_cursor_alist (&buffer_defaults
, Qnil
);
5188 bset_scroll_up_aggressively (&buffer_defaults
, Qnil
);
5189 bset_scroll_down_aggressively (&buffer_defaults
, Qnil
);
5190 bset_display_time (&buffer_defaults
, Qnil
);
5192 /* Assign the local-flags to the slots that have default values.
5193 The local flag is a bit that is used in the buffer
5194 to say that it has its own local value for the slot.
5195 The local flag bits are in the local_var_flags slot of the buffer. */
5197 /* Nothing can work if this isn't true */
5198 { verify (sizeof (EMACS_INT
) == word_size
); }
5200 /* 0 means not a lisp var, -1 means always local, else mask */
5201 memset (&buffer_local_flags
, 0, sizeof buffer_local_flags
);
5202 bset_filename (&buffer_local_flags
, make_number (-1));
5203 bset_directory (&buffer_local_flags
, make_number (-1));
5204 bset_backed_up (&buffer_local_flags
, make_number (-1));
5205 bset_save_length (&buffer_local_flags
, make_number (-1));
5206 bset_auto_save_file_name (&buffer_local_flags
, make_number (-1));
5207 bset_read_only (&buffer_local_flags
, make_number (-1));
5208 bset_major_mode (&buffer_local_flags
, make_number (-1));
5209 bset_mode_name (&buffer_local_flags
, make_number (-1));
5210 bset_undo_list (&buffer_local_flags
, make_number (-1));
5211 bset_mark_active (&buffer_local_flags
, make_number (-1));
5212 bset_point_before_scroll (&buffer_local_flags
, make_number (-1));
5213 bset_file_truename (&buffer_local_flags
, make_number (-1));
5214 bset_invisibility_spec (&buffer_local_flags
, make_number (-1));
5215 bset_file_format (&buffer_local_flags
, make_number (-1));
5216 bset_auto_save_file_format (&buffer_local_flags
, make_number (-1));
5217 bset_display_count (&buffer_local_flags
, make_number (-1));
5218 bset_display_time (&buffer_local_flags
, make_number (-1));
5219 bset_enable_multibyte_characters (&buffer_local_flags
, make_number (-1));
5222 XSETFASTINT (BVAR (&buffer_local_flags
, mode_line_format
), idx
); ++idx
;
5223 XSETFASTINT (BVAR (&buffer_local_flags
, abbrev_mode
), idx
); ++idx
;
5224 XSETFASTINT (BVAR (&buffer_local_flags
, overwrite_mode
), idx
); ++idx
;
5225 XSETFASTINT (BVAR (&buffer_local_flags
, case_fold_search
), idx
); ++idx
;
5226 XSETFASTINT (BVAR (&buffer_local_flags
, auto_fill_function
), idx
); ++idx
;
5227 XSETFASTINT (BVAR (&buffer_local_flags
, selective_display
), idx
); ++idx
;
5228 XSETFASTINT (BVAR (&buffer_local_flags
, selective_display_ellipses
), idx
); ++idx
;
5229 XSETFASTINT (BVAR (&buffer_local_flags
, tab_width
), idx
); ++idx
;
5230 XSETFASTINT (BVAR (&buffer_local_flags
, truncate_lines
), idx
); ++idx
;
5231 XSETFASTINT (BVAR (&buffer_local_flags
, word_wrap
), idx
); ++idx
;
5232 XSETFASTINT (BVAR (&buffer_local_flags
, ctl_arrow
), idx
); ++idx
;
5233 XSETFASTINT (BVAR (&buffer_local_flags
, fill_column
), idx
); ++idx
;
5234 XSETFASTINT (BVAR (&buffer_local_flags
, left_margin
), idx
); ++idx
;
5235 XSETFASTINT (BVAR (&buffer_local_flags
, abbrev_table
), idx
); ++idx
;
5236 XSETFASTINT (BVAR (&buffer_local_flags
, display_table
), idx
); ++idx
;
5237 XSETFASTINT (BVAR (&buffer_local_flags
, syntax_table
), idx
); ++idx
;
5238 XSETFASTINT (BVAR (&buffer_local_flags
, cache_long_line_scans
), idx
); ++idx
;
5239 XSETFASTINT (BVAR (&buffer_local_flags
, category_table
), idx
); ++idx
;
5240 XSETFASTINT (BVAR (&buffer_local_flags
, bidi_display_reordering
), idx
); ++idx
;
5241 XSETFASTINT (BVAR (&buffer_local_flags
, bidi_paragraph_direction
), idx
); ++idx
;
5242 XSETFASTINT (BVAR (&buffer_local_flags
, buffer_file_coding_system
), idx
);
5243 /* Make this one a permanent local. */
5244 buffer_permanent_local_flags
[idx
++] = 1;
5245 XSETFASTINT (BVAR (&buffer_local_flags
, left_margin_cols
), idx
); ++idx
;
5246 XSETFASTINT (BVAR (&buffer_local_flags
, right_margin_cols
), idx
); ++idx
;
5247 XSETFASTINT (BVAR (&buffer_local_flags
, left_fringe_width
), idx
); ++idx
;
5248 XSETFASTINT (BVAR (&buffer_local_flags
, right_fringe_width
), idx
); ++idx
;
5249 XSETFASTINT (BVAR (&buffer_local_flags
, fringes_outside_margins
), idx
); ++idx
;
5250 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_bar_width
), idx
); ++idx
;
5251 XSETFASTINT (BVAR (&buffer_local_flags
, vertical_scroll_bar_type
), idx
); ++idx
;
5252 XSETFASTINT (BVAR (&buffer_local_flags
, indicate_empty_lines
), idx
); ++idx
;
5253 XSETFASTINT (BVAR (&buffer_local_flags
, indicate_buffer_boundaries
), idx
); ++idx
;
5254 XSETFASTINT (BVAR (&buffer_local_flags
, fringe_indicator_alist
), idx
); ++idx
;
5255 XSETFASTINT (BVAR (&buffer_local_flags
, fringe_cursor_alist
), idx
); ++idx
;
5256 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_up_aggressively
), idx
); ++idx
;
5257 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_down_aggressively
), idx
); ++idx
;
5258 XSETFASTINT (BVAR (&buffer_local_flags
, header_line_format
), idx
); ++idx
;
5259 XSETFASTINT (BVAR (&buffer_local_flags
, cursor_type
), idx
); ++idx
;
5260 XSETFASTINT (BVAR (&buffer_local_flags
, extra_line_spacing
), idx
); ++idx
;
5261 XSETFASTINT (BVAR (&buffer_local_flags
, cursor_in_non_selected_windows
), idx
); ++idx
;
5263 /* Need more room? */
5264 if (idx
>= MAX_PER_BUFFER_VARS
)
5266 last_per_buffer_idx
= idx
;
5268 Vbuffer_alist
= Qnil
;
5272 QSFundamental
= build_pure_c_string ("Fundamental");
5274 Qfundamental_mode
= intern_c_string ("fundamental-mode");
5275 bset_major_mode (&buffer_defaults
, Qfundamental_mode
);
5277 Qmode_class
= intern_c_string ("mode-class");
5279 Qprotected_field
= intern_c_string ("protected-field");
5281 Qpermanent_local
= intern_c_string ("permanent-local");
5283 Qkill_buffer_hook
= intern_c_string ("kill-buffer-hook");
5284 Fput (Qkill_buffer_hook
, Qpermanent_local
, Qt
);
5286 /* super-magic invisible buffer */
5287 Vprin1_to_string_buffer
= Fget_buffer_create (build_pure_c_string (" prin1"));
5288 Vbuffer_alist
= Qnil
;
5290 Fset_buffer (Fget_buffer_create (build_pure_c_string ("*scratch*")));
5292 inhibit_modification_hooks
= 0;
5302 #ifdef USE_MMAP_FOR_BUFFERS
5304 /* When using the ralloc implementation based on mmap(2), buffer
5305 text pointers will have been set to null in the dumped Emacs.
5310 if (b
->text
->beg
== NULL
)
5311 enlarge_buffer_text (b
, 0);
5313 #endif /* USE_MMAP_FOR_BUFFERS */
5315 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
5316 if (NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
)))
5317 Fset_buffer_multibyte (Qnil
);
5319 pwd
= get_current_dir_name ();
5322 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5324 /* Maybe this should really use some standard subroutine
5325 whose definition is filename syntax dependent. */
5327 if (!(IS_DIRECTORY_SEP (pwd
[len
- 1])))
5329 /* Grow buffer to add directory separator and '\0'. */
5330 pwd
= realloc (pwd
, len
+ 2);
5332 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5333 pwd
[len
] = DIRECTORY_SEP
;
5334 pwd
[len
+ 1] = '\0';
5338 bset_directory (current_buffer
, make_unibyte_string (pwd
, len
));
5339 if (! NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
)))
5340 /* At this moment, we still don't know how to decode the
5341 directory name. So, we keep the bytes in multibyte form so
5342 that ENCODE_FILE correctly gets the original bytes. */
5344 (current_buffer
, string_to_multibyte (BVAR (current_buffer
, directory
)));
5346 /* Add /: to the front of the name
5347 if it would otherwise be treated as magic. */
5348 temp
= Ffind_file_name_handler (BVAR (current_buffer
, directory
), Qt
);
5350 /* If the default dir is just /, TEMP is non-nil
5351 because of the ange-ftp completion handler.
5352 However, it is not necessary to turn / into /:/.
5353 So avoid doing that. */
5354 && strcmp ("/", SSDATA (BVAR (current_buffer
, directory
))))
5357 concat2 (build_string ("/:"), BVAR (current_buffer
, directory
)));
5359 temp
= get_minibuffer (0);
5360 bset_directory (XBUFFER (temp
), BVAR (current_buffer
, directory
));
5365 /* Similar to defvar_lisp but define a variable whose value is the Lisp
5366 Object stored in the current buffer. address is the address of the slot
5367 in the buffer that is current now. */
5369 /* TYPE is nil for a general Lisp variable.
5370 An integer specifies a type; then only Lisp values
5371 with that type code are allowed (except that nil is allowed too).
5372 LNAME is the Lisp-level variable name.
5373 VNAME is the name of the buffer slot.
5374 DOC is a dummy where you write the doc string as a comment. */
5375 #define DEFVAR_PER_BUFFER(lname, vname, type, doc) \
5377 static struct Lisp_Buffer_Objfwd bo_fwd; \
5378 defvar_per_buffer (&bo_fwd, lname, vname, type); \
5382 defvar_per_buffer (struct Lisp_Buffer_Objfwd
*bo_fwd
, const char *namestring
,
5383 Lisp_Object
*address
, Lisp_Object type
)
5385 struct Lisp_Symbol
*sym
;
5388 sym
= XSYMBOL (intern (namestring
));
5389 offset
= (char *)address
- (char *)current_buffer
;
5391 bo_fwd
->type
= Lisp_Fwd_Buffer_Obj
;
5392 bo_fwd
->offset
= offset
;
5393 bo_fwd
->slottype
= type
;
5394 sym
->declared_special
= 1;
5395 sym
->redirect
= SYMBOL_FORWARDED
;
5397 /* I tried to do the job without a cast, but it seems impossible.
5398 union Lisp_Fwd *fwd; &(fwd->u_buffer_objfwd) = bo_fwd; */
5399 SET_SYMBOL_FWD (sym
, (union Lisp_Fwd
*)bo_fwd
);
5401 XSETSYMBOL (PER_BUFFER_SYMBOL (offset
), sym
);
5403 if (PER_BUFFER_IDX (offset
) == 0)
5404 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
5405 slot of buffer_local_flags */
5410 /* initialize the buffer routines */
5412 syms_of_buffer (void)
5414 staticpro (&last_overlay_modification_hooks
);
5415 last_overlay_modification_hooks
5416 = Fmake_vector (make_number (10), Qnil
);
5418 staticpro (&Qfundamental_mode
);
5419 staticpro (&Qmode_class
);
5420 staticpro (&QSFundamental
);
5421 staticpro (&Vbuffer_alist
);
5422 staticpro (&Qprotected_field
);
5423 staticpro (&Qpermanent_local
);
5424 staticpro (&Qkill_buffer_hook
);
5426 DEFSYM (Qpermanent_local_hook
, "permanent-local-hook");
5427 DEFSYM (Qoverlayp
, "overlayp");
5428 DEFSYM (Qevaporate
, "evaporate");
5429 DEFSYM (Qmodification_hooks
, "modification-hooks");
5430 DEFSYM (Qinsert_in_front_hooks
, "insert-in-front-hooks");
5431 DEFSYM (Qinsert_behind_hooks
, "insert-behind-hooks");
5432 DEFSYM (Qget_file_buffer
, "get-file-buffer");
5433 DEFSYM (Qpriority
, "priority");
5434 DEFSYM (Qbefore_string
, "before-string");
5435 DEFSYM (Qafter_string
, "after-string");
5436 DEFSYM (Qfirst_change_hook
, "first-change-hook");
5437 DEFSYM (Qbefore_change_functions
, "before-change-functions");
5438 DEFSYM (Qafter_change_functions
, "after-change-functions");
5439 DEFSYM (Qkill_buffer_query_functions
, "kill-buffer-query-functions");
5441 Fput (Qprotected_field
, Qerror_conditions
,
5442 listn (CONSTYPE_PURE
, 2, Qprotected_field
, Qerror
));
5443 Fput (Qprotected_field
, Qerror_message
,
5444 build_pure_c_string ("Attempt to modify a protected field"));
5446 DEFVAR_BUFFER_DEFAULTS ("default-mode-line-format",
5448 doc
: /* Default value of `mode-line-format' for buffers that don't override it.
5449 This is the same as (default-value 'mode-line-format). */);
5451 DEFVAR_BUFFER_DEFAULTS ("default-header-line-format",
5453 doc
: /* Default value of `header-line-format' for buffers that don't override it.
5454 This is the same as (default-value 'header-line-format). */);
5456 DEFVAR_BUFFER_DEFAULTS ("default-cursor-type", cursor_type
,
5457 doc
: /* Default value of `cursor-type' for buffers that don't override it.
5458 This is the same as (default-value 'cursor-type). */);
5460 DEFVAR_BUFFER_DEFAULTS ("default-line-spacing",
5462 doc
: /* Default value of `line-spacing' for buffers that don't override it.
5463 This is the same as (default-value 'line-spacing). */);
5465 DEFVAR_BUFFER_DEFAULTS ("default-cursor-in-non-selected-windows",
5466 cursor_in_non_selected_windows
,
5467 doc
: /* Default value of `cursor-in-non-selected-windows'.
5468 This is the same as (default-value 'cursor-in-non-selected-windows). */);
5470 DEFVAR_BUFFER_DEFAULTS ("default-abbrev-mode",
5472 doc
: /* Default value of `abbrev-mode' for buffers that do not override it.
5473 This is the same as (default-value 'abbrev-mode). */);
5475 DEFVAR_BUFFER_DEFAULTS ("default-ctl-arrow",
5477 doc
: /* Default value of `ctl-arrow' for buffers that do not override it.
5478 This is the same as (default-value 'ctl-arrow). */);
5480 DEFVAR_BUFFER_DEFAULTS ("default-enable-multibyte-characters",
5481 enable_multibyte_characters
,
5482 doc
: /* Default value of `enable-multibyte-characters' for buffers not overriding it.
5483 This is the same as (default-value 'enable-multibyte-characters). */);
5485 DEFVAR_BUFFER_DEFAULTS ("default-buffer-file-coding-system",
5486 buffer_file_coding_system
,
5487 doc
: /* Default value of `buffer-file-coding-system' for buffers not overriding it.
5488 This is the same as (default-value 'buffer-file-coding-system). */);
5490 DEFVAR_BUFFER_DEFAULTS ("default-truncate-lines",
5492 doc
: /* Default value of `truncate-lines' for buffers that do not override it.
5493 This is the same as (default-value 'truncate-lines). */);
5495 DEFVAR_BUFFER_DEFAULTS ("default-fill-column",
5497 doc
: /* Default value of `fill-column' for buffers that do not override it.
5498 This is the same as (default-value 'fill-column). */);
5500 DEFVAR_BUFFER_DEFAULTS ("default-left-margin",
5502 doc
: /* Default value of `left-margin' for buffers that do not override it.
5503 This is the same as (default-value 'left-margin). */);
5505 DEFVAR_BUFFER_DEFAULTS ("default-tab-width",
5507 doc
: /* Default value of `tab-width' for buffers that do not override it.
5508 This is the same as (default-value 'tab-width). */);
5510 DEFVAR_BUFFER_DEFAULTS ("default-case-fold-search",
5512 doc
: /* Default value of `case-fold-search' for buffers that don't override it.
5513 This is the same as (default-value 'case-fold-search). */);
5515 DEFVAR_BUFFER_DEFAULTS ("default-left-margin-width",
5517 doc
: /* Default value of `left-margin-width' for buffers that don't override it.
5518 This is the same as (default-value 'left-margin-width). */);
5520 DEFVAR_BUFFER_DEFAULTS ("default-right-margin-width",
5522 doc
: /* Default value of `right-margin-width' for buffers that don't override it.
5523 This is the same as (default-value 'right-margin-width). */);
5525 DEFVAR_BUFFER_DEFAULTS ("default-left-fringe-width",
5527 doc
: /* Default value of `left-fringe-width' for buffers that don't override it.
5528 This is the same as (default-value 'left-fringe-width). */);
5530 DEFVAR_BUFFER_DEFAULTS ("default-right-fringe-width",
5532 doc
: /* Default value of `right-fringe-width' for buffers that don't override it.
5533 This is the same as (default-value 'right-fringe-width). */);
5535 DEFVAR_BUFFER_DEFAULTS ("default-fringes-outside-margins",
5536 fringes_outside_margins
,
5537 doc
: /* Default value of `fringes-outside-margins' for buffers that don't override it.
5538 This is the same as (default-value 'fringes-outside-margins). */);
5540 DEFVAR_BUFFER_DEFAULTS ("default-scroll-bar-width",
5542 doc
: /* Default value of `scroll-bar-width' for buffers that don't override it.
5543 This is the same as (default-value 'scroll-bar-width). */);
5545 DEFVAR_BUFFER_DEFAULTS ("default-vertical-scroll-bar",
5546 vertical_scroll_bar_type
,
5547 doc
: /* Default value of `vertical-scroll-bar' for buffers that don't override it.
5548 This is the same as (default-value 'vertical-scroll-bar). */);
5550 DEFVAR_BUFFER_DEFAULTS ("default-indicate-empty-lines",
5551 indicate_empty_lines
,
5552 doc
: /* Default value of `indicate-empty-lines' for buffers that don't override it.
5553 This is the same as (default-value 'indicate-empty-lines). */);
5555 DEFVAR_BUFFER_DEFAULTS ("default-indicate-buffer-boundaries",
5556 indicate_buffer_boundaries
,
5557 doc
: /* Default value of `indicate-buffer-boundaries' for buffers that don't override it.
5558 This is the same as (default-value 'indicate-buffer-boundaries). */);
5560 DEFVAR_BUFFER_DEFAULTS ("default-fringe-indicator-alist",
5561 fringe_indicator_alist
,
5562 doc
: /* Default value of `fringe-indicator-alist' for buffers that don't override it.
5563 This is the same as (default-value 'fringe-indicator-alist'). */);
5565 DEFVAR_BUFFER_DEFAULTS ("default-fringe-cursor-alist",
5566 fringe_cursor_alist
,
5567 doc
: /* Default value of `fringe-cursor-alist' for buffers that don't override it.
5568 This is the same as (default-value 'fringe-cursor-alist'). */);
5570 DEFVAR_BUFFER_DEFAULTS ("default-scroll-up-aggressively",
5571 scroll_up_aggressively
,
5572 doc
: /* Default value of `scroll-up-aggressively'.
5573 This value applies in buffers that don't have their own local values.
5574 This is the same as (default-value 'scroll-up-aggressively). */);
5576 DEFVAR_BUFFER_DEFAULTS ("default-scroll-down-aggressively",
5577 scroll_down_aggressively
,
5578 doc
: /* Default value of `scroll-down-aggressively'.
5579 This value applies in buffers that don't have their own local values.
5580 This is the same as (default-value 'scroll-down-aggressively). */);
5582 DEFVAR_PER_BUFFER ("header-line-format",
5583 &BVAR (current_buffer
, header_line_format
),
5585 doc
: /* Analogous to `mode-line-format', but controls the header line.
5586 The header line appears, optionally, at the top of a window;
5587 the mode line appears at the bottom. */);
5589 DEFVAR_PER_BUFFER ("mode-line-format", &BVAR (current_buffer
, mode_line_format
),
5591 doc
: /* Template for displaying mode line for current buffer.
5593 The value may be nil, a string, a symbol or a list.
5595 A value of nil means don't display a mode line.
5597 For any symbol other than t or nil, the symbol's value is processed as
5598 a mode line construct. As a special exception, if that value is a
5599 string, the string is processed verbatim, without handling any
5600 %-constructs (see below). Also, unless the symbol has a non-nil
5601 `risky-local-variable' property, all properties in any strings, as
5602 well as all :eval and :propertize forms in the value, are ignored.
5604 A list whose car is a string or list is processed by processing each
5605 of the list elements recursively, as separate mode line constructs,
5606 and concatenating the results.
5608 A list of the form `(:eval FORM)' is processed by evaluating FORM and
5609 using the result as a mode line construct. Be careful--FORM should
5610 not load any files, because that can cause an infinite recursion.
5612 A list of the form `(:propertize ELT PROPS...)' is processed by
5613 processing ELT as the mode line construct, and adding the text
5614 properties PROPS to the result.
5616 A list whose car is a symbol is processed by examining the symbol's
5617 value, and, if that value is non-nil, processing the cadr of the list
5618 recursively; and if that value is nil, processing the caddr of the
5621 A list whose car is an integer is processed by processing the cadr of
5622 the list, and padding (if the number is positive) or truncating (if
5623 negative) to the width specified by that number.
5625 A string is printed verbatim in the mode line except for %-constructs:
5626 %b -- print buffer name. %f -- print visited file name.
5627 %F -- print frame name.
5628 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
5629 %& is like %*, but ignore read-only-ness.
5630 % means buffer is read-only and * means it is modified.
5631 For a modified read-only buffer, %* gives % and %+ gives *.
5632 %s -- print process status. %l -- print the current line number.
5633 %c -- print the current column number (this makes editing slower).
5634 To make the column number update correctly in all cases,
5635 `column-number-mode' must be non-nil.
5636 %i -- print the size of the buffer.
5637 %I -- like %i, but use k, M, G, etc., to abbreviate.
5638 %p -- print percent of buffer above top of window, or Top, Bot or All.
5639 %P -- print percent of buffer above bottom of window, perhaps plus Top,
5640 or print Bottom or All.
5641 %n -- print Narrow if appropriate.
5642 %t -- visited file is text or binary (if OS supports this distinction).
5643 %z -- print mnemonics of keyboard, terminal, and buffer coding systems.
5644 %Z -- like %z, but including the end-of-line format.
5645 %e -- print error message about full memory.
5646 %@ -- print @ or hyphen. @ means that default-directory is on a
5648 %[ -- print one [ for each recursive editing level. %] similar.
5649 %% -- print %. %- -- print infinitely many dashes.
5650 Decimal digits after the % specify field width to which to pad. */);
5652 DEFVAR_BUFFER_DEFAULTS ("default-major-mode", major_mode
,
5653 doc
: /* Value of `major-mode' for new buffers. */);
5655 DEFVAR_PER_BUFFER ("major-mode", &BVAR (current_buffer
, major_mode
),
5656 make_number (Lisp_Symbol
),
5657 doc
: /* Symbol for current buffer's major mode.
5658 The default value (normally `fundamental-mode') affects new buffers.
5659 A value of nil means to use the current buffer's major mode, provided
5660 it is not marked as "special".
5662 When a mode is used by default, `find-file' switches to it before it
5663 reads the contents into the buffer and before it finishes setting up
5664 the buffer. Thus, the mode and its hooks should not expect certain
5665 variables such as `buffer-read-only' and `buffer-file-coding-system'
5668 DEFVAR_PER_BUFFER ("mode-name", &BVAR (current_buffer
, mode_name
),
5670 doc
: /* Pretty name of current buffer's major mode.
5671 Usually a string, but can use any of the constructs for `mode-line-format',
5673 Format with `format-mode-line' to produce a string value. */);
5675 DEFVAR_PER_BUFFER ("local-abbrev-table", &BVAR (current_buffer
, abbrev_table
), Qnil
,
5676 doc
: /* Local (mode-specific) abbrev table of current buffer. */);
5678 DEFVAR_PER_BUFFER ("abbrev-mode", &BVAR (current_buffer
, abbrev_mode
), Qnil
,
5679 doc
: /* Non-nil if Abbrev mode is enabled.
5680 Use the command `abbrev-mode' to change this variable. */);
5682 DEFVAR_PER_BUFFER ("case-fold-search", &BVAR (current_buffer
, case_fold_search
),
5684 doc
: /* Non-nil if searches and matches should ignore case. */);
5686 DEFVAR_PER_BUFFER ("fill-column", &BVAR (current_buffer
, fill_column
),
5687 make_number (Lisp_Int0
),
5688 doc
: /* Column beyond which automatic line-wrapping should happen.
5689 Interactively, you can set the buffer local value using \\[set-fill-column]. */);
5691 DEFVAR_PER_BUFFER ("left-margin", &BVAR (current_buffer
, left_margin
),
5692 make_number (Lisp_Int0
),
5693 doc
: /* Column for the default `indent-line-function' to indent to.
5694 Linefeed indents to this column in Fundamental mode. */);
5696 DEFVAR_PER_BUFFER ("tab-width", &BVAR (current_buffer
, tab_width
),
5697 make_number (Lisp_Int0
),
5698 doc
: /* Distance between tab stops (for display of tab characters), in columns.
5699 This should be an integer greater than zero. */);
5701 DEFVAR_PER_BUFFER ("ctl-arrow", &BVAR (current_buffer
, ctl_arrow
), Qnil
,
5702 doc
: /* Non-nil means display control chars with uparrow.
5703 A value of nil means use backslash and octal digits.
5704 This variable does not apply to characters whose display is specified
5705 in the current display table (if there is one). */);
5707 DEFVAR_PER_BUFFER ("enable-multibyte-characters",
5708 &BVAR (current_buffer
, enable_multibyte_characters
),
5710 doc
: /* Non-nil means the buffer contents are regarded as multi-byte characters.
5711 Otherwise they are regarded as unibyte. This affects the display,
5712 file I/O and the behavior of various editing commands.
5714 This variable is buffer-local but you cannot set it directly;
5715 use the function `set-buffer-multibyte' to change a buffer's representation.
5716 See also Info node `(elisp)Text Representations'. */);
5717 XSYMBOL (intern_c_string ("enable-multibyte-characters"))->constant
= 1;
5719 DEFVAR_PER_BUFFER ("buffer-file-coding-system",
5720 &BVAR (current_buffer
, buffer_file_coding_system
), Qnil
,
5721 doc
: /* Coding system to be used for encoding the buffer contents on saving.
5722 This variable applies to saving the buffer, and also to `write-region'
5723 and other functions that use `write-region'.
5724 It does not apply to sending output to subprocesses, however.
5726 If this is nil, the buffer is saved without any code conversion
5727 unless some coding system is specified in `file-coding-system-alist'
5728 for the buffer file.
5730 If the text to be saved cannot be encoded as specified by this variable,
5731 an alternative encoding is selected by `select-safe-coding-system', which see.
5733 The variable `coding-system-for-write', if non-nil, overrides this variable.
5735 This variable is never applied to a way of decoding a file while reading it. */);
5737 DEFVAR_PER_BUFFER ("bidi-display-reordering",
5738 &BVAR (current_buffer
, bidi_display_reordering
), Qnil
,
5739 doc
: /* Non-nil means reorder bidirectional text for display in the visual order. */);
5741 DEFVAR_PER_BUFFER ("bidi-paragraph-direction",
5742 &BVAR (current_buffer
, bidi_paragraph_direction
), Qnil
,
5743 doc
: /* If non-nil, forces directionality of text paragraphs in the buffer.
5745 If this is nil (the default), the direction of each paragraph is
5746 determined by the first strong directional character of its text.
5747 The values of `right-to-left' and `left-to-right' override that.
5748 Any other value is treated as nil.
5750 This variable has no effect unless the buffer's value of
5751 \`bidi-display-reordering' is non-nil. */);
5753 DEFVAR_PER_BUFFER ("truncate-lines", &BVAR (current_buffer
, truncate_lines
), Qnil
,
5754 doc
: /* Non-nil means do not display continuation lines.
5755 Instead, give each line of text just one screen line.
5757 Note that this is overridden by the variable
5758 `truncate-partial-width-windows' if that variable is non-nil
5759 and this buffer is not full-frame width.
5761 Minibuffers set this variable to nil. */);
5763 DEFVAR_PER_BUFFER ("word-wrap", &BVAR (current_buffer
, word_wrap
), Qnil
,
5764 doc
: /* Non-nil means to use word-wrapping for continuation lines.
5765 When word-wrapping is on, continuation lines are wrapped at the space
5766 or tab character nearest to the right window edge.
5767 If nil, continuation lines are wrapped at the right screen edge.
5769 This variable has no effect if long lines are truncated (see
5770 `truncate-lines' and `truncate-partial-width-windows'). If you use
5771 word-wrapping, you might want to reduce the value of
5772 `truncate-partial-width-windows', since wrapping can make text readable
5773 in narrower windows.
5775 Instead of setting this variable directly, most users should use
5776 Visual Line mode . Visual Line mode, when enabled, sets `word-wrap'
5777 to t, and additionally redefines simple editing commands to act on
5778 visual lines rather than logical lines. See the documentation of
5779 `visual-line-mode'. */);
5781 DEFVAR_PER_BUFFER ("default-directory", &BVAR (current_buffer
, directory
),
5782 make_number (Lisp_String
),
5783 doc
: /* Name of default directory of current buffer. Should end with slash.
5784 To interactively change the default directory, use command `cd'. */);
5786 DEFVAR_PER_BUFFER ("auto-fill-function", &BVAR (current_buffer
, auto_fill_function
),
5788 doc
: /* Function called (if non-nil) to perform auto-fill.
5789 It is called after self-inserting any character specified in
5790 the `auto-fill-chars' table.
5791 NOTE: This variable is not a hook;
5792 its value may not be a list of functions. */);
5794 DEFVAR_PER_BUFFER ("buffer-file-name", &BVAR (current_buffer
, filename
),
5795 make_number (Lisp_String
),
5796 doc
: /* Name of file visited in current buffer, or nil if not visiting a file. */);
5798 DEFVAR_PER_BUFFER ("buffer-file-truename", &BVAR (current_buffer
, file_truename
),
5799 make_number (Lisp_String
),
5800 doc
: /* Abbreviated truename of file visited in current buffer, or nil if none.
5801 The truename of a file is calculated by `file-truename'
5802 and then abbreviated with `abbreviate-file-name'. */);
5804 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
5805 &BVAR (current_buffer
, auto_save_file_name
),
5806 make_number (Lisp_String
),
5807 doc
: /* Name of file for auto-saving current buffer.
5808 If it is nil, that means don't auto-save this buffer. */);
5810 DEFVAR_PER_BUFFER ("buffer-read-only", &BVAR (current_buffer
, read_only
), Qnil
,
5811 doc
: /* Non-nil if this buffer is read-only. */);
5813 DEFVAR_PER_BUFFER ("buffer-backed-up", &BVAR (current_buffer
, backed_up
), Qnil
,
5814 doc
: /* Non-nil if this buffer's file has been backed up.
5815 Backing up is done before the first time the file is saved. */);
5817 DEFVAR_PER_BUFFER ("buffer-saved-size", &BVAR (current_buffer
, save_length
),
5818 make_number (Lisp_Int0
),
5819 doc
: /* Length of current buffer when last read in, saved or auto-saved.
5821 -1 means auto-saving turned off until next real save.
5823 If you set this to -2, that means don't turn off auto-saving in this buffer
5824 if its text size shrinks. If you use `buffer-swap-text' on a buffer,
5825 you probably should set this to -2 in that buffer. */);
5827 DEFVAR_PER_BUFFER ("selective-display", &BVAR (current_buffer
, selective_display
),
5829 doc
: /* Non-nil enables selective display.
5830 An integer N as value means display only lines
5831 that start with less than N columns of space.
5832 A value of t means that the character ^M makes itself and
5833 all the rest of the line invisible; also, when saving the buffer
5834 in a file, save the ^M as a newline. */);
5836 DEFVAR_PER_BUFFER ("selective-display-ellipses",
5837 &BVAR (current_buffer
, selective_display_ellipses
),
5839 doc
: /* Non-nil means display ... on previous line when a line is invisible. */);
5841 DEFVAR_PER_BUFFER ("overwrite-mode", &BVAR (current_buffer
, overwrite_mode
), Qnil
,
5842 doc
: /* Non-nil if self-insertion should replace existing text.
5843 The value should be one of `overwrite-mode-textual',
5844 `overwrite-mode-binary', or nil.
5845 If it is `overwrite-mode-textual', self-insertion still
5846 inserts at the end of a line, and inserts when point is before a tab,
5847 until the tab is filled in.
5848 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too. */);
5850 DEFVAR_PER_BUFFER ("buffer-display-table", &BVAR (current_buffer
, display_table
),
5852 doc
: /* Display table that controls display of the contents of current buffer.
5854 If this variable is nil, the value of `standard-display-table' is used.
5855 Each window can have its own, overriding display table, see
5856 `set-window-display-table' and `window-display-table'.
5858 The display table is a char-table created with `make-display-table'.
5859 A char-table is an array indexed by character codes. Normal array
5860 primitives `aref' and `aset' can be used to access elements of a char-table.
5862 Each of the char-table elements control how to display the corresponding
5863 text character: the element at index C in the table says how to display
5864 the character whose code is C. Each element should be a vector of
5865 characters or nil. The value nil means display the character in the
5866 default fashion; otherwise, the characters from the vector are delivered
5867 to the screen instead of the original character.
5869 For example, (aset buffer-display-table ?X [?Y]) tells Emacs
5870 to display a capital Y instead of each X character.
5872 In addition, a char-table has six extra slots to control the display of:
5874 the end of a truncated screen line (extra-slot 0, a single character);
5875 the end of a continued line (extra-slot 1, a single character);
5876 the escape character used to display character codes in octal
5877 (extra-slot 2, a single character);
5878 the character used as an arrow for control characters (extra-slot 3,
5879 a single character);
5880 the decoration indicating the presence of invisible lines (extra-slot 4,
5881 a vector of characters);
5882 the character used to draw the border between side-by-side windows
5883 (extra-slot 5, a single character).
5885 See also the functions `display-table-slot' and `set-display-table-slot'. */);
5887 DEFVAR_PER_BUFFER ("left-margin-width", &BVAR (current_buffer
, left_margin_cols
),
5889 doc
: /* Width of left marginal area for display of a buffer.
5890 A value of nil means no marginal area. */);
5892 DEFVAR_PER_BUFFER ("right-margin-width", &BVAR (current_buffer
, right_margin_cols
),
5894 doc
: /* Width of right marginal area for display of a buffer.
5895 A value of nil means no marginal area. */);
5897 DEFVAR_PER_BUFFER ("left-fringe-width", &BVAR (current_buffer
, left_fringe_width
),
5899 doc
: /* Width of this buffer's left fringe (in pixels).
5900 A value of 0 means no left fringe is shown in this buffer's window.
5901 A value of nil means to use the left fringe width from the window's frame. */);
5903 DEFVAR_PER_BUFFER ("right-fringe-width", &BVAR (current_buffer
, right_fringe_width
),
5905 doc
: /* Width of this buffer's right fringe (in pixels).
5906 A value of 0 means no right fringe is shown in this buffer's window.
5907 A value of nil means to use the right fringe width from the window's frame. */);
5909 DEFVAR_PER_BUFFER ("fringes-outside-margins", &BVAR (current_buffer
, fringes_outside_margins
),
5911 doc
: /* Non-nil means to display fringes outside display margins.
5912 A value of nil means to display fringes between margins and buffer text. */);
5914 DEFVAR_PER_BUFFER ("scroll-bar-width", &BVAR (current_buffer
, scroll_bar_width
),
5916 doc
: /* Width of this buffer's scroll bars in pixels.
5917 A value of nil means to use the scroll bar width from the window's frame. */);
5919 DEFVAR_PER_BUFFER ("vertical-scroll-bar", &BVAR (current_buffer
, vertical_scroll_bar_type
),
5921 doc
: /* Position of this buffer's vertical scroll bar.
5922 The value takes effect whenever you tell a window to display this buffer;
5923 for instance, with `set-window-buffer' or when `display-buffer' displays it.
5925 A value of `left' or `right' means put the vertical scroll bar at that side
5926 of the window; a value of nil means don't show any vertical scroll bars.
5927 A value of t (the default) means do whatever the window's frame specifies. */);
5929 DEFVAR_PER_BUFFER ("indicate-empty-lines",
5930 &BVAR (current_buffer
, indicate_empty_lines
), Qnil
,
5931 doc
: /* Visually indicate empty lines after the buffer end.
5932 If non-nil, a bitmap is displayed in the left fringe of a window on
5933 window-systems. */);
5935 DEFVAR_PER_BUFFER ("indicate-buffer-boundaries",
5936 &BVAR (current_buffer
, indicate_buffer_boundaries
), Qnil
,
5937 doc
: /* Visually indicate buffer boundaries and scrolling.
5938 If non-nil, the first and last line of the buffer are marked in the fringe
5939 of a window on window-systems with angle bitmaps, or if the window can be
5940 scrolled, the top and bottom line of the window are marked with up and down
5943 If value is a symbol `left' or `right', both angle and arrow bitmaps
5944 are displayed in the left or right fringe, resp. Any other value
5945 that doesn't look like an alist means display the angle bitmaps in
5946 the left fringe but no arrows.
5948 You can exercise more precise control by using an alist as the
5949 value. Each alist element (INDICATOR . POSITION) specifies
5950 where to show one of the indicators. INDICATOR is one of `top',
5951 `bottom', `up', `down', or t, which specifies the default position,
5952 and POSITION is one of `left', `right', or nil, meaning do not show
5955 For example, ((top . left) (t . right)) places the top angle bitmap in
5956 left fringe, the bottom angle bitmap in right fringe, and both arrow
5957 bitmaps in right fringe. To show just the angle bitmaps in the left
5958 fringe, but no arrow bitmaps, use ((top . left) (bottom . left)). */);
5960 DEFVAR_PER_BUFFER ("fringe-indicator-alist",
5961 &BVAR (current_buffer
, fringe_indicator_alist
), Qnil
,
5962 doc
: /* Mapping from logical to physical fringe indicator bitmaps.
5963 The value is an alist where each element (INDICATOR . BITMAPS)
5964 specifies the fringe bitmaps used to display a specific logical
5967 INDICATOR specifies the logical indicator type which is one of the
5968 following symbols: `truncation' , `continuation', `overlay-arrow',
5969 `top', `bottom', `top-bottom', `up', `down', empty-line', or `unknown'.
5971 BITMAPS is a list of symbols (LEFT RIGHT [LEFT1 RIGHT1]) which specifies
5972 the actual bitmap shown in the left or right fringe for the logical
5973 indicator. LEFT and RIGHT are the bitmaps shown in the left and/or
5974 right fringe for the specific indicator. The LEFT1 or RIGHT1 bitmaps
5975 are used only for the `bottom' and `top-bottom' indicators when the
5976 last (only) line has no final newline. BITMAPS may also be a single
5977 symbol which is used in both left and right fringes. */);
5979 DEFVAR_PER_BUFFER ("fringe-cursor-alist",
5980 &BVAR (current_buffer
, fringe_cursor_alist
), Qnil
,
5981 doc
: /* Mapping from logical to physical fringe cursor bitmaps.
5982 The value is an alist where each element (CURSOR . BITMAP)
5983 specifies the fringe bitmaps used to display a specific logical
5984 cursor type in the fringe.
5986 CURSOR specifies the logical cursor type which is one of the following
5987 symbols: `box' , `hollow', `bar', `hbar', or `hollow-small'. The last
5988 one is used to show a hollow cursor on narrow lines display lines
5989 where the normal hollow cursor will not fit.
5991 BITMAP is the corresponding fringe bitmap shown for the logical
5994 DEFVAR_PER_BUFFER ("scroll-up-aggressively",
5995 &BVAR (current_buffer
, scroll_up_aggressively
), Qnil
,
5996 doc
: /* How far to scroll windows upward.
5997 If you move point off the bottom, the window scrolls automatically.
5998 This variable controls how far it scrolls. The value nil, the default,
5999 means scroll to center point. A fraction means scroll to put point
6000 that fraction of the window's height from the bottom of the window.
6001 When the value is 0.0, point goes at the bottom line, which in the
6002 simple case that you moved off with C-f means scrolling just one line.
6003 1.0 means point goes at the top, so that in that simple case, the
6004 window scrolls by a full window height. Meaningful values are
6005 between 0.0 and 1.0, inclusive. */);
6007 DEFVAR_PER_BUFFER ("scroll-down-aggressively",
6008 &BVAR (current_buffer
, scroll_down_aggressively
), Qnil
,
6009 doc
: /* How far to scroll windows downward.
6010 If you move point off the top, the window scrolls automatically.
6011 This variable controls how far it scrolls. The value nil, the default,
6012 means scroll to center point. A fraction means scroll to put point
6013 that fraction of the window's height from the top of the window.
6014 When the value is 0.0, point goes at the top line, which in the
6015 simple case that you moved off with C-b means scrolling just one line.
6016 1.0 means point goes at the bottom, so that in that simple case, the
6017 window scrolls by a full window height. Meaningful values are
6018 between 0.0 and 1.0, inclusive. */);
6020 /*DEFVAR_LISP ("debug-check-symbol", &Vcheck_symbol,
6024 DEFVAR_LISP ("before-change-functions", Vbefore_change_functions
,
6025 doc
: /* List of functions to call before each text change.
6026 Two arguments are passed to each function: the positions of
6027 the beginning and end of the range of old text to be changed.
6028 \(For an insertion, the beginning and end are at the same place.)
6029 No information is given about the length of the text after the change.
6031 Buffer changes made while executing the `before-change-functions'
6032 don't call any before-change or after-change functions.
6033 That's because `inhibit-modification-hooks' is temporarily set non-nil.
6035 If an unhandled error happens in running these functions,
6036 the variable's value remains nil. That prevents the error
6037 from happening repeatedly and making Emacs nonfunctional. */);
6038 Vbefore_change_functions
= Qnil
;
6040 DEFVAR_LISP ("after-change-functions", Vafter_change_functions
,
6041 doc
: /* List of functions to call after each text change.
6042 Three arguments are passed to each function: the positions of
6043 the beginning and end of the range of changed text,
6044 and the length in bytes of the pre-change text replaced by that range.
6045 \(For an insertion, the pre-change length is zero;
6046 for a deletion, that length is the number of bytes deleted,
6047 and the post-change beginning and end are at the same place.)
6049 Buffer changes made while executing the `after-change-functions'
6050 don't call any before-change or after-change functions.
6051 That's because `inhibit-modification-hooks' is temporarily set non-nil.
6053 If an unhandled error happens in running these functions,
6054 the variable's value remains nil. That prevents the error
6055 from happening repeatedly and making Emacs nonfunctional. */);
6056 Vafter_change_functions
= Qnil
;
6058 DEFVAR_LISP ("first-change-hook", Vfirst_change_hook
,
6059 doc
: /* A list of functions to call before changing a buffer which is unmodified.
6060 The functions are run using the `run-hooks' function. */);
6061 Vfirst_change_hook
= Qnil
;
6063 DEFVAR_PER_BUFFER ("buffer-undo-list", &BVAR (current_buffer
, undo_list
), Qnil
,
6064 doc
: /* List of undo entries in current buffer.
6065 Recent changes come first; older changes follow newer.
6067 An entry (BEG . END) represents an insertion which begins at
6068 position BEG and ends at position END.
6070 An entry (TEXT . POSITION) represents the deletion of the string TEXT
6071 from (abs POSITION). If POSITION is positive, point was at the front
6072 of the text being deleted; if negative, point was at the end.
6074 An entry (t HIGH LOW USEC PSEC) indicates that the buffer was previously
6075 unmodified; (HIGH LOW USEC PSEC) is in the same style as (current-time)
6076 and is the visited file's modification time, as of that time. If the
6077 modification time of the most recent save is different, this entry is
6080 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
6081 was modified between BEG and END. PROPERTY is the property name,
6082 and VALUE is the old value.
6084 An entry (apply FUN-NAME . ARGS) means undo the change with
6085 \(apply FUN-NAME ARGS).
6087 An entry (apply DELTA BEG END FUN-NAME . ARGS) supports selective undo
6088 in the active region. BEG and END is the range affected by this entry
6089 and DELTA is the number of bytes added or deleted in that range by
6092 An entry (MARKER . DISTANCE) indicates that the marker MARKER
6093 was adjusted in position by the offset DISTANCE (an integer).
6095 An entry of the form POSITION indicates that point was at the buffer
6096 location given by the integer. Undoing an entry of this form places
6099 Entries with value `nil' mark undo boundaries. The undo command treats
6100 the changes between two undo boundaries as a single step to be undone.
6102 If the value of the variable is t, undo information is not recorded. */);
6104 DEFVAR_PER_BUFFER ("mark-active", &BVAR (current_buffer
, mark_active
), Qnil
,
6105 doc
: /* Non-nil means the mark and region are currently active in this buffer. */);
6107 DEFVAR_PER_BUFFER ("cache-long-line-scans", &BVAR (current_buffer
, cache_long_line_scans
), Qnil
,
6108 doc
: /* Non-nil means that Emacs should use caches to handle long lines more quickly.
6110 Normally, the line-motion functions work by scanning the buffer for
6111 newlines. Columnar operations (like `move-to-column' and
6112 `compute-motion') also work by scanning the buffer, summing character
6113 widths as they go. This works well for ordinary text, but if the
6114 buffer's lines are very long (say, more than 500 characters), these
6115 motion functions will take longer to execute. Emacs may also take
6116 longer to update the display.
6118 If `cache-long-line-scans' is non-nil, these motion functions cache the
6119 results of their scans, and consult the cache to avoid rescanning
6120 regions of the buffer until the text is modified. The caches are most
6121 beneficial when they prevent the most searching---that is, when the
6122 buffer contains long lines and large regions of characters with the
6123 same, fixed screen width.
6125 When `cache-long-line-scans' is non-nil, processing short lines will
6126 become slightly slower (because of the overhead of consulting the
6127 cache), and the caches will use memory roughly proportional to the
6128 number of newlines and characters whose screen width varies.
6130 The caches require no explicit maintenance; their accuracy is
6131 maintained internally by the Emacs primitives. Enabling or disabling
6132 the cache should not affect the behavior of any of the motion
6133 functions; it should only affect their performance. */);
6135 DEFVAR_PER_BUFFER ("point-before-scroll", &BVAR (current_buffer
, point_before_scroll
), Qnil
,
6136 doc
: /* Value of point before the last series of scroll operations, or nil. */);
6138 DEFVAR_PER_BUFFER ("buffer-file-format", &BVAR (current_buffer
, file_format
), Qnil
,
6139 doc
: /* List of formats to use when saving this buffer.
6140 Formats are defined by `format-alist'. This variable is
6141 set when a file is visited. */);
6143 DEFVAR_PER_BUFFER ("buffer-auto-save-file-format",
6144 &BVAR (current_buffer
, auto_save_file_format
), Qnil
,
6145 doc
: /* Format in which to write auto-save files.
6146 Should be a list of symbols naming formats that are defined in `format-alist'.
6147 If it is t, which is the default, auto-save files are written in the
6148 same format as a regular save would use. */);
6150 DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
6151 &BVAR (current_buffer
, invisibility_spec
), Qnil
,
6152 doc
: /* Invisibility spec of this buffer.
6153 The default is t, which means that text is invisible
6154 if it has a non-nil `invisible' property.
6155 If the value is a list, a text character is invisible if its `invisible'
6156 property is an element in that list (or is a list with members in common).
6157 If an element is a cons cell of the form (PROP . ELLIPSIS),
6158 then characters with property value PROP are invisible,
6159 and they have an ellipsis as well if ELLIPSIS is non-nil. */);
6161 DEFVAR_PER_BUFFER ("buffer-display-count",
6162 &BVAR (current_buffer
, display_count
), Qnil
,
6163 doc
: /* A number incremented each time this buffer is displayed in a window.
6164 The function `set-window-buffer' increments it. */);
6166 DEFVAR_PER_BUFFER ("buffer-display-time",
6167 &BVAR (current_buffer
, display_time
), Qnil
,
6168 doc
: /* Time stamp updated each time this buffer is displayed in a window.
6169 The function `set-window-buffer' updates this variable
6170 to the value obtained by calling `current-time'.
6171 If the buffer has never been shown in a window, the value is nil. */);
6173 DEFVAR_LISP ("transient-mark-mode", Vtransient_mark_mode
,
6174 doc
: /* Non-nil if Transient Mark mode is enabled.
6175 See the command `transient-mark-mode' for a description of this minor mode.
6177 Non-nil also enables highlighting of the region whenever the mark is active.
6178 The variable `highlight-nonselected-windows' controls whether to highlight
6179 all windows or just the selected window.
6181 Lisp programs may give this variable certain special values:
6183 - A value of `lambda' enables Transient Mark mode temporarily.
6184 It is disabled again after any subsequent action that would
6185 normally deactivate the mark (e.g. buffer modification).
6187 - A value of (only . OLDVAL) enables Transient Mark mode
6188 temporarily. After any subsequent point motion command that is
6189 not shift-translated, or any other action that would normally
6190 deactivate the mark (e.g. buffer modification), the value of
6191 `transient-mark-mode' is set to OLDVAL. */);
6192 Vtransient_mark_mode
= Qnil
;
6194 DEFVAR_LISP ("inhibit-read-only", Vinhibit_read_only
,
6195 doc
: /* Non-nil means disregard read-only status of buffers or characters.
6196 If the value is t, disregard `buffer-read-only' and all `read-only'
6197 text properties. If the value is a list, disregard `buffer-read-only'
6198 and disregard a `read-only' text property if the property value
6199 is a member of the list. */);
6200 Vinhibit_read_only
= Qnil
;
6202 DEFVAR_PER_BUFFER ("cursor-type", &BVAR (current_buffer
, cursor_type
), Qnil
,
6203 doc
: /* Cursor to use when this buffer is in the selected window.
6204 Values are interpreted as follows:
6206 t use the cursor specified for the frame
6207 nil don't display a cursor
6208 box display a filled box cursor
6209 hollow display a hollow box cursor
6210 bar display a vertical bar cursor with default width
6211 (bar . WIDTH) display a vertical bar cursor with width WIDTH
6212 hbar display a horizontal bar cursor with default height
6213 (hbar . HEIGHT) display a horizontal bar cursor with height HEIGHT
6214 ANYTHING ELSE display a hollow box cursor
6216 When the buffer is displayed in a non-selected window, the
6217 cursor's appearance is instead controlled by the variable
6218 `cursor-in-non-selected-windows'. */);
6220 DEFVAR_PER_BUFFER ("line-spacing",
6221 &BVAR (current_buffer
, extra_line_spacing
), Qnil
,
6222 doc
: /* Additional space to put between lines when displaying a buffer.
6223 The space is measured in pixels, and put below lines on graphic displays,
6224 see `display-graphic-p'.
6225 If value is a floating point number, it specifies the spacing relative
6226 to the default frame line height. A value of nil means add no extra space. */);
6228 DEFVAR_PER_BUFFER ("cursor-in-non-selected-windows",
6229 &BVAR (current_buffer
, cursor_in_non_selected_windows
), Qnil
,
6230 doc
: /* Non-nil means show a cursor in non-selected windows.
6231 If nil, only shows a cursor in the selected window.
6232 If t, displays a cursor related to the usual cursor type
6233 \(a solid box becomes hollow, a bar becomes a narrower bar).
6234 You can also specify the cursor type as in the `cursor-type' variable.
6235 Use Custom to set this variable and update the display." */);
6237 DEFVAR_LISP ("kill-buffer-query-functions", Vkill_buffer_query_functions
,
6238 doc
: /* List of functions called with no args to query before killing a buffer.
6239 The buffer being killed will be current while the functions are running.
6241 If any of them returns nil, the buffer is not killed. Functions run by
6242 this hook are supposed to not change the current buffer. */);
6243 Vkill_buffer_query_functions
= Qnil
;
6245 DEFVAR_LISP ("change-major-mode-hook", Vchange_major_mode_hook
,
6246 doc
: /* Normal hook run before changing the major mode of a buffer.
6247 The function `kill-all-local-variables' runs this before doing anything else. */);
6248 Vchange_major_mode_hook
= Qnil
;
6249 DEFSYM (Qchange_major_mode_hook
, "change-major-mode-hook");
6251 DEFVAR_LISP ("buffer-list-update-hook", Vbuffer_list_update_hook
,
6252 doc
: /* Hook run when the buffer list changes.
6253 Functions running this hook are `get-buffer-create',
6254 `make-indirect-buffer', `rename-buffer', `kill-buffer',
6255 and `bury-buffer-internal'. */);
6256 Vbuffer_list_update_hook
= Qnil
;
6257 DEFSYM (Qbuffer_list_update_hook
, "buffer-list-update-hook");
6259 defsubr (&Sbuffer_live_p
);
6260 defsubr (&Sbuffer_list
);
6261 defsubr (&Sget_buffer
);
6262 defsubr (&Sget_file_buffer
);
6263 defsubr (&Sget_buffer_create
);
6264 defsubr (&Smake_indirect_buffer
);
6265 defsubr (&Sgenerate_new_buffer_name
);
6266 defsubr (&Sbuffer_name
);
6267 defsubr (&Sbuffer_file_name
);
6268 defsubr (&Sbuffer_base_buffer
);
6269 defsubr (&Sbuffer_local_value
);
6270 defsubr (&Sbuffer_local_variables
);
6271 defsubr (&Sbuffer_modified_p
);
6272 defsubr (&Sset_buffer_modified_p
);
6273 defsubr (&Sbuffer_modified_tick
);
6274 defsubr (&Sbuffer_chars_modified_tick
);
6275 defsubr (&Srename_buffer
);
6276 defsubr (&Sother_buffer
);
6277 defsubr (&Sbuffer_enable_undo
);
6278 defsubr (&Skill_buffer
);
6279 defsubr (&Sbury_buffer_internal
);
6280 defsubr (&Sset_buffer_major_mode
);
6281 defsubr (&Scurrent_buffer
);
6282 defsubr (&Sset_buffer
);
6283 defsubr (&Sbarf_if_buffer_read_only
);
6284 defsubr (&Serase_buffer
);
6285 defsubr (&Sbuffer_swap_text
);
6286 defsubr (&Sset_buffer_multibyte
);
6287 defsubr (&Skill_all_local_variables
);
6289 defsubr (&Soverlayp
);
6290 defsubr (&Smake_overlay
);
6291 defsubr (&Sdelete_overlay
);
6292 defsubr (&Sdelete_all_overlays
);
6293 defsubr (&Smove_overlay
);
6294 defsubr (&Soverlay_start
);
6295 defsubr (&Soverlay_end
);
6296 defsubr (&Soverlay_buffer
);
6297 defsubr (&Soverlay_properties
);
6298 defsubr (&Soverlays_at
);
6299 defsubr (&Soverlays_in
);
6300 defsubr (&Snext_overlay_change
);
6301 defsubr (&Sprevious_overlay_change
);
6302 defsubr (&Soverlay_recenter
);
6303 defsubr (&Soverlay_lists
);
6304 defsubr (&Soverlay_get
);
6305 defsubr (&Soverlay_put
);
6306 defsubr (&Srestore_buffer_modified_p
);
6310 keys_of_buffer (void)
6312 initial_define_key (control_x_map
, 'b', "switch-to-buffer");
6313 initial_define_key (control_x_map
, 'k', "kill-buffer");
6315 /* This must not be in syms_of_buffer, because Qdisabled is not
6316 initialized when that function gets called. */
6317 Fput (intern_c_string ("erase-buffer"), Qdisabled
, Qt
);