1 /* Buffer manipulation primitives for GNU Emacs.
3 Copyright (C) 1985-1989, 1993-1995, 1997-2015 Free Software Foundation,
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
23 #include <sys/types.h>
25 #include <sys/param.h>
33 #include "intervals.h"
36 #include "character.h"
38 #include "region-cache.h"
40 #include "blockinput.h"
47 #endif /* HAVE_XWIDGETS */
49 #include "w32heap.h" /* for mmap_* */
52 struct buffer
*current_buffer
; /* The current buffer. */
54 /* First buffer in chain of all buffers (in reverse order of creation).
55 Threaded through ->header.next.buffer. */
57 struct buffer
*all_buffers
;
59 /* This structure holds the default values of the buffer-local variables
60 defined with DEFVAR_PER_BUFFER, that have special slots in each buffer.
61 The default value occupies the same slot in this structure
62 as an individual buffer's value occupies in that buffer.
63 Setting the default value also goes through the alist of buffers
64 and stores into each buffer that does not say it has a local value. */
66 struct buffer
alignas (GCALIGNMENT
) buffer_defaults
;
68 /* This structure marks which slots in a buffer have corresponding
69 default values in buffer_defaults.
70 Each such slot has a nonzero value in this structure.
71 The value has only one nonzero bit.
73 When a buffer has its own local value for a slot,
74 the entry for that slot (found in the same slot in this structure)
75 is turned on in the buffer's local_flags array.
77 If a slot in this structure is -1, then even though there may
78 be a DEFVAR_PER_BUFFER for the slot, there is no default value for it;
79 and the corresponding slot in buffer_defaults is not used.
81 If a slot in this structure corresponding to a DEFVAR_PER_BUFFER is
82 zero, that is a bug. */
84 struct buffer buffer_local_flags
;
86 /* This structure holds the names of symbols whose values may be
87 buffer-local. It is indexed and accessed in the same way as the above. */
89 struct buffer
alignas (GCALIGNMENT
) buffer_local_symbols
;
91 /* Return the symbol of the per-buffer variable at offset OFFSET in
92 the buffer structure. */
94 #define PER_BUFFER_SYMBOL(OFFSET) \
95 (*(Lisp_Object *)((OFFSET) + (char *) &buffer_local_symbols))
97 /* Maximum length of an overlay vector. */
98 #define OVERLAY_COUNT_MAX \
99 ((ptrdiff_t) min (MOST_POSITIVE_FIXNUM, \
100 min (PTRDIFF_MAX, SIZE_MAX) / word_size))
102 /* Flags indicating which built-in buffer-local variables
103 are permanent locals. */
104 static char buffer_permanent_local_flags
[MAX_PER_BUFFER_VARS
];
106 /* Number of per-buffer variables used. */
108 int last_per_buffer_idx
;
110 static void call_overlay_mod_hooks (Lisp_Object list
, Lisp_Object overlay
,
111 bool after
, Lisp_Object arg1
,
112 Lisp_Object arg2
, Lisp_Object arg3
);
113 static void swap_out_buffer_local_variables (struct buffer
*b
);
114 static void reset_buffer_local_variables (struct buffer
*, bool);
116 /* Alist of all buffer names vs the buffers. This used to be
117 a Lisp-visible variable, but is no longer, to prevent lossage
118 due to user rplac'ing this alist or its elements. */
119 Lisp_Object Vbuffer_alist
;
121 static Lisp_Object QSFundamental
; /* A string "Fundamental". */
123 static void alloc_buffer_text (struct buffer
*, ptrdiff_t);
124 static void free_buffer_text (struct buffer
*b
);
125 static struct Lisp_Overlay
* copy_overlays (struct buffer
*, struct Lisp_Overlay
*);
126 static void modify_overlay (struct buffer
*, ptrdiff_t, ptrdiff_t);
127 static Lisp_Object
buffer_lisp_local_variables (struct buffer
*, bool);
130 CHECK_OVERLAY (Lisp_Object x
)
132 CHECK_TYPE (OVERLAYP (x
), Qoverlayp
, x
);
135 /* These setters are used only in this file, so they can be private.
136 The public setters are inline functions defined in buffer.h. */
138 bset_abbrev_mode (struct buffer
*b
, Lisp_Object val
)
140 b
->INTERNAL_FIELD (abbrev_mode
) = val
;
143 bset_abbrev_table (struct buffer
*b
, Lisp_Object val
)
145 b
->INTERNAL_FIELD (abbrev_table
) = val
;
148 bset_auto_fill_function (struct buffer
*b
, Lisp_Object val
)
150 b
->INTERNAL_FIELD (auto_fill_function
) = val
;
153 bset_auto_save_file_format (struct buffer
*b
, Lisp_Object val
)
155 b
->INTERNAL_FIELD (auto_save_file_format
) = val
;
158 bset_auto_save_file_name (struct buffer
*b
, Lisp_Object val
)
160 b
->INTERNAL_FIELD (auto_save_file_name
) = val
;
163 bset_backed_up (struct buffer
*b
, Lisp_Object val
)
165 b
->INTERNAL_FIELD (backed_up
) = val
;
168 bset_begv_marker (struct buffer
*b
, Lisp_Object val
)
170 b
->INTERNAL_FIELD (begv_marker
) = val
;
173 bset_bidi_display_reordering (struct buffer
*b
, Lisp_Object val
)
175 b
->INTERNAL_FIELD (bidi_display_reordering
) = val
;
178 bset_buffer_file_coding_system (struct buffer
*b
, Lisp_Object val
)
180 b
->INTERNAL_FIELD (buffer_file_coding_system
) = val
;
183 bset_case_fold_search (struct buffer
*b
, Lisp_Object val
)
185 b
->INTERNAL_FIELD (case_fold_search
) = val
;
188 bset_ctl_arrow (struct buffer
*b
, Lisp_Object val
)
190 b
->INTERNAL_FIELD (ctl_arrow
) = val
;
193 bset_cursor_in_non_selected_windows (struct buffer
*b
, Lisp_Object val
)
195 b
->INTERNAL_FIELD (cursor_in_non_selected_windows
) = val
;
198 bset_cursor_type (struct buffer
*b
, Lisp_Object val
)
200 b
->INTERNAL_FIELD (cursor_type
) = val
;
203 bset_display_table (struct buffer
*b
, Lisp_Object val
)
205 b
->INTERNAL_FIELD (display_table
) = val
;
208 bset_extra_line_spacing (struct buffer
*b
, Lisp_Object val
)
210 b
->INTERNAL_FIELD (extra_line_spacing
) = val
;
213 bset_file_format (struct buffer
*b
, Lisp_Object val
)
215 b
->INTERNAL_FIELD (file_format
) = val
;
218 bset_file_truename (struct buffer
*b
, Lisp_Object val
)
220 b
->INTERNAL_FIELD (file_truename
) = val
;
223 bset_fringe_cursor_alist (struct buffer
*b
, Lisp_Object val
)
225 b
->INTERNAL_FIELD (fringe_cursor_alist
) = val
;
228 bset_fringe_indicator_alist (struct buffer
*b
, Lisp_Object val
)
230 b
->INTERNAL_FIELD (fringe_indicator_alist
) = val
;
233 bset_fringes_outside_margins (struct buffer
*b
, Lisp_Object val
)
235 b
->INTERNAL_FIELD (fringes_outside_margins
) = val
;
238 bset_header_line_format (struct buffer
*b
, Lisp_Object val
)
240 b
->INTERNAL_FIELD (header_line_format
) = val
;
243 bset_indicate_buffer_boundaries (struct buffer
*b
, Lisp_Object val
)
245 b
->INTERNAL_FIELD (indicate_buffer_boundaries
) = val
;
248 bset_indicate_empty_lines (struct buffer
*b
, Lisp_Object val
)
250 b
->INTERNAL_FIELD (indicate_empty_lines
) = val
;
253 bset_invisibility_spec (struct buffer
*b
, Lisp_Object val
)
255 b
->INTERNAL_FIELD (invisibility_spec
) = val
;
258 bset_left_fringe_width (struct buffer
*b
, Lisp_Object val
)
260 b
->INTERNAL_FIELD (left_fringe_width
) = val
;
263 bset_major_mode (struct buffer
*b
, Lisp_Object val
)
265 b
->INTERNAL_FIELD (major_mode
) = val
;
268 bset_mark (struct buffer
*b
, Lisp_Object val
)
270 b
->INTERNAL_FIELD (mark
) = val
;
273 bset_minor_modes (struct buffer
*b
, Lisp_Object val
)
275 b
->INTERNAL_FIELD (minor_modes
) = val
;
278 bset_mode_line_format (struct buffer
*b
, Lisp_Object val
)
280 b
->INTERNAL_FIELD (mode_line_format
) = val
;
283 bset_mode_name (struct buffer
*b
, Lisp_Object val
)
285 b
->INTERNAL_FIELD (mode_name
) = val
;
288 bset_name (struct buffer
*b
, Lisp_Object val
)
290 b
->INTERNAL_FIELD (name
) = val
;
293 bset_overwrite_mode (struct buffer
*b
, Lisp_Object val
)
295 b
->INTERNAL_FIELD (overwrite_mode
) = val
;
298 bset_pt_marker (struct buffer
*b
, Lisp_Object val
)
300 b
->INTERNAL_FIELD (pt_marker
) = val
;
303 bset_right_fringe_width (struct buffer
*b
, Lisp_Object val
)
305 b
->INTERNAL_FIELD (right_fringe_width
) = val
;
308 bset_save_length (struct buffer
*b
, Lisp_Object val
)
310 b
->INTERNAL_FIELD (save_length
) = val
;
313 bset_scroll_bar_width (struct buffer
*b
, Lisp_Object val
)
315 b
->INTERNAL_FIELD (scroll_bar_width
) = val
;
318 bset_scroll_bar_height (struct buffer
*b
, Lisp_Object val
)
320 b
->INTERNAL_FIELD (scroll_bar_height
) = val
;
323 bset_scroll_down_aggressively (struct buffer
*b
, Lisp_Object val
)
325 b
->INTERNAL_FIELD (scroll_down_aggressively
) = val
;
328 bset_scroll_up_aggressively (struct buffer
*b
, Lisp_Object val
)
330 b
->INTERNAL_FIELD (scroll_up_aggressively
) = val
;
333 bset_selective_display (struct buffer
*b
, Lisp_Object val
)
335 b
->INTERNAL_FIELD (selective_display
) = val
;
338 bset_selective_display_ellipses (struct buffer
*b
, Lisp_Object val
)
340 b
->INTERNAL_FIELD (selective_display_ellipses
) = val
;
343 bset_vertical_scroll_bar_type (struct buffer
*b
, Lisp_Object val
)
345 b
->INTERNAL_FIELD (vertical_scroll_bar_type
) = val
;
348 bset_horizontal_scroll_bar_type (struct buffer
*b
, Lisp_Object val
)
350 b
->INTERNAL_FIELD (horizontal_scroll_bar_type
) = val
;
353 bset_word_wrap (struct buffer
*b
, Lisp_Object val
)
355 b
->INTERNAL_FIELD (word_wrap
) = val
;
358 bset_zv_marker (struct buffer
*b
, Lisp_Object val
)
360 b
->INTERNAL_FIELD (zv_marker
) = val
;
364 nsberror (Lisp_Object spec
)
367 error ("No buffer named %s", SDATA (spec
));
368 error ("Invalid buffer argument");
371 DEFUN ("buffer-live-p", Fbuffer_live_p
, Sbuffer_live_p
, 1, 1, 0,
372 doc
: /* Return non-nil if OBJECT is a buffer which has not been killed.
373 Value is nil if OBJECT is not a buffer or if it has been killed. */)
376 return ((BUFFERP (object
) && BUFFER_LIVE_P (XBUFFER (object
)))
380 DEFUN ("buffer-list", Fbuffer_list
, Sbuffer_list
, 0, 1, 0,
381 doc
: /* Return a list of all existing live buffers.
382 If the optional arg FRAME is a frame, we return the buffer list in the
383 proper order for that frame: the buffers show in FRAME come first,
384 followed by the rest of the buffers. */)
388 general
= Fmapcar (Qcdr
, Vbuffer_alist
);
392 Lisp_Object framelist
, prevlist
, tail
;
394 framelist
= Fcopy_sequence (XFRAME (frame
)->buffer_list
);
395 prevlist
= Fnreverse (Fcopy_sequence
396 (XFRAME (frame
)->buried_buffer_list
));
398 /* Remove from GENERAL any buffer that duplicates one in
399 FRAMELIST or PREVLIST. */
403 general
= Fdelq (XCAR (tail
), general
);
409 general
= Fdelq (XCAR (tail
), general
);
413 return CALLN (Fnconc
, framelist
, general
, prevlist
);
419 /* Like Fassoc, but use Fstring_equal to compare
420 (which ignores text properties),
421 and don't ever QUIT. */
424 assoc_ignore_text_properties (register Lisp_Object key
, Lisp_Object list
)
426 register Lisp_Object tail
;
427 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
429 register Lisp_Object elt
, tem
;
431 tem
= Fstring_equal (Fcar (elt
), key
);
438 DEFUN ("get-buffer", Fget_buffer
, Sget_buffer
, 1, 1, 0,
439 doc
: /* Return the buffer named BUFFER-OR-NAME.
440 BUFFER-OR-NAME must be either a string or a buffer. If BUFFER-OR-NAME
441 is a string and there is no buffer with that name, return nil. If
442 BUFFER-OR-NAME is a buffer, return it as given. */)
443 (register Lisp_Object buffer_or_name
)
445 if (BUFFERP (buffer_or_name
))
446 return buffer_or_name
;
447 CHECK_STRING (buffer_or_name
);
449 return Fcdr (assoc_ignore_text_properties (buffer_or_name
, Vbuffer_alist
));
452 DEFUN ("get-file-buffer", Fget_file_buffer
, Sget_file_buffer
, 1, 1, 0,
453 doc
: /* Return the buffer visiting file FILENAME (a string).
454 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
455 If there is no such live buffer, return nil.
456 See also `find-buffer-visiting'. */)
457 (register Lisp_Object filename
)
459 register Lisp_Object tail
, buf
, handler
;
461 CHECK_STRING (filename
);
462 filename
= Fexpand_file_name (filename
, Qnil
);
464 /* If the file name has special constructs in it,
465 call the corresponding file handler. */
466 handler
= Ffind_file_name_handler (filename
, Qget_file_buffer
);
469 Lisp_Object handled_buf
= call2 (handler
, Qget_file_buffer
,
471 return BUFFERP (handled_buf
) ? handled_buf
: Qnil
;
474 FOR_EACH_LIVE_BUFFER (tail
, buf
)
476 if (!STRINGP (BVAR (XBUFFER (buf
), filename
))) continue;
477 if (!NILP (Fstring_equal (BVAR (XBUFFER (buf
), filename
), filename
)))
484 get_truename_buffer (register Lisp_Object filename
)
486 register Lisp_Object tail
, buf
;
488 FOR_EACH_LIVE_BUFFER (tail
, buf
)
490 if (!STRINGP (BVAR (XBUFFER (buf
), file_truename
))) continue;
491 if (!NILP (Fstring_equal (BVAR (XBUFFER (buf
), file_truename
), filename
)))
497 DEFUN ("get-buffer-create", Fget_buffer_create
, Sget_buffer_create
, 1, 1, 0,
498 doc
: /* Return the buffer specified by BUFFER-OR-NAME, creating a new one if needed.
499 If BUFFER-OR-NAME is a string and a live buffer with that name exists,
500 return that buffer. If no such buffer exists, create a new buffer with
501 that name and return it. If BUFFER-OR-NAME starts with a space, the new
502 buffer does not keep undo information.
504 If BUFFER-OR-NAME is a buffer instead of a string, return it as given,
505 even if it is dead. The return value is never nil. */)
506 (register Lisp_Object buffer_or_name
)
508 register Lisp_Object buffer
, name
;
509 register struct buffer
*b
;
511 buffer
= Fget_buffer (buffer_or_name
);
515 if (SCHARS (buffer_or_name
) == 0)
516 error ("Empty string for buffer name is not allowed");
518 b
= allocate_buffer ();
520 /* An ordinary buffer uses its own struct buffer_text. */
521 b
->text
= &b
->own_text
;
522 b
->base_buffer
= NULL
;
523 /* No one shares the text with us now. */
525 /* No one shows us now. */
528 BUF_GAP_SIZE (b
) = 20;
530 /* We allocate extra 1-byte at the tail and keep it always '\0' for
531 anchoring a search. */
532 alloc_buffer_text (b
, BUF_GAP_SIZE (b
) + 1);
534 if (! BUF_BEG_ADDR (b
))
535 buffer_memory_full (BUF_GAP_SIZE (b
) + 1);
540 b
->pt_byte
= BEG_BYTE
;
541 b
->begv_byte
= BEG_BYTE
;
542 b
->zv_byte
= BEG_BYTE
;
545 BUF_GPT_BYTE (b
) = BEG_BYTE
;
548 BUF_Z_BYTE (b
) = BEG_BYTE
;
550 BUF_CHARS_MODIFF (b
) = 1;
551 BUF_OVERLAY_MODIFF (b
) = 1;
552 BUF_SAVE_MODIFF (b
) = 1;
554 set_buffer_intervals (b
, NULL
);
555 BUF_UNCHANGED_MODIFIED (b
) = 1;
556 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = 1;
557 BUF_END_UNCHANGED (b
) = 0;
558 BUF_BEG_UNCHANGED (b
) = 0;
559 *(BUF_GPT_ADDR (b
)) = *(BUF_Z_ADDR (b
)) = 0; /* Put an anchor '\0'. */
560 b
->text
->inhibit_shrinking
= false;
561 b
->text
->redisplay
= false;
563 b
->newline_cache
= 0;
564 b
->width_run_cache
= 0;
565 b
->bidi_paragraph_cache
= 0;
566 bset_width_table (b
, Qnil
);
567 b
->prevent_redisplay_optimizations_p
= 1;
569 /* An ordinary buffer normally doesn't need markers
570 to handle BEGV and ZV. */
571 bset_pt_marker (b
, Qnil
);
572 bset_begv_marker (b
, Qnil
);
573 bset_zv_marker (b
, Qnil
);
575 name
= Fcopy_sequence (buffer_or_name
);
576 set_string_intervals (name
, NULL
);
579 bset_undo_list (b
, SREF (name
, 0) != ' ' ? Qnil
: Qt
);
582 reset_buffer_local_variables (b
, 1);
584 bset_mark (b
, Fmake_marker ());
585 BUF_MARKERS (b
) = NULL
;
587 /* Put this in the alist of all live buffers. */
588 XSETBUFFER (buffer
, b
);
589 Vbuffer_alist
= nconc2 (Vbuffer_alist
, list1 (Fcons (name
, buffer
)));
590 /* And run buffer-list-update-hook. */
591 if (!NILP (Vrun_hooks
))
592 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
598 /* Return a list of overlays which is a copy of the overlay list
599 LIST, but for buffer B. */
601 static struct Lisp_Overlay
*
602 copy_overlays (struct buffer
*b
, struct Lisp_Overlay
*list
)
604 struct Lisp_Overlay
*result
= NULL
, *tail
= NULL
;
606 for (; list
; list
= list
->next
)
608 Lisp_Object overlay
, start
, end
;
609 struct Lisp_Marker
*m
;
611 eassert (MARKERP (list
->start
));
612 m
= XMARKER (list
->start
);
613 start
= build_marker (b
, m
->charpos
, m
->bytepos
);
614 XMARKER (start
)->insertion_type
= m
->insertion_type
;
616 eassert (MARKERP (list
->end
));
617 m
= XMARKER (list
->end
);
618 end
= build_marker (b
, m
->charpos
, m
->bytepos
);
619 XMARKER (end
)->insertion_type
= m
->insertion_type
;
621 overlay
= build_overlay (start
, end
, Fcopy_sequence (list
->plist
));
623 tail
= tail
->next
= XOVERLAY (overlay
);
625 result
= tail
= XOVERLAY (overlay
);
631 /* Set an appropriate overlay of B. */
634 set_buffer_overlays_before (struct buffer
*b
, struct Lisp_Overlay
*o
)
636 b
->overlays_before
= o
;
640 set_buffer_overlays_after (struct buffer
*b
, struct Lisp_Overlay
*o
)
642 b
->overlays_after
= o
;
645 /* Clone per-buffer values of buffer FROM.
647 Buffer TO gets the same per-buffer values as FROM, with the
648 following exceptions: (1) TO's name is left untouched, (2) markers
649 are copied and made to refer to TO, and (3) overlay lists are
653 clone_per_buffer_values (struct buffer
*from
, struct buffer
*to
)
657 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
661 /* Don't touch the `name' which should be unique for every buffer. */
662 if (offset
== PER_BUFFER_VAR_OFFSET (name
))
665 obj
= per_buffer_value (from
, offset
);
666 if (MARKERP (obj
) && XMARKER (obj
)->buffer
== from
)
668 struct Lisp_Marker
*m
= XMARKER (obj
);
670 obj
= build_marker (to
, m
->charpos
, m
->bytepos
);
671 XMARKER (obj
)->insertion_type
= m
->insertion_type
;
674 set_per_buffer_value (to
, offset
, obj
);
677 memcpy (to
->local_flags
, from
->local_flags
, sizeof to
->local_flags
);
679 set_buffer_overlays_before (to
, copy_overlays (to
, from
->overlays_before
));
680 set_buffer_overlays_after (to
, copy_overlays (to
, from
->overlays_after
));
682 /* Get (a copy of) the alist of Lisp-level local variables of FROM
683 and install that in TO. */
684 bset_local_var_alist (to
, buffer_lisp_local_variables (from
, 1));
688 /* If buffer B has markers to record PT, BEGV and ZV when it is not
689 current, update these markers. */
692 record_buffer_markers (struct buffer
*b
)
694 if (! NILP (BVAR (b
, pt_marker
)))
698 eassert (!NILP (BVAR (b
, begv_marker
)));
699 eassert (!NILP (BVAR (b
, zv_marker
)));
701 XSETBUFFER (buffer
, b
);
702 set_marker_both (BVAR (b
, pt_marker
), buffer
, b
->pt
, b
->pt_byte
);
703 set_marker_both (BVAR (b
, begv_marker
), buffer
, b
->begv
, b
->begv_byte
);
704 set_marker_both (BVAR (b
, zv_marker
), buffer
, b
->zv
, b
->zv_byte
);
709 /* If buffer B has markers to record PT, BEGV and ZV when it is not
710 current, fetch these values into B->begv etc. */
713 fetch_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 m
= BVAR (b
, pt_marker
);
723 SET_BUF_PT_BOTH (b
, marker_position (m
), marker_byte_position (m
));
725 m
= BVAR (b
, begv_marker
);
726 SET_BUF_BEGV_BOTH (b
, marker_position (m
), marker_byte_position (m
));
728 m
= BVAR (b
, zv_marker
);
729 SET_BUF_ZV_BOTH (b
, marker_position (m
), marker_byte_position (m
));
734 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer
, Smake_indirect_buffer
,
736 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ",
737 doc
: /* Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.
738 BASE-BUFFER should be a live buffer, or the name of an existing buffer.
739 NAME should be a string which is not the name of an existing buffer.
740 Optional argument CLONE non-nil means preserve BASE-BUFFER's state,
741 such as major and minor modes, in the indirect buffer.
742 CLONE nil means the indirect buffer's state is reset to default values. */)
743 (Lisp_Object base_buffer
, Lisp_Object name
, Lisp_Object clone
)
745 Lisp_Object buf
, tem
;
749 buf
= Fget_buffer (name
);
751 error ("Buffer name `%s' is in use", SDATA (name
));
754 base_buffer
= Fget_buffer (base_buffer
);
755 if (NILP (base_buffer
))
756 error ("No such buffer: `%s'", SDATA (tem
));
757 if (!BUFFER_LIVE_P (XBUFFER (base_buffer
)))
758 error ("Base buffer has been killed");
760 if (SCHARS (name
) == 0)
761 error ("Empty string for buffer name is not allowed");
763 b
= allocate_buffer ();
765 /* No double indirection - if base buffer is indirect,
766 new buffer becomes an indirect to base's base. */
767 b
->base_buffer
= (XBUFFER (base_buffer
)->base_buffer
768 ? XBUFFER (base_buffer
)->base_buffer
769 : XBUFFER (base_buffer
));
771 /* Use the base buffer's text object. */
772 b
->text
= b
->base_buffer
->text
;
773 /* We have no own text. */
774 b
->indirections
= -1;
775 /* Notify base buffer that we share the text now. */
776 b
->base_buffer
->indirections
++;
777 /* Always -1 for an indirect buffer. */
778 b
->window_count
= -1;
780 b
->pt
= b
->base_buffer
->pt
;
781 b
->begv
= b
->base_buffer
->begv
;
782 b
->zv
= b
->base_buffer
->zv
;
783 b
->pt_byte
= b
->base_buffer
->pt_byte
;
784 b
->begv_byte
= b
->base_buffer
->begv_byte
;
785 b
->zv_byte
= b
->base_buffer
->zv_byte
;
787 b
->newline_cache
= 0;
788 b
->width_run_cache
= 0;
789 b
->bidi_paragraph_cache
= 0;
790 bset_width_table (b
, Qnil
);
792 name
= Fcopy_sequence (name
);
793 set_string_intervals (name
, NULL
);
796 /* An indirect buffer shares undo list of its base (Bug#18180). */
797 bset_undo_list (b
, BVAR (b
->base_buffer
, undo_list
));
800 reset_buffer_local_variables (b
, 1);
802 /* Put this in the alist of all live buffers. */
804 Vbuffer_alist
= nconc2 (Vbuffer_alist
, list1 (Fcons (name
, buf
)));
806 bset_mark (b
, Fmake_marker ());
808 /* The multibyte status belongs to the base buffer. */
809 bset_enable_multibyte_characters
810 (b
, BVAR (b
->base_buffer
, enable_multibyte_characters
));
812 /* Make sure the base buffer has markers for its narrowing. */
813 if (NILP (BVAR (b
->base_buffer
, pt_marker
)))
815 eassert (NILP (BVAR (b
->base_buffer
, begv_marker
)));
816 eassert (NILP (BVAR (b
->base_buffer
, zv_marker
)));
818 bset_pt_marker (b
->base_buffer
,
819 build_marker (b
->base_buffer
, b
->base_buffer
->pt
,
820 b
->base_buffer
->pt_byte
));
822 bset_begv_marker (b
->base_buffer
,
823 build_marker (b
->base_buffer
, b
->base_buffer
->begv
,
824 b
->base_buffer
->begv_byte
));
826 bset_zv_marker (b
->base_buffer
,
827 build_marker (b
->base_buffer
, b
->base_buffer
->zv
,
828 b
->base_buffer
->zv_byte
));
830 XMARKER (BVAR (b
->base_buffer
, zv_marker
))->insertion_type
= 1;
835 /* Give the indirect buffer markers for its narrowing. */
836 bset_pt_marker (b
, build_marker (b
, b
->pt
, b
->pt_byte
));
837 bset_begv_marker (b
, build_marker (b
, b
->begv
, b
->begv_byte
));
838 bset_zv_marker (b
, build_marker (b
, b
->zv
, b
->zv_byte
));
839 XMARKER (BVAR (b
, zv_marker
))->insertion_type
= 1;
843 struct buffer
*old_b
= current_buffer
;
845 clone_per_buffer_values (b
->base_buffer
, b
);
846 bset_filename (b
, Qnil
);
847 bset_file_truename (b
, Qnil
);
848 bset_display_count (b
, make_number (0));
849 bset_backed_up (b
, Qnil
);
850 bset_auto_save_file_name (b
, Qnil
);
851 set_buffer_internal_1 (b
);
852 Fset (intern ("buffer-save-without-query"), Qnil
);
853 Fset (intern ("buffer-file-number"), Qnil
);
854 Fset (intern ("buffer-stale-function"), Qnil
);
855 set_buffer_internal_1 (old_b
);
858 /* Run buffer-list-update-hook. */
859 if (!NILP (Vrun_hooks
))
860 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
865 /* Mark OV as no longer associated with B. */
868 drop_overlay (struct buffer
*b
, struct Lisp_Overlay
*ov
)
870 eassert (b
== XBUFFER (Fmarker_buffer (ov
->start
)));
871 modify_overlay (b
, marker_position (ov
->start
),
872 marker_position (ov
->end
));
873 unchain_marker (XMARKER (ov
->start
));
874 unchain_marker (XMARKER (ov
->end
));
878 /* Delete all overlays of B and reset it's overlay lists. */
881 delete_all_overlays (struct buffer
*b
)
883 struct Lisp_Overlay
*ov
, *next
;
885 /* FIXME: Since each drop_overlay will scan BUF_MARKERS to unlink its
886 markers, we have an unneeded O(N^2) behavior here. */
887 for (ov
= b
->overlays_before
; ov
; ov
= next
)
889 drop_overlay (b
, ov
);
894 for (ov
= b
->overlays_after
; ov
; ov
= next
)
896 drop_overlay (b
, ov
);
901 set_buffer_overlays_before (b
, NULL
);
902 set_buffer_overlays_after (b
, NULL
);
905 /* Reinitialize everything about a buffer except its name and contents
907 If called on an already-initialized buffer, the list of overlays
908 should be deleted before calling this function, otherwise we end up
909 with overlays that claim to belong to the buffer but the buffer
910 claims it doesn't belong to it. */
913 reset_buffer (register struct buffer
*b
)
915 bset_filename (b
, Qnil
);
916 bset_file_truename (b
, Qnil
);
917 bset_directory (b
, current_buffer
? BVAR (current_buffer
, directory
) : Qnil
);
918 b
->modtime
= make_timespec (0, UNKNOWN_MODTIME_NSECS
);
919 b
->modtime_size
= -1;
920 XSETFASTINT (BVAR (b
, save_length
), 0);
921 b
->last_window_start
= 1;
922 /* It is more conservative to start out "changed" than "unchanged". */
924 b
->prevent_redisplay_optimizations_p
= 1;
925 bset_backed_up (b
, Qnil
);
926 BUF_AUTOSAVE_MODIFF (b
) = 0;
927 b
->auto_save_failure_time
= 0;
928 bset_auto_save_file_name (b
, Qnil
);
929 bset_read_only (b
, Qnil
);
930 set_buffer_overlays_before (b
, NULL
);
931 set_buffer_overlays_after (b
, NULL
);
932 b
->overlay_center
= BEG
;
933 bset_mark_active (b
, Qnil
);
934 bset_point_before_scroll (b
, Qnil
);
935 bset_file_format (b
, Qnil
);
936 bset_auto_save_file_format (b
, Qt
);
937 bset_last_selected_window (b
, Qnil
);
938 bset_display_count (b
, make_number (0));
939 bset_display_time (b
, Qnil
);
940 bset_enable_multibyte_characters
941 (b
, BVAR (&buffer_defaults
, enable_multibyte_characters
));
942 bset_cursor_type (b
, BVAR (&buffer_defaults
, cursor_type
));
943 bset_extra_line_spacing (b
, BVAR (&buffer_defaults
, extra_line_spacing
));
945 b
->display_error_modiff
= 0;
948 /* Reset buffer B's local variables info.
949 Don't use this on a buffer that has already been in use;
950 it does not treat permanent locals consistently.
951 Instead, use Fkill_all_local_variables.
953 If PERMANENT_TOO, reset permanent buffer-local variables.
954 If not, preserve those. */
957 reset_buffer_local_variables (struct buffer
*b
, bool permanent_too
)
961 /* Reset the major mode to Fundamental, together with all the
962 things that depend on the major mode.
963 default-major-mode is handled at a higher level.
964 We ignore it here. */
965 bset_major_mode (b
, Qfundamental_mode
);
966 bset_keymap (b
, Qnil
);
967 bset_mode_name (b
, QSFundamental
);
968 bset_minor_modes (b
, Qnil
);
970 /* If the standard case table has been altered and invalidated,
971 fix up its insides first. */
972 if (! (CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[0])
973 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[1])
974 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[2])))
975 Fset_standard_case_table (Vascii_downcase_table
);
977 bset_downcase_table (b
, Vascii_downcase_table
);
978 bset_upcase_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[0]);
979 bset_case_canon_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[1]);
980 bset_case_eqv_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[2]);
981 bset_invisibility_spec (b
, Qt
);
983 /* Reset all (or most) per-buffer variables to their defaults. */
985 bset_local_var_alist (b
, Qnil
);
988 Lisp_Object tmp
, prop
, last
= Qnil
;
989 for (tmp
= BVAR (b
, local_var_alist
); CONSP (tmp
); tmp
= XCDR (tmp
))
990 if (!NILP (prop
= Fget (XCAR (XCAR (tmp
)), Qpermanent_local
)))
992 /* If permanent-local, keep it. */
994 if (EQ (prop
, Qpermanent_local_hook
))
996 /* This is a partially permanent hook variable.
997 Preserve only the elements that want to be preserved. */
998 Lisp_Object list
, newlist
;
999 list
= XCDR (XCAR (tmp
));
1003 for (newlist
= Qnil
; CONSP (list
); list
= XCDR (list
))
1005 Lisp_Object elt
= XCAR (list
);
1006 /* Preserve element ELT if it's t,
1007 if it is a function with a `permanent-local-hook' property,
1008 or if it's not a symbol. */
1011 || !NILP (Fget (elt
, Qpermanent_local_hook
)))
1012 newlist
= Fcons (elt
, newlist
);
1014 XSETCDR (XCAR (tmp
), Fnreverse (newlist
));
1017 /* Delete this local variable. */
1018 else if (NILP (last
))
1019 bset_local_var_alist (b
, XCDR (tmp
));
1021 XSETCDR (last
, XCDR (tmp
));
1024 for (i
= 0; i
< last_per_buffer_idx
; ++i
)
1025 if (permanent_too
|| buffer_permanent_local_flags
[i
] == 0)
1026 SET_PER_BUFFER_VALUE_P (b
, i
, 0);
1028 /* For each slot that has a default value, copy that into the slot. */
1029 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
1031 int idx
= PER_BUFFER_IDX (offset
);
1034 || buffer_permanent_local_flags
[idx
] == 0)))
1035 set_per_buffer_value (b
, offset
, per_buffer_default (offset
));
1039 /* We split this away from generate-new-buffer, because rename-buffer
1040 and set-visited-file-name ought to be able to use this to really
1041 rename the buffer properly. */
1043 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name
,
1044 Sgenerate_new_buffer_name
, 1, 2, 0,
1045 doc
: /* Return a string that is the name of no existing buffer based on NAME.
1046 If there is no live buffer named NAME, then return NAME.
1047 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
1048 \(starting at 2) until an unused name is found, and then return that name.
1049 Optional second argument IGNORE specifies a name that is okay to use (if
1050 it is in the sequence to be tried) even if a buffer with that name exists.
1052 If NAME begins with a space (i.e., a buffer that is not normally
1053 visible to users), then if buffer NAME already exists a random number
1054 is first appended to NAME, to speed up finding a non-existent buffer. */)
1055 (register Lisp_Object name
, Lisp_Object ignore
)
1057 register Lisp_Object gentemp
, tem
, tem2
;
1059 char number
[INT_BUFSIZE_BOUND (ptrdiff_t) + sizeof "<>"];
1061 CHECK_STRING (name
);
1063 tem
= Fstring_equal (name
, ignore
);
1066 tem
= Fget_buffer (name
);
1070 if (!strncmp (SSDATA (name
), " ", 1)) /* see bug#1229 */
1072 /* Note fileio.c:make_temp_name does random differently. */
1073 tem2
= concat2 (name
, make_formatted_string
1075 XFASTINT (Frandom (make_number (999999)))));
1076 tem
= Fget_buffer (tem2
);
1086 gentemp
= concat2 (tem2
, make_formatted_string
1087 (number
, "<%"pD
"d>", ++count
));
1088 tem
= Fstring_equal (gentemp
, ignore
);
1091 tem
= Fget_buffer (gentemp
);
1098 DEFUN ("buffer-name", Fbuffer_name
, Sbuffer_name
, 0, 1, 0,
1099 doc
: /* Return the name of BUFFER, as a string.
1100 BUFFER defaults to the current buffer.
1101 Return nil if BUFFER has been killed. */)
1102 (register Lisp_Object buffer
)
1104 return BVAR (decode_buffer (buffer
), name
);
1107 DEFUN ("buffer-file-name", Fbuffer_file_name
, Sbuffer_file_name
, 0, 1, 0,
1108 doc
: /* Return name of file BUFFER is visiting, or nil if none.
1109 No argument or nil as argument means use the current buffer. */)
1110 (register Lisp_Object buffer
)
1112 return BVAR (decode_buffer (buffer
), filename
);
1115 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer
, Sbuffer_base_buffer
,
1117 doc
: /* Return the base buffer of indirect buffer BUFFER.
1118 If BUFFER is not indirect, return nil.
1119 BUFFER defaults to the current buffer. */)
1120 (register Lisp_Object buffer
)
1122 struct buffer
*base
= decode_buffer (buffer
)->base_buffer
;
1123 return base
? (XSETBUFFER (buffer
, base
), buffer
) : Qnil
;
1126 DEFUN ("buffer-local-value", Fbuffer_local_value
,
1127 Sbuffer_local_value
, 2, 2, 0,
1128 doc
: /* Return the value of VARIABLE in BUFFER.
1129 If VARIABLE does not have a buffer-local binding in BUFFER, the value
1130 is the default binding of the variable. */)
1131 (register Lisp_Object variable
, register Lisp_Object buffer
)
1133 register Lisp_Object result
= buffer_local_value (variable
, buffer
);
1135 if (EQ (result
, Qunbound
))
1136 xsignal1 (Qvoid_variable
, variable
);
1142 /* Like Fbuffer_local_value, but return Qunbound if the variable is
1146 buffer_local_value (Lisp_Object variable
, Lisp_Object buffer
)
1148 register struct buffer
*buf
;
1149 register Lisp_Object result
;
1150 struct Lisp_Symbol
*sym
;
1152 CHECK_SYMBOL (variable
);
1153 CHECK_BUFFER (buffer
);
1154 buf
= XBUFFER (buffer
);
1155 sym
= XSYMBOL (variable
);
1158 switch (sym
->redirect
)
1160 case SYMBOL_VARALIAS
: sym
= indirect_variable (sym
); goto start
;
1161 case SYMBOL_PLAINVAL
: result
= SYMBOL_VAL (sym
); break;
1162 case SYMBOL_LOCALIZED
:
1163 { /* Look in local_var_alist. */
1164 struct Lisp_Buffer_Local_Value
*blv
= SYMBOL_BLV (sym
);
1165 XSETSYMBOL (variable
, sym
); /* Update In case of aliasing. */
1166 result
= Fassoc (variable
, BVAR (buf
, local_var_alist
));
1170 { /* What binding is loaded right now? */
1171 Lisp_Object current_alist_element
= blv
->valcell
;
1173 /* The value of the currently loaded binding is not
1174 stored in it, but rather in the realvalue slot.
1175 Store that value into the binding it belongs to
1176 in case that is the one we are about to use. */
1178 XSETCDR (current_alist_element
,
1179 do_symval_forwarding (blv
->fwd
));
1181 /* Now get the (perhaps updated) value out of the binding. */
1182 result
= XCDR (result
);
1185 result
= Fdefault_value (variable
);
1188 case SYMBOL_FORWARDED
:
1190 union Lisp_Fwd
*fwd
= SYMBOL_FWD (sym
);
1191 if (BUFFER_OBJFWDP (fwd
))
1192 result
= per_buffer_value (buf
, XBUFFER_OBJFWD (fwd
)->offset
);
1194 result
= Fdefault_value (variable
);
1197 default: emacs_abort ();
1203 /* Return an alist of the Lisp-level buffer-local bindings of
1204 buffer BUF. That is, don't include the variables maintained
1205 in special slots in the buffer object.
1206 If not CLONE, replace elements of the form (VAR . unbound)
1210 buffer_lisp_local_variables (struct buffer
*buf
, bool clone
)
1212 Lisp_Object result
= Qnil
;
1214 for (tail
= BVAR (buf
, local_var_alist
); CONSP (tail
); tail
= XCDR (tail
))
1216 Lisp_Object val
, elt
;
1220 /* Reference each variable in the alist in buf.
1221 If inquiring about the current buffer, this gets the current values,
1222 so store them into the alist so the alist is up to date.
1223 If inquiring about some other buffer, this swaps out any values
1224 for that buffer, making the alist up to date automatically. */
1225 val
= find_symbol_value (XCAR (elt
));
1226 /* Use the current buffer value only if buf is the current buffer. */
1227 if (buf
!= current_buffer
)
1230 result
= Fcons (!clone
&& EQ (val
, Qunbound
)
1232 : Fcons (XCAR (elt
), val
),
1239 DEFUN ("buffer-local-variables", Fbuffer_local_variables
,
1240 Sbuffer_local_variables
, 0, 1, 0,
1241 doc
: /* Return an alist of variables that are buffer-local in BUFFER.
1242 Most elements look like (SYMBOL . VALUE), describing one variable.
1243 For a symbol that is locally unbound, just the symbol appears in the value.
1244 Note that storing new VALUEs in these elements doesn't change the variables.
1245 No argument or nil as argument means use current buffer as BUFFER. */)
1246 (Lisp_Object buffer
)
1248 struct buffer
*buf
= decode_buffer (buffer
);
1249 Lisp_Object result
= buffer_lisp_local_variables (buf
, 0);
1251 /* Add on all the variables stored in special slots. */
1255 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
1257 idx
= PER_BUFFER_IDX (offset
);
1258 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
1259 && SYMBOLP (PER_BUFFER_SYMBOL (offset
)))
1261 Lisp_Object sym
= PER_BUFFER_SYMBOL (offset
);
1262 Lisp_Object val
= per_buffer_value (buf
, offset
);
1263 result
= Fcons (EQ (val
, Qunbound
) ? sym
: Fcons (sym
, val
),
1272 DEFUN ("buffer-modified-p", Fbuffer_modified_p
, Sbuffer_modified_p
,
1274 doc
: /* Return t if BUFFER was modified since its file was last read or saved.
1275 No argument or nil as argument means use current buffer as BUFFER. */)
1276 (Lisp_Object buffer
)
1278 struct buffer
*buf
= decode_buffer (buffer
);
1279 return BUF_SAVE_MODIFF (buf
) < BUF_MODIFF (buf
) ? Qt
: Qnil
;
1282 DEFUN ("force-mode-line-update", Fforce_mode_line_update
,
1283 Sforce_mode_line_update
, 0, 1, 0,
1284 doc
: /* Force redisplay of the current buffer's mode line and header line.
1285 With optional non-nil ALL, force redisplay of all mode lines and
1286 header lines. This function also forces recomputation of the
1287 menu bar menus and the frame title. */)
1292 update_mode_lines
= 10;
1293 /* FIXME: This can't be right. */
1294 current_buffer
->prevent_redisplay_optimizations_p
= true;
1296 else if (buffer_window_count (current_buffer
))
1298 bset_update_mode_line (current_buffer
);
1299 current_buffer
->prevent_redisplay_optimizations_p
= true;
1304 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p
, Sset_buffer_modified_p
,
1306 doc
: /* Mark current buffer as modified or unmodified according to FLAG.
1307 A non-nil FLAG means mark the buffer modified. */)
1310 Frestore_buffer_modified_p (flag
);
1312 /* Set update_mode_lines only if buffer is displayed in some window.
1313 Packages like jit-lock or lazy-lock preserve a buffer's modified
1314 state by recording/restoring the state around blocks of code.
1315 Setting update_mode_lines makes redisplay consider all windows
1316 (on all frames). Stealth fontification of buffers not displayed
1317 would incur additional redisplay costs if we'd set
1318 update_modes_lines unconditionally.
1320 Ideally, I think there should be another mechanism for fontifying
1321 buffers without "modifying" buffers, or redisplay should be
1322 smarter about updating the `*' in mode lines. --gerd */
1323 return Fforce_mode_line_update (Qnil
);
1326 DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p
,
1327 Srestore_buffer_modified_p
, 1, 1, 0,
1328 doc
: /* Like `set-buffer-modified-p', with a difference concerning redisplay.
1329 It is not ensured that mode lines will be updated to show the modified
1330 state of the current buffer. Use with care. */)
1335 /* If buffer becoming modified, lock the file.
1336 If buffer becoming unmodified, unlock the file. */
1338 struct buffer
*b
= current_buffer
->base_buffer
1339 ? current_buffer
->base_buffer
1342 fn
= BVAR (b
, file_truename
);
1343 /* Test buffer-file-name so that binding it to nil is effective. */
1344 if (!NILP (fn
) && ! NILP (BVAR (b
, filename
)))
1346 bool already
= SAVE_MODIFF
< MODIFF
;
1347 if (!already
&& !NILP (flag
))
1349 else if (already
&& NILP (flag
))
1353 /* Here we have a problem. SAVE_MODIFF is used here to encode
1354 buffer-modified-p (as SAVE_MODIFF<MODIFF) as well as
1355 recent-auto-save-p (as SAVE_MODIFF<auto_save_modified). So if we
1356 modify SAVE_MODIFF to affect one, we may affect the other
1358 E.g. if FLAG is nil we need to set SAVE_MODIFF to MODIFF, but
1359 if SAVE_MODIFF<auto_save_modified that means we risk changing
1360 recent-auto-save-p from t to nil.
1361 Vice versa, if FLAG is non-nil and SAVE_MODIFF>=auto_save_modified
1362 we risk changing recent-auto-save-p from nil to t. */
1363 SAVE_MODIFF
= (NILP (flag
)
1364 /* FIXME: This unavoidably sets recent-auto-save-p to nil. */
1366 /* Let's try to preserve recent-auto-save-p. */
1367 : SAVE_MODIFF
< MODIFF
? SAVE_MODIFF
1368 /* If SAVE_MODIFF == auto_save_modified == MODIFF,
1369 we can either decrease SAVE_MODIFF and auto_save_modified
1370 or increase MODIFF. */
1376 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick
, Sbuffer_modified_tick
,
1378 doc
: /* Return BUFFER's tick counter, incremented for each change in text.
1379 Each buffer has a tick counter which is incremented each time the
1380 text in that buffer is changed. It wraps around occasionally.
1381 No argument or nil as argument means use current buffer as BUFFER. */)
1382 (register Lisp_Object buffer
)
1384 return make_number (BUF_MODIFF (decode_buffer (buffer
)));
1387 DEFUN ("buffer-chars-modified-tick", Fbuffer_chars_modified_tick
,
1388 Sbuffer_chars_modified_tick
, 0, 1, 0,
1389 doc
: /* Return BUFFER's character-change tick counter.
1390 Each buffer has a character-change tick counter, which is set to the
1391 value of the buffer's tick counter \(see `buffer-modified-tick'), each
1392 time text in that buffer is inserted or deleted. By comparing the
1393 values returned by two individual calls of `buffer-chars-modified-tick',
1394 you can tell whether a character change occurred in that buffer in
1395 between these calls. No argument or nil as argument means use current
1396 buffer as BUFFER. */)
1397 (register Lisp_Object buffer
)
1399 return make_number (BUF_CHARS_MODIFF (decode_buffer (buffer
)));
1402 DEFUN ("rename-buffer", Frename_buffer
, Srename_buffer
, 1, 2,
1403 "(list (read-string \"Rename buffer (to new name): \" \
1404 nil 'buffer-name-history (buffer-name (current-buffer))) \
1405 current-prefix-arg)",
1406 doc
: /* Change current buffer's name to NEWNAME (a string).
1407 If second arg UNIQUE is nil or omitted, it is an error if a
1408 buffer named NEWNAME already exists.
1409 If UNIQUE is non-nil, come up with a new name using
1410 `generate-new-buffer-name'.
1411 Interactively, you can set UNIQUE with a prefix argument.
1412 We return the name we actually gave the buffer.
1413 This does not change the name of the visited file (if any). */)
1414 (register Lisp_Object newname
, Lisp_Object unique
)
1416 register Lisp_Object tem
, buf
;
1418 CHECK_STRING (newname
);
1420 if (SCHARS (newname
) == 0)
1421 error ("Empty string is invalid as a buffer name");
1423 tem
= Fget_buffer (newname
);
1426 /* Don't short-circuit if UNIQUE is t. That is a useful way to
1427 rename the buffer automatically so you can create another
1428 with the original name. It makes UNIQUE equivalent to
1429 (rename-buffer (generate-new-buffer-name NEWNAME)). */
1430 if (NILP (unique
) && XBUFFER (tem
) == current_buffer
)
1431 return BVAR (current_buffer
, name
);
1433 newname
= Fgenerate_new_buffer_name (newname
, BVAR (current_buffer
, name
));
1435 error ("Buffer name `%s' is in use", SDATA (newname
));
1438 bset_name (current_buffer
, newname
);
1440 /* Catch redisplay's attention. Unless we do this, the mode lines for
1441 any windows displaying current_buffer will stay unchanged. */
1442 update_mode_lines
= 11;
1444 XSETBUFFER (buf
, current_buffer
);
1445 Fsetcar (Frassq (buf
, Vbuffer_alist
), newname
);
1446 if (NILP (BVAR (current_buffer
, filename
))
1447 && !NILP (BVAR (current_buffer
, auto_save_file_name
)))
1448 call0 (intern ("rename-auto-save-file"));
1450 /* Run buffer-list-update-hook. */
1451 if (!NILP (Vrun_hooks
))
1452 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1454 /* Refetch since that last call may have done GC. */
1455 return BVAR (current_buffer
, name
);
1458 /* True if B can be used as 'other-than-BUFFER' buffer. */
1461 candidate_buffer (Lisp_Object b
, Lisp_Object buffer
)
1463 return (BUFFERP (b
) && !EQ (b
, buffer
)
1464 && BUFFER_LIVE_P (XBUFFER (b
))
1465 && !BUFFER_HIDDEN_P (XBUFFER (b
)));
1468 DEFUN ("other-buffer", Fother_buffer
, Sother_buffer
, 0, 3, 0,
1469 doc
: /* Return most recently selected buffer other than BUFFER.
1470 Buffers not visible in windows are preferred to visible buffers, unless
1471 optional second argument VISIBLE-OK is non-nil. Ignore the argument
1472 BUFFER unless it denotes a live buffer. If the optional third argument
1473 FRAME is non-nil, use that frame's buffer list instead of the selected
1474 frame's buffer list.
1476 The buffer is found by scanning the selected or specified frame's buffer
1477 list first, followed by the list of all buffers. If no other buffer
1478 exists, return the buffer `*scratch*' (creating it if necessary). */)
1479 (Lisp_Object buffer
, Lisp_Object visible_ok
, Lisp_Object frame
)
1481 struct frame
*f
= decode_any_frame (frame
);
1482 Lisp_Object tail
= f
->buffer_list
, pred
= f
->buffer_predicate
;
1483 Lisp_Object buf
, notsogood
= Qnil
;
1485 /* Consider buffers that have been seen in the frame first. */
1486 for (; CONSP (tail
); tail
= XCDR (tail
))
1489 if (candidate_buffer (buf
, buffer
)
1490 /* If the frame has a buffer_predicate, disregard buffers that
1491 don't fit the predicate. */
1492 && (NILP (pred
) || !NILP (call1 (pred
, buf
))))
1494 if (!NILP (visible_ok
)
1495 || NILP (Fget_buffer_window (buf
, Qvisible
)))
1497 else if (NILP (notsogood
))
1502 /* Consider alist of all buffers next. */
1503 FOR_EACH_LIVE_BUFFER (tail
, buf
)
1505 if (candidate_buffer (buf
, buffer
)
1506 /* If the frame has a buffer_predicate, disregard buffers that
1507 don't fit the predicate. */
1508 && (NILP (pred
) || !NILP (call1 (pred
, buf
))))
1510 if (!NILP (visible_ok
)
1511 || NILP (Fget_buffer_window (buf
, Qvisible
)))
1513 else if (NILP (notsogood
))
1518 if (!NILP (notsogood
))
1522 AUTO_STRING (scratch
, "*scratch*");
1523 buf
= Fget_buffer (scratch
);
1526 buf
= Fget_buffer_create (scratch
);
1527 Fset_buffer_major_mode (buf
);
1533 /* The following function is a safe variant of Fother_buffer: It doesn't
1534 pay attention to any frame-local buffer lists, doesn't care about
1535 visibility of buffers, and doesn't evaluate any frame predicates. */
1538 other_buffer_safely (Lisp_Object buffer
)
1540 Lisp_Object tail
, buf
;
1542 FOR_EACH_LIVE_BUFFER (tail
, buf
)
1543 if (candidate_buffer (buf
, buffer
))
1546 AUTO_STRING (scratch
, "*scratch*");
1547 buf
= Fget_buffer (scratch
);
1550 buf
= Fget_buffer_create (scratch
);
1551 Fset_buffer_major_mode (buf
);
1557 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo
, Sbuffer_enable_undo
,
1559 doc
: /* Start keeping undo information for buffer BUFFER.
1560 No argument or nil as argument means do this for the current buffer. */)
1561 (register Lisp_Object buffer
)
1563 Lisp_Object real_buffer
;
1566 XSETBUFFER (real_buffer
, current_buffer
);
1569 real_buffer
= Fget_buffer (buffer
);
1570 if (NILP (real_buffer
))
1574 if (EQ (BVAR (XBUFFER (real_buffer
), undo_list
), Qt
))
1575 bset_undo_list (XBUFFER (real_buffer
), Qnil
);
1580 /* Truncate undo list and shrink the gap of BUFFER. */
1583 compact_buffer (struct buffer
*buffer
)
1585 BUFFER_CHECK_INDIRECTION (buffer
);
1587 /* Skip dead buffers, indirect buffers and buffers
1588 which aren't changed since last compaction. */
1589 if (BUFFER_LIVE_P (buffer
)
1590 && (buffer
->base_buffer
== NULL
)
1591 && (BUF_COMPACT (buffer
) != BUF_MODIFF (buffer
)))
1593 /* If a buffer's undo list is Qt, that means that undo is
1594 turned off in that buffer. Calling truncate_undo_list on
1595 Qt tends to return NULL, which effectively turns undo back on.
1596 So don't call truncate_undo_list if undo_list is Qt. */
1597 if (!EQ (buffer
->INTERNAL_FIELD (undo_list
), Qt
))
1598 truncate_undo_list (buffer
);
1600 /* Shrink buffer gaps. */
1601 if (!buffer
->text
->inhibit_shrinking
)
1603 /* If a buffer's gap size is more than 10% of the buffer
1604 size, or larger than GAP_BYTES_DFL bytes, then shrink it
1605 accordingly. Keep a minimum size of GAP_BYTES_MIN bytes. */
1606 ptrdiff_t size
= clip_to_bounds (GAP_BYTES_MIN
,
1607 BUF_Z_BYTE (buffer
) / 10,
1609 if (BUF_GAP_SIZE (buffer
) > size
)
1610 make_gap_1 (buffer
, -(BUF_GAP_SIZE (buffer
) - size
));
1612 BUF_COMPACT (buffer
) = BUF_MODIFF (buffer
);
1616 DEFUN ("kill-buffer", Fkill_buffer
, Skill_buffer
, 0, 1, "bKill buffer: ",
1617 doc
: /* Kill the buffer specified by BUFFER-OR-NAME.
1618 The argument may be a buffer or the name of an existing buffer.
1619 Argument nil or omitted means kill the current buffer. Return t if the
1620 buffer is actually killed, nil otherwise.
1622 The functions in `kill-buffer-query-functions' are called with the
1623 buffer to be killed as the current buffer. If any of them returns nil,
1624 the buffer is not killed. The hook `kill-buffer-hook' is run before the
1625 buffer is actually killed. The buffer being killed will be current
1626 while the hook is running. Functions called by any of these hooks are
1627 supposed to not change the current buffer.
1629 Any processes that have this buffer as the `process-buffer' are killed
1630 with SIGHUP. This function calls `replace-buffer-in-windows' for
1631 cleaning up all windows currently displaying the buffer to be killed. */)
1632 (Lisp_Object buffer_or_name
)
1635 register struct buffer
*b
;
1636 register Lisp_Object tem
;
1637 register struct Lisp_Marker
*m
;
1638 struct gcpro gcpro1
;
1640 if (NILP (buffer_or_name
))
1641 buffer
= Fcurrent_buffer ();
1643 buffer
= Fget_buffer (buffer_or_name
);
1645 nsberror (buffer_or_name
);
1647 b
= XBUFFER (buffer
);
1649 /* Avoid trouble for buffer already dead. */
1650 if (!BUFFER_LIVE_P (b
))
1653 /* Run hooks with the buffer to be killed the current buffer. */
1655 ptrdiff_t count
= SPECPDL_INDEX ();
1657 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1658 set_buffer_internal (b
);
1660 /* First run the query functions; if any query is answered no,
1661 don't kill the buffer. */
1662 tem
= CALLN (Frun_hook_with_args_until_failure
,
1663 Qkill_buffer_query_functions
);
1665 return unbind_to (count
, Qnil
);
1667 /* Query if the buffer is still modified. */
1668 if (INTERACTIVE
&& !NILP (BVAR (b
, filename
))
1669 && BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
1672 tem
= do_yes_or_no_p (format2 ("Buffer %s modified; kill anyway? ",
1673 BVAR (b
, name
), make_number (0)));
1676 return unbind_to (count
, Qnil
);
1679 /* If the hooks have killed the buffer, exit now. */
1680 if (!BUFFER_LIVE_P (b
))
1681 return unbind_to (count
, Qt
);
1683 /* Then run the hooks. */
1684 run_hook (Qkill_buffer_hook
);
1685 unbind_to (count
, Qnil
);
1688 /* If the hooks have killed the buffer, exit now. */
1689 if (!BUFFER_LIVE_P (b
))
1692 /* We have no more questions to ask. Verify that it is valid
1693 to kill the buffer. This must be done after the questions
1694 since anything can happen within do_yes_or_no_p. */
1696 /* Don't kill the minibuffer now current. */
1697 if (EQ (buffer
, XWINDOW (minibuf_window
)->contents
))
1700 /* When we kill an ordinary buffer which shares it's buffer text
1701 with indirect buffer(s), we must kill indirect buffer(s) too.
1702 We do it at this stage so nothing terrible happens if they
1703 ask questions or their hooks get errors. */
1704 if (!b
->base_buffer
&& b
->indirections
> 0)
1706 struct buffer
*other
;
1710 FOR_EACH_BUFFER (other
)
1711 if (other
->base_buffer
== b
)
1714 XSETBUFFER (buf
, other
);
1720 /* Exit if we now have killed the base buffer (Bug#11665). */
1721 if (!BUFFER_LIVE_P (b
))
1725 /* Run replace_buffer_in_windows before making another buffer current
1726 since set-window-buffer-start-and-point will refuse to make another
1727 buffer current if the selected window does not show the current
1728 buffer (bug#10114). */
1729 replace_buffer_in_windows (buffer
);
1731 /* Exit if replacing the buffer in windows has killed our buffer. */
1732 if (!BUFFER_LIVE_P (b
))
1735 /* Make this buffer not be current. Exit if it is the sole visible
1737 if (b
== current_buffer
)
1739 tem
= Fother_buffer (buffer
, Qnil
, Qnil
);
1741 if (b
== current_buffer
)
1745 /* If the buffer now current is shown in the minibuffer and our buffer
1746 is the sole other buffer give up. */
1747 XSETBUFFER (tem
, current_buffer
);
1748 if (EQ (tem
, XWINDOW (minibuf_window
)->contents
)
1749 && EQ (buffer
, Fother_buffer (buffer
, Qnil
, Qnil
)))
1752 /* Now there is no question: we can kill the buffer. */
1754 /* Unlock this buffer's file, if it is locked. */
1758 kill_buffer_processes (buffer
);
1761 #ifdef HAVE_XWIDGETS
1763 kill_buffer_xwidgets (buffer
);
1765 #endif /* HAVE_XWIDGETS */
1766 /* Killing buffer processes may run sentinels which may have killed
1768 if (!BUFFER_LIVE_P (b
))
1771 /* These may run Lisp code and into infinite loops (if someone
1772 insisted on circular lists) so allow quitting here. */
1773 frames_discard_buffer (buffer
);
1775 clear_charpos_cache (b
);
1777 tem
= Vinhibit_quit
;
1779 /* Remove the buffer from the list of all buffers. */
1780 Vbuffer_alist
= Fdelq (Frassq (buffer
, Vbuffer_alist
), Vbuffer_alist
);
1781 /* If replace_buffer_in_windows didn't do its job fix that now. */
1782 replace_buffer_in_windows_safely (buffer
);
1783 Vinhibit_quit
= tem
;
1785 /* Delete any auto-save file, if we saved it in this session.
1786 But not if the buffer is modified. */
1787 if (STRINGP (BVAR (b
, auto_save_file_name
))
1788 && BUF_AUTOSAVE_MODIFF (b
) != 0
1789 && BUF_SAVE_MODIFF (b
) < BUF_AUTOSAVE_MODIFF (b
)
1790 && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
)
1791 && NILP (Fsymbol_value (intern ("auto-save-visited-file-name"))))
1794 delete = Fsymbol_value (intern ("delete-auto-save-files"));
1795 if (! NILP (delete))
1796 internal_delete_file (BVAR (b
, auto_save_file_name
));
1799 /* Deleting an auto-save file could have killed our buffer. */
1800 if (!BUFFER_LIVE_P (b
))
1806 /* Unchain all markers that belong to this indirect buffer.
1807 Don't unchain the markers that belong to the base buffer
1808 or its other indirect buffers. */
1809 struct Lisp_Marker
**mp
= &BUF_MARKERS (b
);
1820 /* Intervals should be owned by the base buffer (Bug#16502). */
1821 i
= buffer_intervals (b
);
1825 XSETBUFFER (owner
, b
->base_buffer
);
1826 set_interval_object (i
, owner
);
1831 /* Unchain all markers of this buffer and its indirect buffers.
1832 and leave them pointing nowhere. */
1833 for (m
= BUF_MARKERS (b
); m
; )
1835 struct Lisp_Marker
*next
= m
->next
;
1840 BUF_MARKERS (b
) = NULL
;
1841 set_buffer_intervals (b
, NULL
);
1843 /* Perhaps we should explicitly free the interval tree here... */
1845 /* Since we've unlinked the markers, the overlays can't be here any more
1847 b
->overlays_before
= NULL
;
1848 b
->overlays_after
= NULL
;
1850 /* Reset the local variables, so that this buffer's local values
1851 won't be protected from GC. They would be protected
1852 if they happened to remain cached in their symbols.
1853 This gets rid of them for certain. */
1854 swap_out_buffer_local_variables (b
);
1855 reset_buffer_local_variables (b
, 1);
1857 bset_name (b
, Qnil
);
1862 /* Notify our base buffer that we don't share the text anymore. */
1863 eassert (b
->indirections
== -1);
1864 b
->base_buffer
->indirections
--;
1865 eassert (b
->base_buffer
->indirections
>= 0);
1866 /* Make sure that we wasn't confused. */
1867 eassert (b
->window_count
== -1);
1871 /* Make sure that no one shows us. */
1872 eassert (b
->window_count
== 0);
1873 /* No one shares our buffer text, can free it. */
1874 free_buffer_text (b
);
1877 if (b
->newline_cache
)
1879 free_region_cache (b
->newline_cache
);
1880 b
->newline_cache
= 0;
1882 if (b
->width_run_cache
)
1884 free_region_cache (b
->width_run_cache
);
1885 b
->width_run_cache
= 0;
1887 if (b
->bidi_paragraph_cache
)
1889 free_region_cache (b
->bidi_paragraph_cache
);
1890 b
->bidi_paragraph_cache
= 0;
1892 bset_width_table (b
, Qnil
);
1894 bset_undo_list (b
, Qnil
);
1896 /* Run buffer-list-update-hook. */
1897 if (!NILP (Vrun_hooks
))
1898 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1903 /* Move association for BUFFER to the front of buffer (a)lists. Since
1904 we do this each time BUFFER is selected visibly, the more recently
1905 selected buffers are always closer to the front of those lists. This
1906 means that other_buffer is more likely to choose a relevant buffer.
1908 Note that this moves BUFFER to the front of the buffer lists of the
1909 selected frame even if BUFFER is not shown there. If BUFFER is not
1910 shown in the selected frame, consider the present behavior a feature.
1911 `select-window' gets this right since it shows BUFFER in the selected
1912 window when calling us. */
1915 record_buffer (Lisp_Object buffer
)
1917 Lisp_Object aelt
, aelt_cons
, tem
;
1918 register struct frame
*f
= XFRAME (selected_frame
);
1920 CHECK_BUFFER (buffer
);
1922 /* Update Vbuffer_alist (we know that it has an entry for BUFFER).
1923 Don't allow quitting since this might leave the buffer list in an
1924 inconsistent state. */
1925 tem
= Vinhibit_quit
;
1927 aelt
= Frassq (buffer
, Vbuffer_alist
);
1928 aelt_cons
= Fmemq (aelt
, Vbuffer_alist
);
1929 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
1930 XSETCDR (aelt_cons
, Vbuffer_alist
);
1931 Vbuffer_alist
= aelt_cons
;
1932 Vinhibit_quit
= tem
;
1934 /* Update buffer list of selected frame. */
1935 fset_buffer_list (f
, Fcons (buffer
, Fdelq (buffer
, f
->buffer_list
)));
1936 fset_buried_buffer_list (f
, Fdelq (buffer
, f
->buried_buffer_list
));
1938 /* Run buffer-list-update-hook. */
1939 if (!NILP (Vrun_hooks
))
1940 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1944 /* Move BUFFER to the end of the buffer (a)lists. Do nothing if the
1945 buffer is killed. For the selected frame's buffer list this moves
1946 BUFFER to its end even if it was never shown in that frame. If
1947 this happens we have a feature, hence `bury-buffer-internal' should be
1948 called only when BUFFER was shown in the selected frame. */
1950 DEFUN ("bury-buffer-internal", Fbury_buffer_internal
, Sbury_buffer_internal
,
1952 doc
: /* Move BUFFER to the end of the buffer list. */)
1953 (Lisp_Object buffer
)
1955 Lisp_Object aelt
, aelt_cons
, tem
;
1956 register struct frame
*f
= XFRAME (selected_frame
);
1958 CHECK_BUFFER (buffer
);
1960 /* Update Vbuffer_alist (we know that it has an entry for BUFFER).
1961 Don't allow quitting since this might leave the buffer list in an
1962 inconsistent state. */
1963 tem
= Vinhibit_quit
;
1965 aelt
= Frassq (buffer
, Vbuffer_alist
);
1966 aelt_cons
= Fmemq (aelt
, Vbuffer_alist
);
1967 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
1968 XSETCDR (aelt_cons
, Qnil
);
1969 Vbuffer_alist
= nconc2 (Vbuffer_alist
, aelt_cons
);
1970 Vinhibit_quit
= tem
;
1972 /* Update buffer lists of selected frame. */
1973 fset_buffer_list (f
, Fdelq (buffer
, f
->buffer_list
));
1974 fset_buried_buffer_list
1975 (f
, Fcons (buffer
, Fdelq (buffer
, f
->buried_buffer_list
)));
1977 /* Run buffer-list-update-hook. */
1978 if (!NILP (Vrun_hooks
))
1979 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1984 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode
, Sset_buffer_major_mode
, 1, 1, 0,
1985 doc
: /* Set an appropriate major mode for BUFFER.
1986 For the *scratch* buffer, use `initial-major-mode', otherwise choose a mode
1987 according to the default value of `major-mode'.
1988 Use this function before selecting the buffer, since it may need to inspect
1989 the current buffer's major mode. */)
1990 (Lisp_Object buffer
)
1993 Lisp_Object function
;
1995 CHECK_BUFFER (buffer
);
1997 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
1998 error ("Attempt to set major mode for a dead buffer");
2000 if (strcmp (SSDATA (BVAR (XBUFFER (buffer
), name
)), "*scratch*") == 0)
2001 function
= find_symbol_value (intern ("initial-major-mode"));
2004 function
= BVAR (&buffer_defaults
, major_mode
);
2006 && NILP (Fget (BVAR (current_buffer
, major_mode
), Qmode_class
)))
2007 function
= BVAR (current_buffer
, major_mode
);
2010 if (NILP (function
) || EQ (function
, Qfundamental_mode
))
2013 count
= SPECPDL_INDEX ();
2015 /* To select a nonfundamental mode,
2016 select the buffer temporarily and then call the mode function. */
2018 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2020 Fset_buffer (buffer
);
2023 return unbind_to (count
, Qnil
);
2026 DEFUN ("current-buffer", Fcurrent_buffer
, Scurrent_buffer
, 0, 0, 0,
2027 doc
: /* Return the current buffer as a Lisp object. */)
2030 register Lisp_Object buf
;
2031 XSETBUFFER (buf
, current_buffer
);
2035 /* Set the current buffer to B, and do not set windows_or_buffers_changed.
2036 This is used by redisplay. */
2039 set_buffer_internal_1 (register struct buffer
*b
)
2041 register struct buffer
*old_buf
;
2042 register Lisp_Object tail
;
2044 #ifdef USE_MMAP_FOR_BUFFERS
2045 if (b
->text
->beg
== NULL
)
2046 enlarge_buffer_text (b
, 0);
2047 #endif /* USE_MMAP_FOR_BUFFERS */
2049 if (current_buffer
== b
)
2052 BUFFER_CHECK_INDIRECTION (b
);
2054 old_buf
= current_buffer
;
2056 last_known_column_point
= -1; /* Invalidate indentation cache. */
2060 /* Put the undo list back in the base buffer, so that it appears
2061 that an indirect buffer shares the undo list of its base. */
2062 if (old_buf
->base_buffer
)
2063 bset_undo_list (old_buf
->base_buffer
, BVAR (old_buf
, undo_list
));
2065 /* If the old current buffer has markers to record PT, BEGV and ZV
2066 when it is not current, update them now. */
2067 record_buffer_markers (old_buf
);
2070 /* Get the undo list from the base buffer, so that it appears
2071 that an indirect buffer shares the undo list of its base. */
2073 bset_undo_list (b
, BVAR (b
->base_buffer
, undo_list
));
2075 /* If the new current buffer has markers to record PT, BEGV and ZV
2076 when it is not current, fetch them now. */
2077 fetch_buffer_markers (b
);
2079 /* Look down buffer's list of local Lisp variables
2080 to find and update any that forward into C variables. */
2084 for (tail
= BVAR (b
, local_var_alist
); CONSP (tail
); tail
= XCDR (tail
))
2086 Lisp_Object var
= XCAR (XCAR (tail
));
2087 struct Lisp_Symbol
*sym
= XSYMBOL (var
);
2088 if (sym
->redirect
== SYMBOL_LOCALIZED
/* Just to be sure. */
2089 && SYMBOL_BLV (sym
)->fwd
)
2090 /* Just reference the variable
2091 to cause it to become set for this buffer. */
2092 Fsymbol_value (var
);
2095 /* Do the same with any others that were local to the previous buffer */
2096 while (b
!= old_buf
&& (b
= old_buf
, b
));
2099 /* Switch to buffer B temporarily for redisplay purposes.
2100 This avoids certain things that don't need to be done within redisplay. */
2103 set_buffer_temp (struct buffer
*b
)
2105 register struct buffer
*old_buf
;
2107 if (current_buffer
== b
)
2110 old_buf
= current_buffer
;
2113 /* If the old current buffer has markers to record PT, BEGV and ZV
2114 when it is not current, update them now. */
2115 record_buffer_markers (old_buf
);
2117 /* If the new current buffer has markers to record PT, BEGV and ZV
2118 when it is not current, fetch them now. */
2119 fetch_buffer_markers (b
);
2122 DEFUN ("set-buffer", Fset_buffer
, Sset_buffer
, 1, 1, 0,
2123 doc
: /* Make buffer BUFFER-OR-NAME current for editing operations.
2124 BUFFER-OR-NAME may be a buffer or the name of an existing buffer.
2125 See also `with-current-buffer' when you want to make a buffer current
2126 temporarily. This function does not display the buffer, so its effect
2127 ends when the current command terminates. Use `switch-to-buffer' or
2128 `pop-to-buffer' to switch buffers permanently.
2129 The return value is the buffer made current. */)
2130 (register Lisp_Object buffer_or_name
)
2132 register Lisp_Object buffer
;
2133 buffer
= Fget_buffer (buffer_or_name
);
2135 nsberror (buffer_or_name
);
2136 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
2137 error ("Selecting deleted buffer");
2138 set_buffer_internal (XBUFFER (buffer
));
2143 restore_buffer (Lisp_Object buffer_or_name
)
2145 Fset_buffer (buffer_or_name
);
2148 /* Set the current buffer to BUFFER provided if it is alive. */
2151 set_buffer_if_live (Lisp_Object buffer
)
2153 if (BUFFER_LIVE_P (XBUFFER (buffer
)))
2154 set_buffer_internal (XBUFFER (buffer
));
2157 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only
,
2158 Sbarf_if_buffer_read_only
, 0, 1, 0,
2159 doc
: /* Signal a `buffer-read-only' error if the current buffer is read-only.
2160 If the text under POSITION (which defaults to point) has the
2161 `inhibit-read-only' text property set, the error will not be raised. */)
2165 XSETFASTINT (pos
, PT
);
2169 if (!NILP (BVAR (current_buffer
, read_only
))
2170 && NILP (Vinhibit_read_only
)
2171 && NILP (Fget_text_property (pos
, Qinhibit_read_only
, Qnil
)))
2172 xsignal1 (Qbuffer_read_only
, Fcurrent_buffer ());
2176 DEFUN ("erase-buffer", Ferase_buffer
, Serase_buffer
, 0, 0, "*",
2177 doc
: /* Delete the entire contents of the current buffer.
2178 Any narrowing restriction in effect (see `narrow-to-region') is removed,
2179 so the buffer is truly empty after this. */)
2186 current_buffer
->last_window_start
= 1;
2187 /* Prevent warnings, or suspension of auto saving, that would happen
2188 if future size is less than past size. Use of erase-buffer
2189 implies that the future text is not really related to the past text. */
2190 XSETFASTINT (BVAR (current_buffer
, save_length
), 0);
2195 validate_region (register Lisp_Object
*b
, register Lisp_Object
*e
)
2197 CHECK_NUMBER_COERCE_MARKER (*b
);
2198 CHECK_NUMBER_COERCE_MARKER (*e
);
2200 if (XINT (*b
) > XINT (*e
))
2203 tem
= *b
; *b
= *e
; *e
= tem
;
2206 if (! (BEGV
<= XINT (*b
) && XINT (*e
) <= ZV
))
2207 args_out_of_range_3 (Fcurrent_buffer (), *b
, *e
);
2210 /* Advance BYTE_POS up to a character boundary
2211 and return the adjusted position. */
2214 advance_to_char_boundary (ptrdiff_t byte_pos
)
2218 if (byte_pos
== BEG
)
2219 /* Beginning of buffer is always a character boundary. */
2222 c
= FETCH_BYTE (byte_pos
);
2223 if (! CHAR_HEAD_P (c
))
2225 /* We should advance BYTE_POS only when C is a constituent of a
2226 multibyte sequence. */
2227 ptrdiff_t orig_byte_pos
= byte_pos
;
2232 c
= FETCH_BYTE (byte_pos
);
2234 while (! CHAR_HEAD_P (c
) && byte_pos
> BEG
);
2236 if (byte_pos
< orig_byte_pos
)
2237 byte_pos
= orig_byte_pos
;
2238 /* If C is a constituent of a multibyte sequence, BYTE_POS was
2239 surely advance to the correct character boundary. If C is
2240 not, BYTE_POS was unchanged. */
2246 DEFUN ("buffer-swap-text", Fbuffer_swap_text
, Sbuffer_swap_text
,
2248 doc
: /* Swap the text between current buffer and BUFFER. */)
2249 (Lisp_Object buffer
)
2251 struct buffer
*other_buffer
;
2252 CHECK_BUFFER (buffer
);
2253 other_buffer
= XBUFFER (buffer
);
2255 if (!BUFFER_LIVE_P (other_buffer
))
2256 error ("Cannot swap a dead buffer's text");
2258 /* Actually, it probably works just fine.
2259 * if (other_buffer == current_buffer)
2260 * error ("Cannot swap a buffer's text with itself"); */
2262 /* Actually, this may be workable as well, tho probably only if they're
2264 if (other_buffer
->base_buffer
2265 || current_buffer
->base_buffer
)
2266 error ("Cannot swap indirect buffers's text");
2268 { /* This is probably harder to make work. */
2269 struct buffer
*other
;
2270 FOR_EACH_BUFFER (other
)
2271 if (other
->base_buffer
== other_buffer
2272 || other
->base_buffer
== current_buffer
)
2273 error ("One of the buffers to swap has indirect buffers");
2276 #define swapfield(field, type) \
2278 type tmp##field = other_buffer->field; \
2279 other_buffer->field = current_buffer->field; \
2280 current_buffer->field = tmp##field; \
2282 #define swapfield_(field, type) \
2284 type tmp##field = BVAR (other_buffer, field); \
2285 bset_##field (other_buffer, BVAR (current_buffer, field)); \
2286 bset_##field (current_buffer, tmp##field); \
2289 swapfield (own_text
, struct buffer_text
);
2290 eassert (current_buffer
->text
== ¤t_buffer
->own_text
);
2291 eassert (other_buffer
->text
== &other_buffer
->own_text
);
2293 r_alloc_reset_variable ((void **) ¤t_buffer
->own_text
.beg
,
2294 (void **) &other_buffer
->own_text
.beg
);
2295 r_alloc_reset_variable ((void **) &other_buffer
->own_text
.beg
,
2296 (void **) ¤t_buffer
->own_text
.beg
);
2297 #endif /* REL_ALLOC */
2299 swapfield (pt
, ptrdiff_t);
2300 swapfield (pt_byte
, ptrdiff_t);
2301 swapfield (begv
, ptrdiff_t);
2302 swapfield (begv_byte
, ptrdiff_t);
2303 swapfield (zv
, ptrdiff_t);
2304 swapfield (zv_byte
, ptrdiff_t);
2305 eassert (!current_buffer
->base_buffer
);
2306 eassert (!other_buffer
->base_buffer
);
2307 swapfield (indirections
, ptrdiff_t);
2308 current_buffer
->clip_changed
= 1; other_buffer
->clip_changed
= 1;
2309 swapfield (newline_cache
, struct region_cache
*);
2310 swapfield (width_run_cache
, struct region_cache
*);
2311 swapfield (bidi_paragraph_cache
, struct region_cache
*);
2312 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2313 other_buffer
->prevent_redisplay_optimizations_p
= 1;
2314 swapfield (overlays_before
, struct Lisp_Overlay
*);
2315 swapfield (overlays_after
, struct Lisp_Overlay
*);
2316 swapfield (overlay_center
, ptrdiff_t);
2317 swapfield_ (undo_list
, Lisp_Object
);
2318 swapfield_ (mark
, Lisp_Object
);
2319 swapfield_ (enable_multibyte_characters
, Lisp_Object
);
2320 swapfield_ (bidi_display_reordering
, Lisp_Object
);
2321 swapfield_ (bidi_paragraph_direction
, Lisp_Object
);
2322 /* FIXME: Not sure what we should do with these *_marker fields.
2323 Hopefully they're just nil anyway. */
2324 swapfield_ (pt_marker
, Lisp_Object
);
2325 swapfield_ (begv_marker
, Lisp_Object
);
2326 swapfield_ (zv_marker
, Lisp_Object
);
2327 bset_point_before_scroll (current_buffer
, Qnil
);
2328 bset_point_before_scroll (other_buffer
, Qnil
);
2330 current_buffer
->text
->modiff
++; other_buffer
->text
->modiff
++;
2331 current_buffer
->text
->chars_modiff
++; other_buffer
->text
->chars_modiff
++;
2332 current_buffer
->text
->overlay_modiff
++; other_buffer
->text
->overlay_modiff
++;
2333 current_buffer
->text
->beg_unchanged
= current_buffer
->text
->gpt
;
2334 current_buffer
->text
->end_unchanged
= current_buffer
->text
->gpt
;
2335 other_buffer
->text
->beg_unchanged
= other_buffer
->text
->gpt
;
2336 other_buffer
->text
->end_unchanged
= other_buffer
->text
->gpt
;
2338 struct Lisp_Marker
*m
;
2339 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
2340 if (m
->buffer
== other_buffer
)
2341 m
->buffer
= current_buffer
;
2343 /* Since there's no indirect buffer in sight, markers on
2344 BUF_MARKERS(buf) should either be for `buf' or dead. */
2345 eassert (!m
->buffer
);
2346 for (m
= BUF_MARKERS (other_buffer
); m
; m
= m
->next
)
2347 if (m
->buffer
== current_buffer
)
2348 m
->buffer
= other_buffer
;
2350 /* Since there's no indirect buffer in sight, markers on
2351 BUF_MARKERS(buf) should either be for `buf' or dead. */
2352 eassert (!m
->buffer
);
2354 { /* Some of the C code expects that both window markers of a
2355 live window points to that window's buffer. So since we
2356 just swapped the markers between the two buffers, we need
2357 to undo the effect of this swap for window markers. */
2358 Lisp_Object w
= selected_window
, ws
= Qnil
;
2359 Lisp_Object buf1
, buf2
;
2360 XSETBUFFER (buf1
, current_buffer
); XSETBUFFER (buf2
, other_buffer
);
2362 while (NILP (Fmemq (w
, ws
)))
2365 if (MARKERP (XWINDOW (w
)->pointm
)
2366 && (EQ (XWINDOW (w
)->contents
, buf1
)
2367 || EQ (XWINDOW (w
)->contents
, buf2
)))
2368 Fset_marker (XWINDOW (w
)->pointm
,
2370 (BUF_BEGV (XBUFFER (XWINDOW (w
)->contents
))),
2371 XWINDOW (w
)->contents
);
2372 /* Blindly copied from pointm part. */
2373 if (MARKERP (XWINDOW (w
)->old_pointm
)
2374 && (EQ (XWINDOW (w
)->contents
, buf1
)
2375 || EQ (XWINDOW (w
)->contents
, buf2
)))
2376 Fset_marker (XWINDOW (w
)->old_pointm
,
2378 (BUF_BEGV (XBUFFER (XWINDOW (w
)->contents
))),
2379 XWINDOW (w
)->contents
);
2380 if (MARKERP (XWINDOW (w
)->start
)
2381 && (EQ (XWINDOW (w
)->contents
, buf1
)
2382 || EQ (XWINDOW (w
)->contents
, buf2
)))
2383 Fset_marker (XWINDOW (w
)->start
,
2385 (XBUFFER (XWINDOW (w
)->contents
)->last_window_start
),
2386 XWINDOW (w
)->contents
);
2387 w
= Fnext_window (w
, Qt
, Qt
);
2391 if (current_buffer
->text
->intervals
)
2392 (eassert (EQ (current_buffer
->text
->intervals
->up
.obj
, buffer
)),
2393 XSETBUFFER (current_buffer
->text
->intervals
->up
.obj
, current_buffer
));
2394 if (other_buffer
->text
->intervals
)
2395 (eassert (EQ (other_buffer
->text
->intervals
->up
.obj
, Fcurrent_buffer ())),
2396 XSETBUFFER (other_buffer
->text
->intervals
->up
.obj
, other_buffer
));
2401 DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte
, Sset_buffer_multibyte
,
2403 doc
: /* Set the multibyte flag of the current buffer to FLAG.
2404 If FLAG is t, this makes the buffer a multibyte buffer.
2405 If FLAG is nil, this makes the buffer a single-byte buffer.
2406 In these cases, the buffer contents remain unchanged as a sequence of
2407 bytes but the contents viewed as characters do change.
2408 If FLAG is `to', this makes the buffer a multibyte buffer by changing
2409 all eight-bit bytes to eight-bit characters.
2410 If the multibyte flag was really changed, undo information of the
2411 current buffer is cleared. */)
2414 struct Lisp_Marker
*tail
, *markers
;
2415 struct buffer
*other
;
2417 bool narrowed
= (BEG
!= BEGV
|| Z
!= ZV
);
2418 bool modified_p
= !NILP (Fbuffer_modified_p (Qnil
));
2419 Lisp_Object old_undo
= BVAR (current_buffer
, undo_list
);
2420 struct gcpro gcpro1
;
2422 if (current_buffer
->base_buffer
)
2423 error ("Cannot do `set-buffer-multibyte' on an indirect buffer");
2425 /* Do nothing if nothing actually changes. */
2426 if (NILP (flag
) == NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
2431 /* Don't record these buffer changes. We will put a special undo entry
2433 bset_undo_list (current_buffer
, Qt
);
2435 /* If the cached position is for this buffer, clear it out. */
2436 clear_charpos_cache (current_buffer
);
2439 begv
= BEGV_BYTE
, zv
= ZV_BYTE
;
2441 begv
= BEGV
, zv
= ZV
;
2444 error ("Changing multibyteness in a narrowed buffer");
2446 invalidate_buffer_caches (current_buffer
, BEGV
, ZV
);
2450 ptrdiff_t pos
, stop
;
2453 /* Do this first, so it can use CHAR_TO_BYTE
2454 to calculate the old correspondences. */
2455 set_intervals_multibyte (0);
2457 bset_enable_multibyte_characters (current_buffer
, Qnil
);
2463 TEMP_SET_PT_BOTH (PT_BYTE
, PT_BYTE
);
2466 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
2467 tail
->charpos
= tail
->bytepos
;
2469 /* Convert multibyte form of 8-bit characters to unibyte. */
2484 if (ASCII_CHAR_P (*p
))
2486 else if (CHAR_BYTE8_HEAD_P (*p
))
2488 c
= STRING_CHAR_AND_LENGTH (p
, bytes
);
2489 /* Delete all bytes for this 8-bit character but the
2490 last one, and change the last one to the character
2493 del_range_2 (pos
, pos
, pos
+ bytes
, pos
+ bytes
, 0);
2505 bytes
= BYTES_BY_CHAR_HEAD (*p
);
2506 p
+= bytes
, pos
+= bytes
;
2510 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2515 ptrdiff_t pos
, stop
;
2516 unsigned char *p
, *pend
;
2518 /* Be sure not to have a multibyte sequence striding over the GAP.
2519 Ex: We change this: "...abc\302 _GAP_ \241def..."
2520 to: "...abc _GAP_ \302\241def..." */
2523 && GPT_BYTE
> 1 && GPT_BYTE
< Z_BYTE
2524 && ! CHAR_HEAD_P (*(GAP_END_ADDR
)))
2526 unsigned char *q
= GPT_ADDR
- 1;
2528 while (! CHAR_HEAD_P (*q
) && q
> BEG_ADDR
) q
--;
2529 if (LEADING_CODE_P (*q
))
2531 ptrdiff_t new_gpt
= GPT_BYTE
- (GPT_ADDR
- q
);
2533 move_gap_both (new_gpt
, new_gpt
);
2537 /* Make the buffer contents valid as multibyte by converting
2538 8-bit characters to multibyte form. */
2556 if (ASCII_CHAR_P (*p
))
2558 else if (EQ (flag
, Qt
)
2559 && ! CHAR_BYTE8_HEAD_P (*p
)
2560 && (bytes
= MULTIBYTE_LENGTH (p
, pend
)) > 0)
2561 p
+= bytes
, pos
+= bytes
;
2564 unsigned char tmp
[MAX_MULTIBYTE_LENGTH
];
2567 c
= BYTE8_TO_CHAR (*p
);
2568 bytes
= CHAR_STRING (c
, tmp
);
2570 TEMP_SET_PT_BOTH (pos
+ 1, pos
+ 1);
2572 insert_1_both ((char *) tmp
+ 1, bytes
, bytes
, 1, 0, 0);
2573 /* Now the gap is after the just inserted data. */
2591 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2593 /* Do this first, so that chars_in_text asks the right question.
2594 set_intervals_multibyte needs it too. */
2595 bset_enable_multibyte_characters (current_buffer
, Qt
);
2597 GPT_BYTE
= advance_to_char_boundary (GPT_BYTE
);
2598 GPT
= chars_in_text (BEG_ADDR
, GPT_BYTE
- BEG_BYTE
) + BEG
;
2600 Z
= chars_in_text (GAP_END_ADDR
, Z_BYTE
- GPT_BYTE
) + GPT
;
2602 BEGV_BYTE
= advance_to_char_boundary (BEGV_BYTE
);
2603 if (BEGV_BYTE
> GPT_BYTE
)
2604 BEGV
= chars_in_text (GAP_END_ADDR
, BEGV_BYTE
- GPT_BYTE
) + GPT
;
2606 BEGV
= chars_in_text (BEG_ADDR
, BEGV_BYTE
- BEG_BYTE
) + BEG
;
2608 ZV_BYTE
= advance_to_char_boundary (ZV_BYTE
);
2609 if (ZV_BYTE
> GPT_BYTE
)
2610 ZV
= chars_in_text (GAP_END_ADDR
, ZV_BYTE
- GPT_BYTE
) + GPT
;
2612 ZV
= chars_in_text (BEG_ADDR
, ZV_BYTE
- BEG_BYTE
) + BEG
;
2615 ptrdiff_t byte
= advance_to_char_boundary (PT_BYTE
);
2618 if (byte
> GPT_BYTE
)
2619 position
= chars_in_text (GAP_END_ADDR
, byte
- GPT_BYTE
) + GPT
;
2621 position
= chars_in_text (BEG_ADDR
, byte
- BEG_BYTE
) + BEG
;
2622 TEMP_SET_PT_BOTH (position
, byte
);
2625 tail
= markers
= BUF_MARKERS (current_buffer
);
2627 /* This prevents BYTE_TO_CHAR (that is, buf_bytepos_to_charpos) from
2628 getting confused by the markers that have not yet been updated.
2629 It is also a signal that it should never create a marker. */
2630 BUF_MARKERS (current_buffer
) = NULL
;
2632 for (; tail
; tail
= tail
->next
)
2634 tail
->bytepos
= advance_to_char_boundary (tail
->bytepos
);
2635 tail
->charpos
= BYTE_TO_CHAR (tail
->bytepos
);
2638 /* Make sure no markers were put on the chain
2639 while the chain value was incorrect. */
2640 if (BUF_MARKERS (current_buffer
))
2643 BUF_MARKERS (current_buffer
) = markers
;
2645 /* Do this last, so it can calculate the new correspondences
2646 between chars and bytes. */
2647 set_intervals_multibyte (1);
2650 if (!EQ (old_undo
, Qt
))
2652 /* Represent all the above changes by a special undo entry. */
2653 bset_undo_list (current_buffer
,
2654 Fcons (list3 (Qapply
,
2655 intern ("set-buffer-multibyte"),
2656 NILP (flag
) ? Qt
: Qnil
),
2662 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2664 /* If buffer is shown in a window, let redisplay consider other windows. */
2665 if (buffer_window_count (current_buffer
))
2666 windows_or_buffers_changed
= 10;
2668 /* Copy this buffer's new multibyte status
2669 into all of its indirect buffers. */
2670 FOR_EACH_BUFFER (other
)
2671 if (other
->base_buffer
== current_buffer
&& BUFFER_LIVE_P (other
))
2673 BVAR (other
, enable_multibyte_characters
)
2674 = BVAR (current_buffer
, enable_multibyte_characters
);
2675 other
->prevent_redisplay_optimizations_p
= 1;
2678 /* Restore the modifiedness of the buffer. */
2679 if (!modified_p
&& !NILP (Fbuffer_modified_p (Qnil
)))
2680 Fset_buffer_modified_p (Qnil
);
2682 /* Update coding systems of this buffer's process (if any). */
2684 Lisp_Object process
;
2686 process
= Fget_buffer_process (Fcurrent_buffer ());
2687 if (PROCESSP (process
))
2688 setup_process_coding_systems (process
);
2694 DEFUN ("kill-all-local-variables", Fkill_all_local_variables
,
2695 Skill_all_local_variables
, 0, 0, 0,
2696 doc
: /* Switch to Fundamental mode by killing current buffer's local variables.
2697 Most local variable bindings are eliminated so that the default values
2698 become effective once more. Also, the syntax table is set from
2699 `standard-syntax-table', the local keymap is set to nil,
2700 and the abbrev table from `fundamental-mode-abbrev-table'.
2701 This function also forces redisplay of the mode line.
2703 Every function to select a new major mode starts by
2704 calling this function.
2706 As a special exception, local variables whose names have
2707 a non-nil `permanent-local' property are not eliminated by this function.
2709 The first thing this function does is run
2710 the normal hook `change-major-mode-hook'. */)
2713 run_hook (Qchange_major_mode_hook
);
2715 /* Make sure none of the bindings in local_var_alist
2716 remain swapped in, in their symbols. */
2718 swap_out_buffer_local_variables (current_buffer
);
2720 /* Actually eliminate all local bindings of this buffer. */
2722 reset_buffer_local_variables (current_buffer
, 0);
2724 /* Force mode-line redisplay. Useful here because all major mode
2725 commands call this function. */
2726 update_mode_lines
= 12;
2731 /* Make sure no local variables remain set up with buffer B
2732 for their current values. */
2735 swap_out_buffer_local_variables (struct buffer
*b
)
2737 Lisp_Object oalist
, alist
, buffer
;
2739 XSETBUFFER (buffer
, b
);
2740 oalist
= BVAR (b
, local_var_alist
);
2742 for (alist
= oalist
; CONSP (alist
); alist
= XCDR (alist
))
2744 Lisp_Object sym
= XCAR (XCAR (alist
));
2745 eassert (XSYMBOL (sym
)->redirect
== SYMBOL_LOCALIZED
);
2746 /* Need not do anything if some other buffer's binding is
2748 if (EQ (SYMBOL_BLV (XSYMBOL (sym
))->where
, buffer
))
2750 /* Symbol is set up for this buffer's old local value:
2752 swap_in_global_binding (XSYMBOL (sym
));
2757 /* Find all the overlays in the current buffer that contain position POS.
2758 Return the number found, and store them in a vector in *VEC_PTR.
2759 Store in *LEN_PTR the size allocated for the vector.
2760 Store in *NEXT_PTR the next position after POS where an overlay starts,
2761 or ZV if there are no more overlays between POS and ZV.
2762 Store in *PREV_PTR the previous position before POS where an overlay ends,
2763 or where an overlay starts which ends at or after POS;
2764 or BEGV if there are no such overlays from BEGV to POS.
2765 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2767 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2768 when this function is called.
2770 If EXTEND, make the vector bigger if necessary.
2771 If not, never extend the vector,
2772 and store only as many overlays as will fit.
2773 But still return the total number of overlays.
2775 If CHANGE_REQ, any position written into *PREV_PTR or
2776 *NEXT_PTR is guaranteed to be not equal to POS, unless it is the
2777 default (BEGV or ZV). */
2780 overlays_at (EMACS_INT pos
, bool extend
, Lisp_Object
**vec_ptr
,
2782 ptrdiff_t *next_ptr
, ptrdiff_t *prev_ptr
, bool change_req
)
2784 Lisp_Object overlay
, start
, end
;
2785 struct Lisp_Overlay
*tail
;
2787 ptrdiff_t len
= *len_ptr
;
2788 Lisp_Object
*vec
= *vec_ptr
;
2789 ptrdiff_t next
= ZV
;
2790 ptrdiff_t prev
= BEGV
;
2791 bool inhibit_storing
= 0;
2793 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2795 ptrdiff_t startpos
, endpos
;
2797 XSETMISC (overlay
, tail
);
2799 start
= OVERLAY_START (overlay
);
2800 end
= OVERLAY_END (overlay
);
2801 endpos
= OVERLAY_POSITION (end
);
2808 startpos
= OVERLAY_POSITION (start
);
2809 /* This one ends at or after POS
2810 so its start counts for PREV_PTR if it's before POS. */
2811 if (prev
< startpos
&& startpos
< pos
)
2815 if (startpos
<= pos
)
2819 /* The supplied vector is full.
2820 Either make it bigger, or don't store any more in it. */
2823 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2829 inhibit_storing
= 1;
2832 if (!inhibit_storing
)
2834 /* Keep counting overlays even if we can't return them all. */
2837 else if (startpos
< next
)
2841 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2843 ptrdiff_t startpos
, endpos
;
2845 XSETMISC (overlay
, tail
);
2847 start
= OVERLAY_START (overlay
);
2848 end
= OVERLAY_END (overlay
);
2849 startpos
= OVERLAY_POSITION (start
);
2852 if (startpos
< next
)
2856 endpos
= OVERLAY_POSITION (end
);
2863 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2869 inhibit_storing
= 1;
2872 if (!inhibit_storing
)
2876 if (startpos
< pos
&& startpos
> prev
)
2879 else if (endpos
< pos
&& endpos
> prev
)
2881 else if (endpos
== pos
&& startpos
> prev
2882 && (!change_req
|| startpos
< pos
))
2893 /* Find all the overlays in the current buffer that overlap the range
2894 BEG-END, or are empty at BEG, or are empty at END provided END
2895 denotes the position at the end of the current buffer.
2897 Return the number found, and store them in a vector in *VEC_PTR.
2898 Store in *LEN_PTR the size allocated for the vector.
2899 Store in *NEXT_PTR the next position after POS where an overlay starts,
2900 or ZV if there are no more overlays.
2901 Store in *PREV_PTR the previous position before POS where an overlay ends,
2902 or BEGV if there are no previous overlays.
2903 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2905 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2906 when this function is called.
2908 If EXTEND, make the vector bigger if necessary.
2909 If not, never extend the vector,
2910 and store only as many overlays as will fit.
2911 But still return the total number of overlays. */
2914 overlays_in (EMACS_INT beg
, EMACS_INT end
, bool extend
,
2915 Lisp_Object
**vec_ptr
, ptrdiff_t *len_ptr
,
2916 ptrdiff_t *next_ptr
, ptrdiff_t *prev_ptr
)
2918 Lisp_Object overlay
, ostart
, oend
;
2919 struct Lisp_Overlay
*tail
;
2921 ptrdiff_t len
= *len_ptr
;
2922 Lisp_Object
*vec
= *vec_ptr
;
2923 ptrdiff_t next
= ZV
;
2924 ptrdiff_t prev
= BEGV
;
2925 bool inhibit_storing
= 0;
2926 bool end_is_Z
= end
== Z
;
2928 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2930 ptrdiff_t startpos
, endpos
;
2932 XSETMISC (overlay
, tail
);
2934 ostart
= OVERLAY_START (overlay
);
2935 oend
= OVERLAY_END (overlay
);
2936 endpos
= OVERLAY_POSITION (oend
);
2943 startpos
= OVERLAY_POSITION (ostart
);
2944 /* Count an interval if it overlaps the range, is empty at the
2945 start of the range, or is empty at END provided END denotes the
2946 end of the buffer. */
2947 if ((beg
< endpos
&& startpos
< end
)
2948 || (startpos
== endpos
2949 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
2953 /* The supplied vector is full.
2954 Either make it bigger, or don't store any more in it. */
2957 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2963 inhibit_storing
= 1;
2966 if (!inhibit_storing
)
2968 /* Keep counting overlays even if we can't return them all. */
2971 else if (startpos
< next
)
2975 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2977 ptrdiff_t startpos
, endpos
;
2979 XSETMISC (overlay
, tail
);
2981 ostart
= OVERLAY_START (overlay
);
2982 oend
= OVERLAY_END (overlay
);
2983 startpos
= OVERLAY_POSITION (ostart
);
2986 if (startpos
< next
)
2990 endpos
= OVERLAY_POSITION (oend
);
2991 /* Count an interval if it overlaps the range, is empty at the
2992 start of the range, or is empty at END provided END denotes the
2993 end of the buffer. */
2994 if ((beg
< endpos
&& startpos
< end
)
2995 || (startpos
== endpos
2996 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
3002 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
3008 inhibit_storing
= 1;
3011 if (!inhibit_storing
)
3015 else if (endpos
< beg
&& endpos
> prev
)
3027 /* Return true if there exists an overlay with a non-nil
3028 `mouse-face' property overlapping OVERLAY. */
3031 mouse_face_overlay_overlaps (Lisp_Object overlay
)
3033 ptrdiff_t start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3034 ptrdiff_t end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3035 ptrdiff_t n
, i
, size
;
3036 Lisp_Object
*v
, tem
;
3037 Lisp_Object vbuf
[10];
3040 size
= ARRAYELTS (vbuf
);
3042 n
= overlays_in (start
, end
, 0, &v
, &size
, NULL
, NULL
);
3045 SAFE_NALLOCA (v
, 1, n
);
3046 overlays_in (start
, end
, 0, &v
, &n
, NULL
, NULL
);
3049 for (i
= 0; i
< n
; ++i
)
3050 if (!EQ (v
[i
], overlay
)
3051 && (tem
= Foverlay_get (overlay
, Qmouse_face
),
3061 /* Fast function to just test if we're at an overlay boundary. */
3063 overlay_touches_p (ptrdiff_t pos
)
3065 Lisp_Object overlay
;
3066 struct Lisp_Overlay
*tail
;
3068 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
3072 XSETMISC (overlay
,tail
);
3073 eassert (OVERLAYP (overlay
));
3075 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3078 if (endpos
== pos
|| OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
)
3082 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
3086 XSETMISC (overlay
, tail
);
3087 eassert (OVERLAYP (overlay
));
3089 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3092 if (startpos
== pos
|| OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
)
3100 Lisp_Object overlay
;
3103 EMACS_INT spriority
; /* Secondary priority. */
3107 compare_overlays (const void *v1
, const void *v2
)
3109 const struct sortvec
*s1
= v1
;
3110 const struct sortvec
*s2
= v2
;
3111 /* Return 1 if s1 should take precedence, -1 if v2 should take precedence,
3112 and 0 if they're equal. */
3113 if (s1
->priority
!= s2
->priority
)
3114 return s1
->priority
< s2
->priority
? -1 : 1;
3115 /* If the priority is equal, give precedence to the one not covered by the
3116 other. If neither covers the other, obey spriority. */
3117 else if (s1
->beg
< s2
->beg
)
3118 return (s1
->end
< s2
->end
&& s1
->spriority
> s2
->spriority
? 1 : -1);
3119 else if (s1
->beg
> s2
->beg
)
3120 return (s1
->end
> s2
->end
&& s1
->spriority
< s2
->spriority
? -1 : 1);
3121 else if (s1
->end
!= s2
->end
)
3122 return s2
->end
< s1
->end
? -1 : 1;
3123 else if (s1
->spriority
!= s2
->spriority
)
3124 return (s1
->spriority
< s2
->spriority
? -1 : 1);
3125 else if (EQ (s1
->overlay
, s2
->overlay
))
3128 /* Avoid the non-determinism of qsort by choosing an arbitrary ordering
3129 between "equal" overlays. The result can still change between
3130 invocations of Emacs, but it won't change in the middle of
3131 `find_field' (bug#6830). */
3132 return XLI (s1
->overlay
) < XLI (s2
->overlay
) ? -1 : 1;
3135 /* Sort an array of overlays by priority. The array is modified in place.
3136 The return value is the new size; this may be smaller than the original
3137 size if some of the overlays were invalid or were window-specific. */
3139 sort_overlays (Lisp_Object
*overlay_vec
, ptrdiff_t noverlays
, struct window
*w
)
3143 struct sortvec
*sortvec
;
3145 SAFE_NALLOCA (sortvec
, 1, noverlays
);
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
);
3177 sortvec
[j
].priority
= 0;
3178 sortvec
[j
].spriority
= 0;
3180 else if (INTEGERP (tem
))
3182 sortvec
[j
].priority
= XINT (tem
);
3183 sortvec
[j
].spriority
= 0;
3185 else if (CONSP (tem
))
3187 Lisp_Object car
= XCAR (tem
);
3188 Lisp_Object cdr
= XCDR (tem
);
3189 sortvec
[j
].priority
= INTEGERP (car
) ? XINT (car
) : 0;
3190 sortvec
[j
].spriority
= INTEGERP (cdr
) ? XINT (cdr
) : 0;
3197 /* Sort the overlays into the proper order: increasing priority. */
3200 qsort (sortvec
, noverlays
, sizeof (struct sortvec
), compare_overlays
);
3202 for (i
= 0; i
< noverlays
; i
++)
3203 overlay_vec
[i
] = sortvec
[i
].overlay
;
3211 Lisp_Object string
, string2
;
3218 struct sortstr
*buf
; /* An array that expands as needed; never freed. */
3219 ptrdiff_t size
; /* Allocated length of that array. */
3220 ptrdiff_t used
; /* How much of the array is currently in use. */
3221 ptrdiff_t bytes
; /* Total length of the strings in buf. */
3224 /* Buffers for storing information about the overlays touching a given
3225 position. These could be automatic variables in overlay_strings, but
3226 it's more efficient to hold onto the memory instead of repeatedly
3227 allocating and freeing it. */
3228 static struct sortstrlist overlay_heads
, overlay_tails
;
3229 static unsigned char *overlay_str_buf
;
3231 /* Allocated length of overlay_str_buf. */
3232 static ptrdiff_t overlay_str_len
;
3234 /* A comparison function suitable for passing to qsort. */
3236 cmp_for_strings (const void *as1
, const void *as2
)
3238 struct sortstr
const *s1
= as1
;
3239 struct sortstr
const *s2
= as2
;
3240 if (s1
->size
!= s2
->size
)
3241 return s2
->size
< s1
->size
? -1 : 1;
3242 if (s1
->priority
!= s2
->priority
)
3243 return s1
->priority
< s2
->priority
? -1 : 1;
3248 record_overlay_string (struct sortstrlist
*ssl
, Lisp_Object str
,
3249 Lisp_Object str2
, Lisp_Object pri
, ptrdiff_t size
)
3253 if (ssl
->used
== ssl
->size
)
3254 ssl
->buf
= xpalloc (ssl
->buf
, &ssl
->size
, 5, -1, sizeof *ssl
->buf
);
3255 ssl
->buf
[ssl
->used
].string
= str
;
3256 ssl
->buf
[ssl
->used
].string2
= str2
;
3257 ssl
->buf
[ssl
->used
].size
= size
;
3258 ssl
->buf
[ssl
->used
].priority
= (INTEGERP (pri
) ? XINT (pri
) : 0);
3261 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3262 nbytes
= SCHARS (str
);
3263 else if (! STRING_MULTIBYTE (str
))
3264 nbytes
= count_size_as_multibyte (SDATA (str
),
3267 nbytes
= SBYTES (str
);
3269 if (INT_ADD_OVERFLOW (ssl
->bytes
, nbytes
))
3270 memory_full (SIZE_MAX
);
3271 ssl
->bytes
+= nbytes
;
3275 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3276 nbytes
= SCHARS (str2
);
3277 else if (! STRING_MULTIBYTE (str2
))
3278 nbytes
= count_size_as_multibyte (SDATA (str2
),
3281 nbytes
= SBYTES (str2
);
3283 if (INT_ADD_OVERFLOW (ssl
->bytes
, nbytes
))
3284 memory_full (SIZE_MAX
);
3285 ssl
->bytes
+= nbytes
;
3289 /* Concatenate the strings associated with overlays that begin or end
3290 at POS, ignoring overlays that are specific to windows other than W.
3291 The strings are concatenated in the appropriate order: shorter
3292 overlays nest inside longer ones, and higher priority inside lower.
3293 Normally all of the after-strings come first, but zero-sized
3294 overlays have their after-strings ride along with the
3295 before-strings because it would look strange to print them
3298 Returns the concatenated string's length, and return the pointer to
3299 that string via PSTR, if that variable is non-NULL. The storage of
3300 the concatenated strings may be overwritten by subsequent calls. */
3303 overlay_strings (ptrdiff_t pos
, struct window
*w
, unsigned char **pstr
)
3305 Lisp_Object overlay
, window
, str
;
3306 struct Lisp_Overlay
*ov
;
3307 ptrdiff_t startpos
, endpos
;
3308 bool multibyte
= ! NILP (BVAR (current_buffer
, enable_multibyte_characters
));
3310 overlay_heads
.used
= overlay_heads
.bytes
= 0;
3311 overlay_tails
.used
= overlay_tails
.bytes
= 0;
3312 for (ov
= current_buffer
->overlays_before
; ov
; ov
= ov
->next
)
3314 XSETMISC (overlay
, ov
);
3315 eassert (OVERLAYP (overlay
));
3317 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3318 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3321 if (endpos
!= pos
&& startpos
!= pos
)
3323 window
= Foverlay_get (overlay
, Qwindow
);
3324 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3327 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3328 record_overlay_string (&overlay_heads
, str
,
3330 ? Foverlay_get (overlay
, Qafter_string
)
3332 Foverlay_get (overlay
, Qpriority
),
3334 else if (endpos
== pos
3335 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3336 record_overlay_string (&overlay_tails
, str
, Qnil
,
3337 Foverlay_get (overlay
, Qpriority
),
3340 for (ov
= current_buffer
->overlays_after
; ov
; ov
= ov
->next
)
3342 XSETMISC (overlay
, ov
);
3343 eassert (OVERLAYP (overlay
));
3345 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3346 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3349 if (endpos
!= pos
&& startpos
!= pos
)
3351 window
= Foverlay_get (overlay
, Qwindow
);
3352 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3355 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3356 record_overlay_string (&overlay_heads
, str
,
3358 ? Foverlay_get (overlay
, Qafter_string
)
3360 Foverlay_get (overlay
, Qpriority
),
3362 else if (endpos
== pos
3363 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3364 record_overlay_string (&overlay_tails
, str
, Qnil
,
3365 Foverlay_get (overlay
, Qpriority
),
3368 if (overlay_tails
.used
> 1)
3369 qsort (overlay_tails
.buf
, overlay_tails
.used
, sizeof (struct sortstr
),
3371 if (overlay_heads
.used
> 1)
3372 qsort (overlay_heads
.buf
, overlay_heads
.used
, sizeof (struct sortstr
),
3374 if (overlay_heads
.bytes
|| overlay_tails
.bytes
)
3381 if (INT_ADD_OVERFLOW (overlay_heads
.bytes
, overlay_tails
.bytes
))
3382 memory_full (SIZE_MAX
);
3383 total
= overlay_heads
.bytes
+ overlay_tails
.bytes
;
3384 if (total
> overlay_str_len
)
3385 overlay_str_buf
= xpalloc (overlay_str_buf
, &overlay_str_len
,
3386 total
- overlay_str_len
, -1, 1);
3388 p
= overlay_str_buf
;
3389 for (i
= overlay_tails
.used
; --i
>= 0;)
3392 tem
= overlay_tails
.buf
[i
].string
;
3393 nbytes
= copy_text (SDATA (tem
), p
,
3395 STRING_MULTIBYTE (tem
), multibyte
);
3398 for (i
= 0; i
< overlay_heads
.used
; ++i
)
3401 tem
= overlay_heads
.buf
[i
].string
;
3402 nbytes
= copy_text (SDATA (tem
), p
,
3404 STRING_MULTIBYTE (tem
), multibyte
);
3406 tem
= overlay_heads
.buf
[i
].string2
;
3409 nbytes
= copy_text (SDATA (tem
), p
,
3411 STRING_MULTIBYTE (tem
), multibyte
);
3415 if (p
!= overlay_str_buf
+ total
)
3418 *pstr
= overlay_str_buf
;
3424 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
3427 recenter_overlay_lists (struct buffer
*buf
, ptrdiff_t pos
)
3429 Lisp_Object overlay
, beg
, end
;
3430 struct Lisp_Overlay
*prev
, *tail
, *next
;
3432 /* See if anything in overlays_before should move to overlays_after. */
3434 /* We don't strictly need prev in this loop; it should always be nil.
3435 But we use it for symmetry and in case that should cease to be true
3436 with some future change. */
3438 for (tail
= buf
->overlays_before
; tail
; prev
= tail
, tail
= next
)
3441 XSETMISC (overlay
, tail
);
3442 eassert (OVERLAYP (overlay
));
3444 beg
= OVERLAY_START (overlay
);
3445 end
= OVERLAY_END (overlay
);
3447 if (OVERLAY_POSITION (end
) > pos
)
3449 /* OVERLAY needs to be moved. */
3450 ptrdiff_t where
= OVERLAY_POSITION (beg
);
3451 struct Lisp_Overlay
*other
, *other_prev
;
3453 /* Splice the cons cell TAIL out of overlays_before. */
3457 set_buffer_overlays_before (buf
, next
);
3459 /* Search thru overlays_after for where to put it. */
3461 for (other
= buf
->overlays_after
; other
;
3462 other_prev
= other
, other
= other
->next
)
3464 Lisp_Object otherbeg
, otheroverlay
;
3466 XSETMISC (otheroverlay
, other
);
3467 eassert (OVERLAYP (otheroverlay
));
3469 otherbeg
= OVERLAY_START (otheroverlay
);
3470 if (OVERLAY_POSITION (otherbeg
) >= where
)
3474 /* Add TAIL to overlays_after before OTHER. */
3477 other_prev
->next
= tail
;
3479 set_buffer_overlays_after (buf
, tail
);
3483 /* We've reached the things that should stay in overlays_before.
3484 All the rest of overlays_before must end even earlier,
3489 /* See if anything in overlays_after should be in overlays_before. */
3491 for (tail
= buf
->overlays_after
; tail
; prev
= tail
, tail
= next
)
3494 XSETMISC (overlay
, tail
);
3495 eassert (OVERLAYP (overlay
));
3497 beg
= OVERLAY_START (overlay
);
3498 end
= OVERLAY_END (overlay
);
3500 /* Stop looking, when we know that nothing further
3501 can possibly end before POS. */
3502 if (OVERLAY_POSITION (beg
) > pos
)
3505 if (OVERLAY_POSITION (end
) <= pos
)
3507 /* OVERLAY needs to be moved. */
3508 ptrdiff_t where
= OVERLAY_POSITION (end
);
3509 struct Lisp_Overlay
*other
, *other_prev
;
3511 /* Splice the cons cell TAIL out of overlays_after. */
3515 set_buffer_overlays_after (buf
, next
);
3517 /* Search thru overlays_before for where to put it. */
3519 for (other
= buf
->overlays_before
; other
;
3520 other_prev
= other
, other
= other
->next
)
3522 Lisp_Object otherend
, otheroverlay
;
3524 XSETMISC (otheroverlay
, other
);
3525 eassert (OVERLAYP (otheroverlay
));
3527 otherend
= OVERLAY_END (otheroverlay
);
3528 if (OVERLAY_POSITION (otherend
) <= where
)
3532 /* Add TAIL to overlays_before before OTHER. */
3535 other_prev
->next
= tail
;
3537 set_buffer_overlays_before (buf
, tail
);
3542 buf
->overlay_center
= pos
;
3546 adjust_overlays_for_insert (ptrdiff_t pos
, ptrdiff_t length
)
3548 /* After an insertion, the lists are still sorted properly,
3549 but we may need to update the value of the overlay center. */
3550 if (current_buffer
->overlay_center
>= pos
)
3551 current_buffer
->overlay_center
+= length
;
3555 adjust_overlays_for_delete (ptrdiff_t pos
, ptrdiff_t length
)
3557 if (current_buffer
->overlay_center
< pos
)
3558 /* The deletion was to our right. No change needed; the before- and
3559 after-lists are still consistent. */
3561 else if (current_buffer
->overlay_center
- pos
> length
)
3562 /* The deletion was to our left. We need to adjust the center value
3563 to account for the change in position, but the lists are consistent
3564 given the new value. */
3565 current_buffer
->overlay_center
-= length
;
3567 /* We're right in the middle. There might be things on the after-list
3568 that now belong on the before-list. Recentering will move them,
3569 and also update the center point. */
3570 recenter_overlay_lists (current_buffer
, pos
);
3573 /* Fix up overlays that were garbled as a result of permuting markers
3574 in the range START through END. Any overlay with at least one
3575 endpoint in this range will need to be unlinked from the overlay
3576 list and reinserted in its proper place.
3577 Such an overlay might even have negative size at this point.
3578 If so, we'll make the overlay empty. */
3580 fix_start_end_in_overlays (register ptrdiff_t start
, register ptrdiff_t end
)
3582 Lisp_Object overlay
;
3583 struct Lisp_Overlay
*before_list
IF_LINT (= NULL
);
3584 struct Lisp_Overlay
*after_list
IF_LINT (= NULL
);
3585 /* These are either nil, indicating that before_list or after_list
3586 should be assigned, or the cons cell the cdr of which should be
3588 struct Lisp_Overlay
*beforep
= NULL
, *afterp
= NULL
;
3589 /* 'Parent', likewise, indicates a cons cell or
3590 current_buffer->overlays_before or overlays_after, depending
3591 which loop we're in. */
3592 struct Lisp_Overlay
*tail
, *parent
;
3593 ptrdiff_t startpos
, endpos
;
3595 /* This algorithm shifts links around instead of consing and GCing.
3596 The loop invariant is that before_list (resp. after_list) is a
3597 well-formed list except that its last element, the CDR of beforep
3598 (resp. afterp) if beforep (afterp) isn't nil or before_list
3599 (after_list) if it is, is still uninitialized. So it's not a bug
3600 that before_list isn't initialized, although it may look
3602 for (parent
= NULL
, tail
= current_buffer
->overlays_before
; tail
;)
3604 XSETMISC (overlay
, tail
);
3606 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3607 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3609 /* If the overlay is backwards, make it empty. */
3610 if (endpos
< startpos
)
3613 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3621 || (startpos
>= start
&& startpos
< end
))
3623 /* Add it to the end of the wrong list. Later on,
3624 recenter_overlay_lists will move it to the right place. */
3625 if (endpos
< current_buffer
->overlay_center
)
3630 afterp
->next
= tail
;
3638 beforep
->next
= tail
;
3642 set_buffer_overlays_before (current_buffer
, tail
->next
);
3644 parent
->next
= tail
->next
;
3648 parent
= tail
, tail
= parent
->next
;
3650 for (parent
= NULL
, tail
= current_buffer
->overlays_after
; tail
;)
3652 XSETMISC (overlay
, tail
);
3654 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3655 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3657 /* If the overlay is backwards, make it empty. */
3658 if (endpos
< startpos
)
3661 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3665 if (startpos
>= end
)
3668 if (startpos
>= start
3669 || (endpos
>= start
&& endpos
< end
))
3671 if (endpos
< current_buffer
->overlay_center
)
3676 afterp
->next
= tail
;
3684 beforep
->next
= tail
;
3688 set_buffer_overlays_after (current_buffer
, tail
->next
);
3690 parent
->next
= tail
->next
;
3694 parent
= tail
, tail
= parent
->next
;
3697 /* Splice the constructed (wrong) lists into the buffer's lists,
3698 and let the recenter function make it sane again. */
3701 beforep
->next
= current_buffer
->overlays_before
;
3702 set_buffer_overlays_before (current_buffer
, before_list
);
3707 afterp
->next
= current_buffer
->overlays_after
;
3708 set_buffer_overlays_after (current_buffer
, after_list
);
3710 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3713 /* We have two types of overlay: the one whose ending marker is
3714 after-insertion-marker (this is the usual case) and the one whose
3715 ending marker is before-insertion-marker. When `overlays_before'
3716 contains overlays of the latter type and the former type in this
3717 order and both overlays end at inserting position, inserting a text
3718 increases only the ending marker of the latter type, which results
3719 in incorrect ordering of `overlays_before'.
3721 This function fixes ordering of overlays in the slot
3722 `overlays_before' of the buffer *BP. Before the insertion, `point'
3723 was at PREV, and now is at POS. */
3726 fix_overlays_before (struct buffer
*bp
, ptrdiff_t prev
, ptrdiff_t pos
)
3728 /* If parent is nil, replace overlays_before; otherwise, parent->next. */
3729 struct Lisp_Overlay
*tail
= bp
->overlays_before
, *parent
= NULL
, *right_pair
;
3731 ptrdiff_t end
IF_LINT (= 0);
3733 /* After the insertion, the several overlays may be in incorrect
3734 order. The possibility is that, in the list `overlays_before',
3735 an overlay which ends at POS appears after an overlay which ends
3736 at PREV. Since POS is greater than PREV, we must fix the
3737 ordering of these overlays, by moving overlays ends at POS before
3738 the overlays ends at PREV. */
3740 /* At first, find a place where disordered overlays should be linked
3741 in. It is where an overlay which end before POS exists. (i.e. an
3742 overlay whose ending marker is after-insertion-marker if disorder
3745 && (XSETMISC (tem
, tail
),
3746 (end
= OVERLAY_POSITION (OVERLAY_END (tem
))) >= pos
))
3752 /* If we don't find such an overlay,
3753 or the found one ends before PREV,
3754 or the found one is the last one in the list,
3755 we don't have to fix anything. */
3756 if (!tail
|| end
< prev
|| !tail
->next
)
3759 right_pair
= parent
;
3763 /* Now, end position of overlays in the list TAIL should be before
3764 or equal to PREV. In the loop, an overlay which ends at POS is
3765 moved ahead to the place indicated by the CDR of RIGHT_PAIR. If
3766 we found an overlay which ends before PREV, the remaining
3767 overlays are in correct order. */
3770 XSETMISC (tem
, tail
);
3771 end
= OVERLAY_POSITION (OVERLAY_END (tem
));
3774 { /* This overlay is disordered. */
3775 struct Lisp_Overlay
*found
= tail
;
3777 /* Unlink the found overlay. */
3779 parent
->next
= tail
;
3780 /* Move an overlay at RIGHT_PLACE to the next of the found one,
3781 and link it into the right place. */
3784 found
->next
= bp
->overlays_before
;
3785 set_buffer_overlays_before (bp
, found
);
3789 found
->next
= right_pair
->next
;
3790 right_pair
->next
= found
;
3793 else if (end
== prev
)
3798 else /* No more disordered overlay. */
3803 DEFUN ("overlayp", Foverlayp
, Soverlayp
, 1, 1, 0,
3804 doc
: /* Return t if OBJECT is an overlay. */)
3805 (Lisp_Object object
)
3807 return (OVERLAYP (object
) ? Qt
: Qnil
);
3810 DEFUN ("make-overlay", Fmake_overlay
, Smake_overlay
, 2, 5, 0,
3811 doc
: /* Create a new overlay with range BEG to END in BUFFER and return it.
3812 If omitted, BUFFER defaults to the current buffer.
3813 BEG and END may be integers or markers.
3814 The fourth arg FRONT-ADVANCE, if non-nil, makes the marker
3815 for the front of the overlay advance when text is inserted there
3816 \(which means the text *is not* included in the overlay).
3817 The fifth arg REAR-ADVANCE, if non-nil, makes the marker
3818 for the rear of the overlay advance when text is inserted there
3819 \(which means the text *is* included in the overlay). */)
3820 (Lisp_Object beg
, Lisp_Object end
, Lisp_Object buffer
,
3821 Lisp_Object front_advance
, Lisp_Object rear_advance
)
3823 Lisp_Object overlay
;
3827 XSETBUFFER (buffer
, current_buffer
);
3829 CHECK_BUFFER (buffer
);
3831 if (MARKERP (beg
) && !EQ (Fmarker_buffer (beg
), buffer
))
3832 signal_error ("Marker points into wrong buffer", beg
);
3833 if (MARKERP (end
) && !EQ (Fmarker_buffer (end
), buffer
))
3834 signal_error ("Marker points into wrong buffer", end
);
3836 CHECK_NUMBER_COERCE_MARKER (beg
);
3837 CHECK_NUMBER_COERCE_MARKER (end
);
3839 if (XINT (beg
) > XINT (end
))
3842 temp
= beg
; beg
= end
; end
= temp
;
3845 b
= XBUFFER (buffer
);
3847 beg
= Fset_marker (Fmake_marker (), beg
, buffer
);
3848 end
= Fset_marker (Fmake_marker (), end
, buffer
);
3850 if (!NILP (front_advance
))
3851 XMARKER (beg
)->insertion_type
= 1;
3852 if (!NILP (rear_advance
))
3853 XMARKER (end
)->insertion_type
= 1;
3855 overlay
= build_overlay (beg
, end
, Qnil
);
3857 /* Put the new overlay on the wrong list. */
3858 end
= OVERLAY_END (overlay
);
3859 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
3861 eassert (b
->overlays_after
|| (XOVERLAY (overlay
)->next
== NULL
));
3862 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3863 set_buffer_overlays_after (b
, XOVERLAY (overlay
));
3867 eassert (b
->overlays_before
|| (XOVERLAY (overlay
)->next
== NULL
));
3868 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3869 set_buffer_overlays_before (b
, XOVERLAY (overlay
));
3871 /* This puts it in the right list, and in the right order. */
3872 recenter_overlay_lists (b
, b
->overlay_center
);
3874 /* We don't need to redisplay the region covered by the overlay, because
3875 the overlay has no properties at the moment. */
3880 /* Mark a section of BUF as needing redisplay because of overlays changes. */
3883 modify_overlay (struct buffer
*buf
, ptrdiff_t start
, ptrdiff_t end
)
3887 ptrdiff_t temp
= start
;
3892 BUF_COMPUTE_UNCHANGED (buf
, start
, end
);
3894 bset_redisplay (buf
);
3896 ++BUF_OVERLAY_MODIFF (buf
);
3899 /* Remove OVERLAY from LIST. */
3901 static struct Lisp_Overlay
*
3902 unchain_overlay (struct Lisp_Overlay
*list
, struct Lisp_Overlay
*overlay
)
3904 register struct Lisp_Overlay
*tail
, **prev
= &list
;
3906 for (tail
= list
; tail
; prev
= &tail
->next
, tail
= *prev
)
3907 if (tail
== overlay
)
3909 *prev
= overlay
->next
;
3910 overlay
->next
= NULL
;
3916 /* Remove OVERLAY from both overlay lists of B. */
3919 unchain_both (struct buffer
*b
, Lisp_Object overlay
)
3921 struct Lisp_Overlay
*ov
= XOVERLAY (overlay
);
3923 set_buffer_overlays_before (b
, unchain_overlay (b
->overlays_before
, ov
));
3924 set_buffer_overlays_after (b
, unchain_overlay (b
->overlays_after
, ov
));
3925 eassert (XOVERLAY (overlay
)->next
== NULL
);
3928 DEFUN ("move-overlay", Fmove_overlay
, Smove_overlay
, 3, 4, 0,
3929 doc
: /* Set the endpoints of OVERLAY to BEG and END in BUFFER.
3930 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.
3931 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current
3933 (Lisp_Object overlay
, Lisp_Object beg
, Lisp_Object end
, Lisp_Object buffer
)
3935 struct buffer
*b
, *ob
= 0;
3936 Lisp_Object obuffer
;
3937 ptrdiff_t count
= SPECPDL_INDEX ();
3938 ptrdiff_t n_beg
, n_end
, o_beg
IF_LINT (= 0), o_end
IF_LINT (= 0);
3940 CHECK_OVERLAY (overlay
);
3942 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3944 XSETBUFFER (buffer
, current_buffer
);
3945 CHECK_BUFFER (buffer
);
3947 if (NILP (Fbuffer_live_p (buffer
)))
3948 error ("Attempt to move overlay to a dead buffer");
3950 if (MARKERP (beg
) && !EQ (Fmarker_buffer (beg
), buffer
))
3951 signal_error ("Marker points into wrong buffer", beg
);
3952 if (MARKERP (end
) && !EQ (Fmarker_buffer (end
), buffer
))
3953 signal_error ("Marker points into wrong buffer", end
);
3955 CHECK_NUMBER_COERCE_MARKER (beg
);
3956 CHECK_NUMBER_COERCE_MARKER (end
);
3958 if (XINT (beg
) > XINT (end
))
3961 temp
= beg
; beg
= end
; end
= temp
;
3964 specbind (Qinhibit_quit
, Qt
);
3966 obuffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3967 b
= XBUFFER (buffer
);
3969 if (!NILP (obuffer
))
3971 ob
= XBUFFER (obuffer
);
3973 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3974 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3976 unchain_both (ob
, overlay
);
3979 /* Set the overlay boundaries, which may clip them. */
3980 Fset_marker (OVERLAY_START (overlay
), beg
, buffer
);
3981 Fset_marker (OVERLAY_END (overlay
), end
, buffer
);
3983 n_beg
= marker_position (OVERLAY_START (overlay
));
3984 n_end
= marker_position (OVERLAY_END (overlay
));
3986 /* If the overlay has changed buffers, do a thorough redisplay. */
3987 if (!EQ (buffer
, obuffer
))
3989 /* Redisplay where the overlay was. */
3991 modify_overlay (ob
, o_beg
, o_end
);
3993 /* Redisplay where the overlay is going to be. */
3994 modify_overlay (b
, n_beg
, n_end
);
3997 /* Redisplay the area the overlay has just left, or just enclosed. */
4000 modify_overlay (b
, o_end
, n_end
);
4001 else if (o_end
== n_end
)
4002 modify_overlay (b
, o_beg
, n_beg
);
4004 modify_overlay (b
, min (o_beg
, n_beg
), max (o_end
, n_end
));
4007 /* Delete the overlay if it is empty after clipping and has the
4008 evaporate property. */
4009 if (n_beg
== n_end
&& !NILP (Foverlay_get (overlay
, Qevaporate
)))
4010 return unbind_to (count
, Fdelete_overlay (overlay
));
4012 /* Put the overlay into the new buffer's overlay lists, first on the
4014 if (n_end
< b
->overlay_center
)
4016 XOVERLAY (overlay
)->next
= b
->overlays_after
;
4017 set_buffer_overlays_after (b
, XOVERLAY (overlay
));
4021 XOVERLAY (overlay
)->next
= b
->overlays_before
;
4022 set_buffer_overlays_before (b
, XOVERLAY (overlay
));
4025 /* This puts it in the right list, and in the right order. */
4026 recenter_overlay_lists (b
, b
->overlay_center
);
4028 return unbind_to (count
, overlay
);
4031 DEFUN ("delete-overlay", Fdelete_overlay
, Sdelete_overlay
, 1, 1, 0,
4032 doc
: /* Delete the overlay OVERLAY from its buffer. */)
4033 (Lisp_Object overlay
)
4037 ptrdiff_t count
= SPECPDL_INDEX ();
4039 CHECK_OVERLAY (overlay
);
4041 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4045 b
= XBUFFER (buffer
);
4046 specbind (Qinhibit_quit
, Qt
);
4048 unchain_both (b
, overlay
);
4049 drop_overlay (b
, XOVERLAY (overlay
));
4051 /* When deleting an overlay with before or after strings, turn off
4052 display optimizations for the affected buffer, on the basis that
4053 these strings may contain newlines. This is easier to do than to
4054 check for that situation during redisplay. */
4055 if (!windows_or_buffers_changed
4056 && (!NILP (Foverlay_get (overlay
, Qbefore_string
))
4057 || !NILP (Foverlay_get (overlay
, Qafter_string
))))
4058 b
->prevent_redisplay_optimizations_p
= 1;
4060 return unbind_to (count
, Qnil
);
4063 DEFUN ("delete-all-overlays", Fdelete_all_overlays
, Sdelete_all_overlays
, 0, 1, 0,
4064 doc
: /* Delete all overlays of BUFFER.
4065 BUFFER omitted or nil means delete all overlays of the current
4067 (Lisp_Object buffer
)
4069 delete_all_overlays (decode_buffer (buffer
));
4073 /* Overlay dissection functions. */
4075 DEFUN ("overlay-start", Foverlay_start
, Soverlay_start
, 1, 1, 0,
4076 doc
: /* Return the position at which OVERLAY starts. */)
4077 (Lisp_Object overlay
)
4079 CHECK_OVERLAY (overlay
);
4081 return (Fmarker_position (OVERLAY_START (overlay
)));
4084 DEFUN ("overlay-end", Foverlay_end
, Soverlay_end
, 1, 1, 0,
4085 doc
: /* Return the position at which OVERLAY ends. */)
4086 (Lisp_Object overlay
)
4088 CHECK_OVERLAY (overlay
);
4090 return (Fmarker_position (OVERLAY_END (overlay
)));
4093 DEFUN ("overlay-buffer", Foverlay_buffer
, Soverlay_buffer
, 1, 1, 0,
4094 doc
: /* Return the buffer OVERLAY belongs to.
4095 Return nil if OVERLAY has been deleted. */)
4096 (Lisp_Object overlay
)
4098 CHECK_OVERLAY (overlay
);
4100 return Fmarker_buffer (OVERLAY_START (overlay
));
4103 DEFUN ("overlay-properties", Foverlay_properties
, Soverlay_properties
, 1, 1, 0,
4104 doc
: /* Return a list of the properties on OVERLAY.
4105 This is a copy of OVERLAY's plist; modifying its conses has no effect on
4107 (Lisp_Object overlay
)
4109 CHECK_OVERLAY (overlay
);
4111 return Fcopy_sequence (XOVERLAY (overlay
)->plist
);
4115 DEFUN ("overlays-at", Foverlays_at
, Soverlays_at
, 1, 2, 0,
4116 doc
: /* Return a list of the overlays that contain the character at POS.
4117 If SORTED is non-nil, then sort them by decreasing priority. */)
4118 (Lisp_Object pos
, Lisp_Object sorted
)
4120 ptrdiff_t len
, noverlays
;
4121 Lisp_Object
*overlay_vec
;
4124 CHECK_NUMBER_COERCE_MARKER (pos
);
4126 if (!buffer_has_overlays ())
4130 /* We can't use alloca here because overlays_at can call xrealloc. */
4131 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4133 /* Put all the overlays we want in a vector in overlay_vec.
4134 Store the length in len. */
4135 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4139 noverlays
= sort_overlays (overlay_vec
, noverlays
,
4140 WINDOWP (sorted
) ? XWINDOW (sorted
) : NULL
);
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
);
4165 if (!buffer_has_overlays ())
4169 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4171 /* Put all the overlays we want in a vector in overlay_vec.
4172 Store the length in len. */
4173 noverlays
= overlays_in (XINT (beg
), XINT (end
), 1, &overlay_vec
, &len
,
4176 /* Make a list of them all. */
4177 result
= Flist (noverlays
, overlay_vec
);
4179 xfree (overlay_vec
);
4183 DEFUN ("next-overlay-change", Fnext_overlay_change
, Snext_overlay_change
,
4185 doc
: /* Return the next position after POS where an overlay starts or ends.
4186 If there are no overlay boundaries from POS to (point-max),
4187 the value is (point-max). */)
4190 ptrdiff_t i
, len
, noverlays
;
4192 Lisp_Object
*overlay_vec
;
4194 CHECK_NUMBER_COERCE_MARKER (pos
);
4196 if (!buffer_has_overlays ())
4197 return make_number (ZV
);
4200 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4202 /* Put all the overlays we want in a vector in overlay_vec.
4203 Store the length in len.
4204 endpos gets the position where the next overlay starts. */
4205 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4208 /* If any of these overlays ends before endpos,
4209 use its ending point instead. */
4210 for (i
= 0; i
< noverlays
; i
++)
4215 oend
= OVERLAY_END (overlay_vec
[i
]);
4216 oendpos
= OVERLAY_POSITION (oend
);
4217 if (oendpos
< endpos
)
4221 xfree (overlay_vec
);
4222 return make_number (endpos
);
4225 DEFUN ("previous-overlay-change", Fprevious_overlay_change
,
4226 Sprevious_overlay_change
, 1, 1, 0,
4227 doc
: /* Return the previous position before POS where an overlay starts or ends.
4228 If there are no overlay boundaries from (point-min) to POS,
4229 the value is (point-min). */)
4233 Lisp_Object
*overlay_vec
;
4236 CHECK_NUMBER_COERCE_MARKER (pos
);
4238 if (!buffer_has_overlays ())
4239 return make_number (BEGV
);
4241 /* At beginning of buffer, we know the answer;
4242 avoid bug subtracting 1 below. */
4243 if (XINT (pos
) == BEGV
)
4247 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4249 /* Put all the overlays we want in a vector in overlay_vec.
4250 Store the length in len.
4251 prevpos gets the position of the previous change. */
4252 overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4255 xfree (overlay_vec
);
4256 return make_number (prevpos
);
4259 /* These functions are for debugging overlays. */
4261 DEFUN ("overlay-lists", Foverlay_lists
, Soverlay_lists
, 0, 0, 0,
4262 doc
: /* Return a pair of lists giving all the overlays of the current buffer.
4263 The car has all the overlays before the overlay center;
4264 the cdr has all the overlays after the overlay center.
4265 Recentering overlays moves overlays between these lists.
4266 The lists you get are copies, so that changing them has no effect.
4267 However, the overlays you get are the real objects that the buffer uses. */)
4270 struct Lisp_Overlay
*ol
;
4271 Lisp_Object before
= Qnil
, after
= Qnil
, tmp
;
4273 for (ol
= current_buffer
->overlays_before
; ol
; ol
= ol
->next
)
4276 before
= Fcons (tmp
, before
);
4278 for (ol
= current_buffer
->overlays_after
; ol
; ol
= ol
->next
)
4281 after
= Fcons (tmp
, after
);
4284 return Fcons (Fnreverse (before
), Fnreverse (after
));
4287 DEFUN ("overlay-recenter", Foverlay_recenter
, Soverlay_recenter
, 1, 1, 0,
4288 doc
: /* Recenter the overlays of the current buffer around position POS.
4289 That makes overlay lookup faster for positions near POS (but perhaps slower
4290 for positions far away from POS). */)
4294 CHECK_NUMBER_COERCE_MARKER (pos
);
4296 p
= clip_to_bounds (PTRDIFF_MIN
, XINT (pos
), PTRDIFF_MAX
);
4297 recenter_overlay_lists (current_buffer
, p
);
4301 DEFUN ("overlay-get", Foverlay_get
, Soverlay_get
, 2, 2, 0,
4302 doc
: /* Get the property of overlay OVERLAY with property name PROP. */)
4303 (Lisp_Object overlay
, Lisp_Object prop
)
4305 CHECK_OVERLAY (overlay
);
4306 return lookup_char_property (XOVERLAY (overlay
)->plist
, prop
, 0);
4309 DEFUN ("overlay-put", Foverlay_put
, Soverlay_put
, 3, 3, 0,
4310 doc
: /* Set one property of overlay OVERLAY: give property PROP value VALUE.
4311 VALUE will be returned.*/)
4312 (Lisp_Object overlay
, Lisp_Object prop
, Lisp_Object value
)
4314 Lisp_Object tail
, buffer
;
4317 CHECK_OVERLAY (overlay
);
4319 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4321 for (tail
= XOVERLAY (overlay
)->plist
;
4322 CONSP (tail
) && CONSP (XCDR (tail
));
4323 tail
= XCDR (XCDR (tail
)))
4324 if (EQ (XCAR (tail
), prop
))
4326 changed
= !EQ (XCAR (XCDR (tail
)), value
);
4327 XSETCAR (XCDR (tail
), value
);
4330 /* It wasn't in the list, so add it to the front. */
4331 changed
= !NILP (value
);
4333 (overlay
, Fcons (prop
, Fcons (value
, XOVERLAY (overlay
)->plist
)));
4335 if (! NILP (buffer
))
4338 modify_overlay (XBUFFER (buffer
),
4339 marker_position (OVERLAY_START (overlay
)),
4340 marker_position (OVERLAY_END (overlay
)));
4341 if (EQ (prop
, Qevaporate
) && ! NILP (value
)
4342 && (OVERLAY_POSITION (OVERLAY_START (overlay
))
4343 == OVERLAY_POSITION (OVERLAY_END (overlay
))))
4344 Fdelete_overlay (overlay
);
4350 /* Subroutine of report_overlay_modification. */
4352 /* Lisp vector holding overlay hook functions to call.
4353 Vector elements come in pairs.
4354 Each even-index element is a list of hook functions.
4355 The following odd-index element is the overlay they came from.
4357 Before the buffer change, we fill in this vector
4358 as we call overlay hook functions.
4359 After the buffer change, we get the functions to call from this vector.
4360 This way we always call the same functions before and after the change. */
4361 static Lisp_Object last_overlay_modification_hooks
;
4363 /* Number of elements actually used in last_overlay_modification_hooks. */
4364 static ptrdiff_t last_overlay_modification_hooks_used
;
4366 /* Add one functionlist/overlay pair
4367 to the end of last_overlay_modification_hooks. */
4370 add_overlay_mod_hooklist (Lisp_Object functionlist
, Lisp_Object overlay
)
4372 ptrdiff_t oldsize
= ASIZE (last_overlay_modification_hooks
);
4374 if (oldsize
- 1 <= last_overlay_modification_hooks_used
)
4375 last_overlay_modification_hooks
=
4376 larger_vector (last_overlay_modification_hooks
, 2, -1);
4377 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4378 functionlist
); last_overlay_modification_hooks_used
++;
4379 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4380 overlay
); last_overlay_modification_hooks_used
++;
4383 /* Run the modification-hooks of overlays that include
4384 any part of the text in START to END.
4385 If this change is an insertion, also
4386 run the insert-before-hooks of overlay starting at END,
4387 and the insert-after-hooks of overlay ending at START.
4389 This is called both before and after the modification.
4390 AFTER is true when we call after the modification.
4392 ARG1, ARG2, ARG3 are arguments to pass to the hook functions.
4393 When AFTER is nonzero, they are the start position,
4394 the position after the inserted new text,
4395 and the length of deleted or replaced old text. */
4398 report_overlay_modification (Lisp_Object start
, Lisp_Object end
, bool after
,
4399 Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
)
4401 Lisp_Object prop
, overlay
;
4402 struct Lisp_Overlay
*tail
;
4403 /* True if this change is an insertion. */
4404 bool insertion
= (after
? XFASTINT (arg3
) == 0 : EQ (start
, end
));
4405 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4410 /* We used to run the functions as soon as we found them and only register
4411 them in last_overlay_modification_hooks for the purpose of the `after'
4412 case. But running elisp code as we traverse the list of overlays is
4413 painful because the list can be modified by the elisp code so we had to
4414 copy at several places. We now simply do a read-only traversal that
4415 only collects the functions to run and we run them afterwards. It's
4416 simpler, especially since all the code was already there. -stef */
4420 /* We are being called before a change.
4421 Scan the overlays to find the functions to call. */
4422 last_overlay_modification_hooks_used
= 0;
4423 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4425 ptrdiff_t startpos
, endpos
;
4426 Lisp_Object ostart
, oend
;
4428 XSETMISC (overlay
, tail
);
4430 ostart
= OVERLAY_START (overlay
);
4431 oend
= OVERLAY_END (overlay
);
4432 endpos
= OVERLAY_POSITION (oend
);
4433 if (XFASTINT (start
) > endpos
)
4435 startpos
= OVERLAY_POSITION (ostart
);
4436 if (insertion
&& (XFASTINT (start
) == startpos
4437 || XFASTINT (end
) == startpos
))
4439 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4441 add_overlay_mod_hooklist (prop
, overlay
);
4443 if (insertion
&& (XFASTINT (start
) == endpos
4444 || XFASTINT (end
) == endpos
))
4446 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4448 add_overlay_mod_hooklist (prop
, overlay
);
4450 /* Test for intersecting intervals. This does the right thing
4451 for both insertion and deletion. */
4452 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4454 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4456 add_overlay_mod_hooklist (prop
, overlay
);
4460 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4462 ptrdiff_t startpos
, endpos
;
4463 Lisp_Object ostart
, oend
;
4465 XSETMISC (overlay
, tail
);
4467 ostart
= OVERLAY_START (overlay
);
4468 oend
= OVERLAY_END (overlay
);
4469 startpos
= OVERLAY_POSITION (ostart
);
4470 endpos
= OVERLAY_POSITION (oend
);
4471 if (XFASTINT (end
) < startpos
)
4473 if (insertion
&& (XFASTINT (start
) == startpos
4474 || XFASTINT (end
) == startpos
))
4476 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4478 add_overlay_mod_hooklist (prop
, overlay
);
4480 if (insertion
&& (XFASTINT (start
) == endpos
4481 || XFASTINT (end
) == endpos
))
4483 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4485 add_overlay_mod_hooklist (prop
, overlay
);
4487 /* Test for intersecting intervals. This does the right thing
4488 for both insertion and deletion. */
4489 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4491 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4493 add_overlay_mod_hooklist (prop
, overlay
);
4498 GCPRO4 (overlay
, arg1
, arg2
, arg3
);
4500 /* Call the functions recorded in last_overlay_modification_hooks.
4501 First copy the vector contents, in case some of these hooks
4502 do subsequent modification of the buffer. */
4503 ptrdiff_t size
= last_overlay_modification_hooks_used
;
4508 SAFE_ALLOCA_LISP (copy
, size
);
4509 memcpy (copy
, XVECTOR (last_overlay_modification_hooks
)->contents
,
4512 for (i
= 0; i
< size
;)
4514 Lisp_Object prop_i
, overlay_i
;
4516 overlay_i
= copy
[i
++];
4517 call_overlay_mod_hooks (prop_i
, overlay_i
, after
, arg1
, arg2
, arg3
);
4526 call_overlay_mod_hooks (Lisp_Object list
, Lisp_Object overlay
, bool after
,
4527 Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
)
4529 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4531 GCPRO4 (list
, arg1
, arg2
, arg3
);
4533 while (CONSP (list
))
4536 call4 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
);
4538 call5 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
, arg3
);
4544 /* Delete any zero-sized overlays at position POS, if the `evaporate'
4547 evaporate_overlays (ptrdiff_t pos
)
4549 Lisp_Object overlay
, hit_list
;
4550 struct Lisp_Overlay
*tail
;
4553 if (pos
<= current_buffer
->overlay_center
)
4554 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4557 XSETMISC (overlay
, tail
);
4558 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4561 if (endpos
== pos
&& OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
4562 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4563 hit_list
= Fcons (overlay
, hit_list
);
4566 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4569 XSETMISC (overlay
, tail
);
4570 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4573 if (startpos
== pos
&& OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
4574 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4575 hit_list
= Fcons (overlay
, hit_list
);
4577 for (; CONSP (hit_list
); hit_list
= XCDR (hit_list
))
4578 Fdelete_overlay (XCAR (hit_list
));
4581 /***********************************************************************
4582 Allocation with mmap
4583 ***********************************************************************/
4585 /* Note: WINDOWSNT implements this stuff on w32heap.c. */
4586 #if defined USE_MMAP_FOR_BUFFERS && !defined WINDOWSNT
4588 #include <sys/mman.h>
4591 #ifdef MAP_ANONYMOUS
4592 #define MAP_ANON MAP_ANONYMOUS
4599 #define MAP_FAILED ((void *) -1)
4609 /* Memory is allocated in regions which are mapped using mmap(2).
4610 The current implementation lets the system select mapped
4611 addresses; we're not using MAP_FIXED in general, except when
4612 trying to enlarge regions.
4614 Each mapped region starts with a mmap_region structure, the user
4615 area starts after that structure, aligned to MEM_ALIGN.
4617 +-----------------------+
4618 | struct mmap_info + |
4620 +-----------------------+
4624 +-----------------------+ */
4628 /* User-specified size. */
4629 size_t nbytes_specified
;
4631 /* Number of bytes mapped */
4632 size_t nbytes_mapped
;
4634 /* Pointer to the location holding the address of the memory
4635 allocated with the mmap'd block. The variable actually points
4636 after this structure. */
4639 /* Next and previous in list of all mmap'd regions. */
4640 struct mmap_region
*next
, *prev
;
4643 /* Doubly-linked list of mmap'd regions. */
4645 static struct mmap_region
*mmap_regions
;
4647 /* File descriptor for mmap. If we don't have anonymous mapping,
4648 /dev/zero will be opened on it. */
4652 /* Page size on this system. */
4654 static int mmap_page_size
;
4656 /* 1 means mmap has been initialized. */
4658 static bool mmap_initialized_p
;
4660 /* Value is X rounded up to the next multiple of N. */
4662 #define ROUND(X, N) (((X) + (N) - 1) / (N) * (N))
4664 /* Size of mmap_region structure plus padding. */
4666 #define MMAP_REGION_STRUCT_SIZE \
4667 ROUND (sizeof (struct mmap_region), MEM_ALIGN)
4669 /* Given a pointer P to the start of the user-visible part of a mapped
4670 region, return a pointer to the start of the region. */
4672 #define MMAP_REGION(P) \
4673 ((struct mmap_region *) ((char *) (P) - MMAP_REGION_STRUCT_SIZE))
4675 /* Given a pointer P to the start of a mapped region, return a pointer
4676 to the start of the user-visible part of the region. */
4678 #define MMAP_USER_AREA(P) \
4679 ((void *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
4681 #define MEM_ALIGN sizeof (double)
4683 /* Predicate returning true if part of the address range [START .. END]
4684 is currently mapped. Used to prevent overwriting an existing
4687 Default is to conservatively assume the address range is occupied by
4688 something else. This can be overridden by system configuration
4689 files if system-specific means to determine this exists. */
4691 #ifndef MMAP_ALLOCATED_P
4692 #define MMAP_ALLOCATED_P(start, end) 1
4695 /* Perform necessary initializations for the use of mmap. */
4701 /* The value of mmap_fd is initially 0 in temacs, and -1
4702 in a dumped Emacs. */
4705 /* No anonymous mmap -- we need the file descriptor. */
4706 mmap_fd
= emacs_open ("/dev/zero", O_RDONLY
, 0);
4708 fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno
));
4710 #endif /* MAP_ANON == 0 */
4712 if (mmap_initialized_p
)
4714 mmap_initialized_p
= 1;
4720 mmap_page_size
= getpagesize ();
4723 /* Unmap a region. P is a pointer to the start of the user-araa of
4727 mmap_free_1 (struct mmap_region
*r
)
4730 r
->next
->prev
= r
->prev
;
4732 r
->prev
->next
= r
->next
;
4734 mmap_regions
= r
->next
;
4736 if (munmap (r
, r
->nbytes_mapped
) == -1)
4737 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4741 /* Enlarge region R by NPAGES pages. NPAGES < 0 means shrink R.
4742 Value is true if successful. */
4745 mmap_enlarge (struct mmap_region
*r
, int npages
)
4747 char *region_end
= (char *) r
+ r
->nbytes_mapped
;
4753 /* Unmap pages at the end of the region. */
4754 nbytes
= - npages
* mmap_page_size
;
4755 if (munmap (region_end
- nbytes
, nbytes
) == -1)
4756 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4759 r
->nbytes_mapped
-= nbytes
;
4763 else if (npages
> 0)
4765 nbytes
= npages
* mmap_page_size
;
4767 /* Try to map additional pages at the end of the region. We
4768 cannot do this if the address range is already occupied by
4769 something else because mmap deletes any previous mapping.
4770 I'm not sure this is worth doing, let's see. */
4771 if (!MMAP_ALLOCATED_P (region_end
, region_end
+ nbytes
))
4775 p
= mmap (region_end
, nbytes
, PROT_READ
| PROT_WRITE
,
4776 MAP_ANON
| MAP_PRIVATE
| MAP_FIXED
, mmap_fd
, 0);
4777 if (p
== MAP_FAILED
)
4778 ; /* fprintf (stderr, "mmap: %s\n", emacs_strerror (errno)); */
4779 else if (p
!= region_end
)
4781 /* Kernels are free to choose a different address. In
4782 that case, unmap what we've mapped above; we have
4784 if (munmap (p
, nbytes
) == -1)
4785 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4789 r
->nbytes_mapped
+= nbytes
;
4799 /* Allocate a block of storage large enough to hold NBYTES bytes of
4800 data. A pointer to the data is returned in *VAR. VAR is thus the
4801 address of some variable which will use the data area.
4803 The allocation of 0 bytes is valid.
4805 If we can't allocate the necessary memory, set *VAR to null, and
4809 mmap_alloc (void **var
, size_t nbytes
)
4816 map
= ROUND (nbytes
+ MMAP_REGION_STRUCT_SIZE
, mmap_page_size
);
4817 p
= mmap (NULL
, map
, PROT_READ
| PROT_WRITE
, MAP_ANON
| MAP_PRIVATE
,
4820 if (p
== MAP_FAILED
)
4822 if (errno
!= ENOMEM
)
4823 fprintf (stderr
, "mmap: %s\n", emacs_strerror (errno
));
4828 struct mmap_region
*r
= p
;
4830 r
->nbytes_specified
= nbytes
;
4831 r
->nbytes_mapped
= map
;
4834 r
->next
= mmap_regions
;
4839 p
= MMAP_USER_AREA (p
);
4846 /* Free a block of relocatable storage whose data is pointed to by
4847 PTR. Store 0 in *PTR to show there's no block allocated. */
4850 mmap_free (void **var
)
4856 mmap_free_1 (MMAP_REGION (*var
));
4862 /* Given a pointer at address VAR to data allocated with mmap_alloc,
4863 resize it to size NBYTES. Change *VAR to reflect the new block,
4864 and return this value. If more memory cannot be allocated, then
4865 leave *VAR unchanged, and return null. */
4868 mmap_realloc (void **var
, size_t nbytes
)
4875 result
= mmap_alloc (var
, nbytes
);
4876 else if (nbytes
== 0)
4879 result
= mmap_alloc (var
, nbytes
);
4883 struct mmap_region
*r
= MMAP_REGION (*var
);
4884 size_t room
= r
->nbytes_mapped
- MMAP_REGION_STRUCT_SIZE
;
4889 void *old_ptr
= *var
;
4891 /* Try to map additional pages at the end of the region.
4892 If that fails, allocate a new region, copy data
4893 from the old region, then free it. */
4894 if (mmap_enlarge (r
, (ROUND (nbytes
- room
, mmap_page_size
)
4897 r
->nbytes_specified
= nbytes
;
4898 *var
= result
= old_ptr
;
4900 else if (mmap_alloc (var
, nbytes
))
4902 memcpy (*var
, old_ptr
, r
->nbytes_specified
);
4903 mmap_free_1 (MMAP_REGION (old_ptr
));
4905 r
= MMAP_REGION (result
);
4906 r
->nbytes_specified
= nbytes
;
4914 else if (room
- nbytes
>= mmap_page_size
)
4916 /* Shrinking by at least a page. Let's give some
4917 memory back to the system.
4919 The extra parens are to make the division happens first,
4920 on positive values, so we know it will round towards
4922 mmap_enlarge (r
, - ((room
- nbytes
) / mmap_page_size
));
4924 r
->nbytes_specified
= nbytes
;
4928 /* Leave it alone. */
4930 r
->nbytes_specified
= nbytes
;
4938 #endif /* USE_MMAP_FOR_BUFFERS */
4942 /***********************************************************************
4943 Buffer-text Allocation
4944 ***********************************************************************/
4946 /* Allocate NBYTES bytes for buffer B's text buffer. */
4949 alloc_buffer_text (struct buffer
*b
, ptrdiff_t nbytes
)
4954 #if defined USE_MMAP_FOR_BUFFERS
4955 p
= mmap_alloc ((void **) &b
->text
->beg
, nbytes
);
4956 #elif defined REL_ALLOC
4957 p
= r_alloc ((void **) &b
->text
->beg
, nbytes
);
4959 p
= xmalloc (nbytes
);
4965 memory_full (nbytes
);
4972 /* Enlarge buffer B's text buffer by DELTA bytes. DELTA < 0 means
4976 enlarge_buffer_text (struct buffer
*b
, ptrdiff_t delta
)
4979 ptrdiff_t nbytes
= (BUF_Z_BYTE (b
) - BUF_BEG_BYTE (b
) + BUF_GAP_SIZE (b
) + 1
4982 #if defined USE_MMAP_FOR_BUFFERS
4983 p
= mmap_realloc ((void **) &b
->text
->beg
, nbytes
);
4984 #elif defined REL_ALLOC
4985 p
= r_re_alloc ((void **) &b
->text
->beg
, nbytes
);
4987 p
= xrealloc (b
->text
->beg
, nbytes
);
4993 memory_full (nbytes
);
4996 BUF_BEG_ADDR (b
) = p
;
5001 /* Free buffer B's text buffer. */
5004 free_buffer_text (struct buffer
*b
)
5008 #if defined USE_MMAP_FOR_BUFFERS
5009 mmap_free ((void **) &b
->text
->beg
);
5010 #elif defined REL_ALLOC
5011 r_alloc_free ((void **) &b
->text
->beg
);
5013 xfree (b
->text
->beg
);
5016 BUF_BEG_ADDR (b
) = NULL
;
5022 /***********************************************************************
5024 ***********************************************************************/
5027 init_buffer_once (void)
5031 memset (buffer_permanent_local_flags
, 0, sizeof buffer_permanent_local_flags
);
5033 /* 0 means not a lisp var, -1 means always local, else mask. */
5034 memset (&buffer_local_flags
, 0, sizeof buffer_local_flags
);
5035 bset_filename (&buffer_local_flags
, make_number (-1));
5036 bset_directory (&buffer_local_flags
, make_number (-1));
5037 bset_backed_up (&buffer_local_flags
, make_number (-1));
5038 bset_save_length (&buffer_local_flags
, make_number (-1));
5039 bset_auto_save_file_name (&buffer_local_flags
, make_number (-1));
5040 bset_read_only (&buffer_local_flags
, make_number (-1));
5041 bset_major_mode (&buffer_local_flags
, make_number (-1));
5042 bset_mode_name (&buffer_local_flags
, make_number (-1));
5043 bset_undo_list (&buffer_local_flags
, make_number (-1));
5044 bset_mark_active (&buffer_local_flags
, make_number (-1));
5045 bset_point_before_scroll (&buffer_local_flags
, make_number (-1));
5046 bset_file_truename (&buffer_local_flags
, make_number (-1));
5047 bset_invisibility_spec (&buffer_local_flags
, make_number (-1));
5048 bset_file_format (&buffer_local_flags
, make_number (-1));
5049 bset_auto_save_file_format (&buffer_local_flags
, make_number (-1));
5050 bset_display_count (&buffer_local_flags
, make_number (-1));
5051 bset_display_time (&buffer_local_flags
, make_number (-1));
5052 bset_enable_multibyte_characters (&buffer_local_flags
, make_number (-1));
5054 /* These used to be stuck at 0 by default, but now that the all-zero value
5055 means Qnil, we have to initialize them explicitly. */
5056 bset_name (&buffer_local_flags
, make_number (0));
5057 bset_mark (&buffer_local_flags
, make_number (0));
5058 bset_local_var_alist (&buffer_local_flags
, make_number (0));
5059 bset_keymap (&buffer_local_flags
, make_number (0));
5060 bset_downcase_table (&buffer_local_flags
, make_number (0));
5061 bset_upcase_table (&buffer_local_flags
, make_number (0));
5062 bset_case_canon_table (&buffer_local_flags
, make_number (0));
5063 bset_case_eqv_table (&buffer_local_flags
, make_number (0));
5064 bset_minor_modes (&buffer_local_flags
, make_number (0));
5065 bset_width_table (&buffer_local_flags
, make_number (0));
5066 bset_pt_marker (&buffer_local_flags
, make_number (0));
5067 bset_begv_marker (&buffer_local_flags
, make_number (0));
5068 bset_zv_marker (&buffer_local_flags
, make_number (0));
5069 bset_last_selected_window (&buffer_local_flags
, make_number (0));
5072 XSETFASTINT (BVAR (&buffer_local_flags
, mode_line_format
), idx
); ++idx
;
5073 XSETFASTINT (BVAR (&buffer_local_flags
, abbrev_mode
), idx
); ++idx
;
5074 XSETFASTINT (BVAR (&buffer_local_flags
, overwrite_mode
), idx
); ++idx
;
5075 XSETFASTINT (BVAR (&buffer_local_flags
, case_fold_search
), idx
); ++idx
;
5076 XSETFASTINT (BVAR (&buffer_local_flags
, auto_fill_function
), idx
); ++idx
;
5077 XSETFASTINT (BVAR (&buffer_local_flags
, selective_display
), idx
); ++idx
;
5078 XSETFASTINT (BVAR (&buffer_local_flags
, selective_display_ellipses
), idx
); ++idx
;
5079 XSETFASTINT (BVAR (&buffer_local_flags
, tab_width
), idx
); ++idx
;
5080 XSETFASTINT (BVAR (&buffer_local_flags
, truncate_lines
), idx
); ++idx
;
5081 XSETFASTINT (BVAR (&buffer_local_flags
, word_wrap
), idx
); ++idx
;
5082 XSETFASTINT (BVAR (&buffer_local_flags
, ctl_arrow
), idx
); ++idx
;
5083 XSETFASTINT (BVAR (&buffer_local_flags
, fill_column
), idx
); ++idx
;
5084 XSETFASTINT (BVAR (&buffer_local_flags
, left_margin
), idx
); ++idx
;
5085 XSETFASTINT (BVAR (&buffer_local_flags
, abbrev_table
), idx
); ++idx
;
5086 XSETFASTINT (BVAR (&buffer_local_flags
, display_table
), idx
); ++idx
;
5087 XSETFASTINT (BVAR (&buffer_local_flags
, syntax_table
), idx
); ++idx
;
5088 XSETFASTINT (BVAR (&buffer_local_flags
, cache_long_scans
), idx
); ++idx
;
5089 XSETFASTINT (BVAR (&buffer_local_flags
, category_table
), idx
); ++idx
;
5090 XSETFASTINT (BVAR (&buffer_local_flags
, bidi_display_reordering
), idx
); ++idx
;
5091 XSETFASTINT (BVAR (&buffer_local_flags
, bidi_paragraph_direction
), idx
); ++idx
;
5092 XSETFASTINT (BVAR (&buffer_local_flags
, buffer_file_coding_system
), idx
);
5093 /* Make this one a permanent local. */
5094 buffer_permanent_local_flags
[idx
++] = 1;
5095 XSETFASTINT (BVAR (&buffer_local_flags
, left_margin_cols
), idx
); ++idx
;
5096 XSETFASTINT (BVAR (&buffer_local_flags
, right_margin_cols
), idx
); ++idx
;
5097 XSETFASTINT (BVAR (&buffer_local_flags
, left_fringe_width
), idx
); ++idx
;
5098 XSETFASTINT (BVAR (&buffer_local_flags
, right_fringe_width
), idx
); ++idx
;
5099 XSETFASTINT (BVAR (&buffer_local_flags
, fringes_outside_margins
), idx
); ++idx
;
5100 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_bar_width
), idx
); ++idx
;
5101 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_bar_height
), idx
); ++idx
;
5102 XSETFASTINT (BVAR (&buffer_local_flags
, vertical_scroll_bar_type
), idx
); ++idx
;
5103 XSETFASTINT (BVAR (&buffer_local_flags
, horizontal_scroll_bar_type
), idx
); ++idx
;
5104 XSETFASTINT (BVAR (&buffer_local_flags
, indicate_empty_lines
), idx
); ++idx
;
5105 XSETFASTINT (BVAR (&buffer_local_flags
, indicate_buffer_boundaries
), idx
); ++idx
;
5106 XSETFASTINT (BVAR (&buffer_local_flags
, fringe_indicator_alist
), idx
); ++idx
;
5107 XSETFASTINT (BVAR (&buffer_local_flags
, fringe_cursor_alist
), idx
); ++idx
;
5108 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_up_aggressively
), idx
); ++idx
;
5109 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_down_aggressively
), idx
); ++idx
;
5110 XSETFASTINT (BVAR (&buffer_local_flags
, header_line_format
), idx
); ++idx
;
5111 XSETFASTINT (BVAR (&buffer_local_flags
, cursor_type
), idx
); ++idx
;
5112 XSETFASTINT (BVAR (&buffer_local_flags
, extra_line_spacing
), idx
); ++idx
;
5113 XSETFASTINT (BVAR (&buffer_local_flags
, cursor_in_non_selected_windows
), idx
); ++idx
;
5115 /* Need more room? */
5116 if (idx
>= MAX_PER_BUFFER_VARS
)
5118 last_per_buffer_idx
= idx
;
5120 /* Make sure all markable slots in buffer_defaults
5121 are initialized reasonably, so mark_buffer won't choke. */
5122 reset_buffer (&buffer_defaults
);
5123 eassert (NILP (BVAR (&buffer_defaults
, name
)));
5124 reset_buffer_local_variables (&buffer_defaults
, 1);
5125 eassert (NILP (BVAR (&buffer_local_symbols
, name
)));
5126 reset_buffer (&buffer_local_symbols
);
5127 reset_buffer_local_variables (&buffer_local_symbols
, 1);
5128 /* Prevent GC from getting confused. */
5129 buffer_defaults
.text
= &buffer_defaults
.own_text
;
5130 buffer_local_symbols
.text
= &buffer_local_symbols
.own_text
;
5131 /* No one will share the text with these buffers, but let's play it safe. */
5132 buffer_defaults
.indirections
= 0;
5133 buffer_local_symbols
.indirections
= 0;
5134 /* Likewise no one will display them. */
5135 buffer_defaults
.window_count
= 0;
5136 buffer_local_symbols
.window_count
= 0;
5137 set_buffer_intervals (&buffer_defaults
, NULL
);
5138 set_buffer_intervals (&buffer_local_symbols
, NULL
);
5139 /* This is not strictly necessary, but let's make them initialized. */
5140 bset_name (&buffer_defaults
, build_pure_c_string (" *buffer-defaults*"));
5141 bset_name (&buffer_local_symbols
, build_pure_c_string (" *buffer-local-symbols*"));
5142 BUFFER_PVEC_INIT (&buffer_defaults
);
5143 BUFFER_PVEC_INIT (&buffer_local_symbols
);
5145 /* Set up the default values of various buffer slots. */
5146 /* Must do these before making the first buffer! */
5148 /* real setup is done in bindings.el */
5149 bset_mode_line_format (&buffer_defaults
, build_pure_c_string ("%-"));
5150 bset_header_line_format (&buffer_defaults
, Qnil
);
5151 bset_abbrev_mode (&buffer_defaults
, Qnil
);
5152 bset_overwrite_mode (&buffer_defaults
, Qnil
);
5153 bset_case_fold_search (&buffer_defaults
, Qt
);
5154 bset_auto_fill_function (&buffer_defaults
, Qnil
);
5155 bset_selective_display (&buffer_defaults
, Qnil
);
5156 bset_selective_display_ellipses (&buffer_defaults
, Qt
);
5157 bset_abbrev_table (&buffer_defaults
, Qnil
);
5158 bset_display_table (&buffer_defaults
, Qnil
);
5159 bset_undo_list (&buffer_defaults
, Qnil
);
5160 bset_mark_active (&buffer_defaults
, Qnil
);
5161 bset_file_format (&buffer_defaults
, Qnil
);
5162 bset_auto_save_file_format (&buffer_defaults
, Qt
);
5163 set_buffer_overlays_before (&buffer_defaults
, NULL
);
5164 set_buffer_overlays_after (&buffer_defaults
, NULL
);
5165 buffer_defaults
.overlay_center
= BEG
;
5167 XSETFASTINT (BVAR (&buffer_defaults
, tab_width
), 8);
5168 bset_truncate_lines (&buffer_defaults
, Qnil
);
5169 bset_word_wrap (&buffer_defaults
, Qnil
);
5170 bset_ctl_arrow (&buffer_defaults
, Qt
);
5171 bset_bidi_display_reordering (&buffer_defaults
, Qt
);
5172 bset_bidi_paragraph_direction (&buffer_defaults
, Qnil
);
5173 bset_cursor_type (&buffer_defaults
, Qt
);
5174 bset_extra_line_spacing (&buffer_defaults
, Qnil
);
5175 bset_cursor_in_non_selected_windows (&buffer_defaults
, Qt
);
5177 bset_enable_multibyte_characters (&buffer_defaults
, Qt
);
5178 bset_buffer_file_coding_system (&buffer_defaults
, Qnil
);
5179 XSETFASTINT (BVAR (&buffer_defaults
, fill_column
), 70);
5180 XSETFASTINT (BVAR (&buffer_defaults
, left_margin
), 0);
5181 bset_cache_long_scans (&buffer_defaults
, Qt
);
5182 bset_file_truename (&buffer_defaults
, Qnil
);
5183 XSETFASTINT (BVAR (&buffer_defaults
, display_count
), 0);
5184 XSETFASTINT (BVAR (&buffer_defaults
, left_margin_cols
), 0);
5185 XSETFASTINT (BVAR (&buffer_defaults
, right_margin_cols
), 0);
5186 bset_left_fringe_width (&buffer_defaults
, Qnil
);
5187 bset_right_fringe_width (&buffer_defaults
, Qnil
);
5188 bset_fringes_outside_margins (&buffer_defaults
, Qnil
);
5189 bset_scroll_bar_width (&buffer_defaults
, Qnil
);
5190 bset_scroll_bar_height (&buffer_defaults
, Qnil
);
5191 bset_vertical_scroll_bar_type (&buffer_defaults
, Qt
);
5192 bset_horizontal_scroll_bar_type (&buffer_defaults
, Qt
);
5193 bset_indicate_empty_lines (&buffer_defaults
, Qnil
);
5194 bset_indicate_buffer_boundaries (&buffer_defaults
, Qnil
);
5195 bset_fringe_indicator_alist (&buffer_defaults
, Qnil
);
5196 bset_fringe_cursor_alist (&buffer_defaults
, Qnil
);
5197 bset_scroll_up_aggressively (&buffer_defaults
, Qnil
);
5198 bset_scroll_down_aggressively (&buffer_defaults
, Qnil
);
5199 bset_display_time (&buffer_defaults
, Qnil
);
5201 /* Assign the local-flags to the slots that have default values.
5202 The local flag is a bit that is used in the buffer
5203 to say that it has its own local value for the slot.
5204 The local flag bits are in the local_var_flags slot of the buffer. */
5206 /* Nothing can work if this isn't true. */
5207 { verify (sizeof (EMACS_INT
) == word_size
); }
5209 Vbuffer_alist
= Qnil
;
5213 QSFundamental
= build_pure_c_string ("Fundamental");
5215 DEFSYM (Qfundamental_mode
, "fundamental-mode");
5216 bset_major_mode (&buffer_defaults
, Qfundamental_mode
);
5218 DEFSYM (Qmode_class
, "mode-class");
5219 DEFSYM (Qprotected_field
, "protected-field");
5221 DEFSYM (Qpermanent_local
, "permanent-local");
5222 DEFSYM (Qkill_buffer_hook
, "kill-buffer-hook");
5223 Fput (Qkill_buffer_hook
, Qpermanent_local
, Qt
);
5225 /* Super-magic invisible buffer. */
5226 Vprin1_to_string_buffer
= Fget_buffer_create (build_pure_c_string (" prin1"));
5227 Vbuffer_alist
= Qnil
;
5229 Fset_buffer (Fget_buffer_create (build_pure_c_string ("*scratch*")));
5231 inhibit_modification_hooks
= 0;
5235 init_buffer (int initialized
)
5241 #ifdef USE_MMAP_FOR_BUFFERS
5247 /* These must be reset in the dumped Emacs, to avoid stale
5248 references to mmap'ed memory from before the dump.
5250 WINDOWSNT doesn't need this because it doesn't track mmap'ed
5251 regions by hand (see w32heap.c, which uses system APIs for
5252 that purpose), and thus doesn't use mmap_regions. */
5253 mmap_regions
= NULL
;
5257 /* The dumped buffers reference addresses of buffer text
5258 recorded by temacs, that cannot be used by the dumped Emacs.
5259 We map new memory for their text here.
5261 Implementation note: the buffers we carry from temacs are:
5262 " prin1", "*scratch*", " *Minibuf-0*", "*Messages*", and
5263 " *code-conversion-work*". They are created by
5264 init_buffer_once and init_window_once (which are not called
5265 in the dumped Emacs), and by the first call to coding.c routines. */
5268 b
->text
->beg
= NULL
;
5269 enlarge_buffer_text (b
, 0);
5276 /* Only buffers with allocated buffer text should be present at
5277 this point in temacs. */
5280 eassert (b
->text
->beg
!= NULL
);
5283 #else /* not USE_MMAP_FOR_BUFFERS */
5284 /* Avoid compiler warnings. */
5286 #endif /* USE_MMAP_FOR_BUFFERS */
5288 AUTO_STRING (scratch
, "*scratch*");
5289 Fset_buffer (Fget_buffer_create (scratch
));
5290 if (NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
)))
5291 Fset_buffer_multibyte (Qnil
);
5293 pwd
= get_current_dir_name ();
5296 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5298 /* Maybe this should really use some standard subroutine
5299 whose definition is filename syntax dependent. */
5301 if (!(IS_DIRECTORY_SEP (pwd
[len
- 1])))
5303 /* Grow buffer to add directory separator and '\0'. */
5304 pwd
= realloc (pwd
, len
+ 2);
5306 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5307 pwd
[len
] = DIRECTORY_SEP
;
5308 pwd
[len
+ 1] = '\0';
5312 /* At this moment, we still don't know how to decode the directory
5313 name. So, we keep the bytes in unibyte form so that file I/O
5314 routines correctly get the original bytes. */
5315 bset_directory (current_buffer
, make_unibyte_string (pwd
, len
));
5317 /* Add /: to the front of the name
5318 if it would otherwise be treated as magic. */
5319 temp
= Ffind_file_name_handler (BVAR (current_buffer
, directory
), Qt
);
5321 /* If the default dir is just /, TEMP is non-nil
5322 because of the ange-ftp completion handler.
5323 However, it is not necessary to turn / into /:/.
5324 So avoid doing that. */
5325 && strcmp ("/", SSDATA (BVAR (current_buffer
, directory
))))
5327 AUTO_STRING (slash_colon
, "/:");
5328 bset_directory (current_buffer
,
5329 concat2 (slash_colon
,
5330 BVAR (current_buffer
, directory
)));
5333 temp
= get_minibuffer (0);
5334 bset_directory (XBUFFER (temp
), BVAR (current_buffer
, directory
));
5339 /* Similar to defvar_lisp but define a variable whose value is the
5340 Lisp_Object stored in the current buffer. LNAME is the Lisp-level
5341 variable name. VNAME is the name of the buffer slot. PREDICATE
5342 is nil for a general Lisp variable. If PREDICATE is non-nil, then
5343 only Lisp values that satisfies the PREDICATE are allowed (except
5344 that nil is allowed too). DOC is a dummy where you write the doc
5345 string as a comment. */
5347 #define DEFVAR_PER_BUFFER(lname, vname, predicate, doc) \
5349 static struct Lisp_Buffer_Objfwd bo_fwd; \
5350 defvar_per_buffer (&bo_fwd, lname, vname, predicate); \
5354 defvar_per_buffer (struct Lisp_Buffer_Objfwd
*bo_fwd
, const char *namestring
,
5355 Lisp_Object
*address
, Lisp_Object predicate
)
5357 struct Lisp_Symbol
*sym
;
5360 sym
= XSYMBOL (intern (namestring
));
5361 offset
= (char *)address
- (char *)current_buffer
;
5363 bo_fwd
->type
= Lisp_Fwd_Buffer_Obj
;
5364 bo_fwd
->offset
= offset
;
5365 bo_fwd
->predicate
= predicate
;
5366 sym
->declared_special
= 1;
5367 sym
->redirect
= SYMBOL_FORWARDED
;
5368 SET_SYMBOL_FWD (sym
, (union Lisp_Fwd
*) bo_fwd
);
5369 XSETSYMBOL (PER_BUFFER_SYMBOL (offset
), sym
);
5371 if (PER_BUFFER_IDX (offset
) == 0)
5372 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
5373 slot of buffer_local_flags. */
5378 /* Initialize the buffer routines. */
5380 syms_of_buffer (void)
5382 staticpro (&last_overlay_modification_hooks
);
5383 last_overlay_modification_hooks
5384 = Fmake_vector (make_number (10), Qnil
);
5386 staticpro (&QSFundamental
);
5387 staticpro (&Vbuffer_alist
);
5389 DEFSYM (Qchoice
, "choice");
5390 DEFSYM (Qleft
, "left");
5391 DEFSYM (Qright
, "right");
5392 DEFSYM (Qrange
, "range");
5394 DEFSYM (Qpermanent_local_hook
, "permanent-local-hook");
5395 DEFSYM (Qoverlayp
, "overlayp");
5396 DEFSYM (Qevaporate
, "evaporate");
5397 DEFSYM (Qmodification_hooks
, "modification-hooks");
5398 DEFSYM (Qinsert_in_front_hooks
, "insert-in-front-hooks");
5399 DEFSYM (Qinsert_behind_hooks
, "insert-behind-hooks");
5400 DEFSYM (Qget_file_buffer
, "get-file-buffer");
5401 DEFSYM (Qpriority
, "priority");
5402 DEFSYM (Qbefore_string
, "before-string");
5403 DEFSYM (Qafter_string
, "after-string");
5404 DEFSYM (Qfirst_change_hook
, "first-change-hook");
5405 DEFSYM (Qbefore_change_functions
, "before-change-functions");
5406 DEFSYM (Qafter_change_functions
, "after-change-functions");
5407 DEFSYM (Qkill_buffer_query_functions
, "kill-buffer-query-functions");
5409 DEFSYM (Qvertical_scroll_bar
, "vertical-scroll-bar");
5410 Fput (Qvertical_scroll_bar
, Qchoice
, list4 (Qnil
, Qt
, Qleft
, Qright
));
5411 DEFSYM (Qhorizontal_scroll_bar
, "horizontal-scroll-bar");
5413 DEFSYM (Qfraction
, "fraction");
5414 Fput (Qfraction
, Qrange
, Fcons (make_float (0.0), make_float (1.0)));
5416 DEFSYM (Qoverwrite_mode
, "overwrite-mode");
5417 Fput (Qoverwrite_mode
, Qchoice
,
5418 list3 (Qnil
, intern ("overwrite-mode-textual"),
5419 intern ("overwrite-mode-binary")));
5421 Fput (Qprotected_field
, Qerror_conditions
,
5422 listn (CONSTYPE_PURE
, 2, Qprotected_field
, Qerror
));
5423 Fput (Qprotected_field
, Qerror_message
,
5424 build_pure_c_string ("Attempt to modify a protected field"));
5426 DEFVAR_BUFFER_DEFAULTS ("default-mode-line-format",
5428 doc
: /* Default value of `mode-line-format' for buffers that don't override it.
5429 This is the same as (default-value 'mode-line-format). */);
5431 DEFVAR_BUFFER_DEFAULTS ("default-header-line-format",
5433 doc
: /* Default value of `header-line-format' for buffers that don't override it.
5434 This is the same as (default-value 'header-line-format). */);
5436 DEFVAR_BUFFER_DEFAULTS ("default-cursor-type", cursor_type
,
5437 doc
: /* Default value of `cursor-type' for buffers that don't override it.
5438 This is the same as (default-value 'cursor-type). */);
5440 DEFVAR_BUFFER_DEFAULTS ("default-line-spacing",
5442 doc
: /* Default value of `line-spacing' for buffers that don't override it.
5443 This is the same as (default-value 'line-spacing). */);
5445 DEFVAR_BUFFER_DEFAULTS ("default-cursor-in-non-selected-windows",
5446 cursor_in_non_selected_windows
,
5447 doc
: /* Default value of `cursor-in-non-selected-windows'.
5448 This is the same as (default-value 'cursor-in-non-selected-windows). */);
5450 DEFVAR_BUFFER_DEFAULTS ("default-abbrev-mode",
5452 doc
: /* Default value of `abbrev-mode' for buffers that do not override it.
5453 This is the same as (default-value 'abbrev-mode). */);
5455 DEFVAR_BUFFER_DEFAULTS ("default-ctl-arrow",
5457 doc
: /* Default value of `ctl-arrow' for buffers that do not override it.
5458 This is the same as (default-value 'ctl-arrow). */);
5460 DEFVAR_BUFFER_DEFAULTS ("default-enable-multibyte-characters",
5461 enable_multibyte_characters
,
5462 doc
: /* Default value of `enable-multibyte-characters' for buffers not overriding it.
5463 This is the same as (default-value 'enable-multibyte-characters). */);
5465 DEFVAR_BUFFER_DEFAULTS ("default-buffer-file-coding-system",
5466 buffer_file_coding_system
,
5467 doc
: /* Default value of `buffer-file-coding-system' for buffers not overriding it.
5468 This is the same as (default-value 'buffer-file-coding-system). */);
5470 DEFVAR_BUFFER_DEFAULTS ("default-truncate-lines",
5472 doc
: /* Default value of `truncate-lines' for buffers that do not override it.
5473 This is the same as (default-value 'truncate-lines). */);
5475 DEFVAR_BUFFER_DEFAULTS ("default-fill-column",
5477 doc
: /* Default value of `fill-column' for buffers that do not override it.
5478 This is the same as (default-value 'fill-column). */);
5480 DEFVAR_BUFFER_DEFAULTS ("default-left-margin",
5482 doc
: /* Default value of `left-margin' for buffers that do not override it.
5483 This is the same as (default-value 'left-margin). */);
5485 DEFVAR_BUFFER_DEFAULTS ("default-tab-width",
5487 doc
: /* Default value of `tab-width' for buffers that do not override it.
5488 NOTE: This controls the display width of a TAB character, and not
5489 the size of an indentation step.
5490 This is the same as (default-value 'tab-width). */);
5492 DEFVAR_BUFFER_DEFAULTS ("default-case-fold-search",
5494 doc
: /* Default value of `case-fold-search' for buffers that don't override it.
5495 This is the same as (default-value 'case-fold-search). */);
5497 DEFVAR_BUFFER_DEFAULTS ("default-left-margin-width",
5499 doc
: /* Default value of `left-margin-width' for buffers that don't override it.
5500 This is the same as (default-value 'left-margin-width). */);
5502 DEFVAR_BUFFER_DEFAULTS ("default-right-margin-width",
5504 doc
: /* Default value of `right-margin-width' for buffers that don't override it.
5505 This is the same as (default-value 'right-margin-width). */);
5507 DEFVAR_BUFFER_DEFAULTS ("default-left-fringe-width",
5509 doc
: /* Default value of `left-fringe-width' for buffers that don't override it.
5510 This is the same as (default-value 'left-fringe-width). */);
5512 DEFVAR_BUFFER_DEFAULTS ("default-right-fringe-width",
5514 doc
: /* Default value of `right-fringe-width' for buffers that don't override it.
5515 This is the same as (default-value 'right-fringe-width). */);
5517 DEFVAR_BUFFER_DEFAULTS ("default-fringes-outside-margins",
5518 fringes_outside_margins
,
5519 doc
: /* Default value of `fringes-outside-margins' for buffers that don't override it.
5520 This is the same as (default-value 'fringes-outside-margins). */);
5522 DEFVAR_BUFFER_DEFAULTS ("default-scroll-bar-width",
5524 doc
: /* Default value of `scroll-bar-width' for buffers that don't override it.
5525 This is the same as (default-value 'scroll-bar-width). */);
5527 DEFVAR_BUFFER_DEFAULTS ("default-vertical-scroll-bar",
5528 vertical_scroll_bar_type
,
5529 doc
: /* Default value of `vertical-scroll-bar' for buffers that don't override it.
5530 This is the same as (default-value 'vertical-scroll-bar). */);
5532 DEFVAR_BUFFER_DEFAULTS ("default-indicate-empty-lines",
5533 indicate_empty_lines
,
5534 doc
: /* Default value of `indicate-empty-lines' for buffers that don't override it.
5535 This is the same as (default-value 'indicate-empty-lines). */);
5537 DEFVAR_BUFFER_DEFAULTS ("default-indicate-buffer-boundaries",
5538 indicate_buffer_boundaries
,
5539 doc
: /* Default value of `indicate-buffer-boundaries' for buffers that don't override it.
5540 This is the same as (default-value 'indicate-buffer-boundaries). */);
5542 DEFVAR_BUFFER_DEFAULTS ("default-fringe-indicator-alist",
5543 fringe_indicator_alist
,
5544 doc
: /* Default value of `fringe-indicator-alist' for buffers that don't override it.
5545 This is the same as (default-value 'fringe-indicator-alist'). */);
5547 DEFVAR_BUFFER_DEFAULTS ("default-fringe-cursor-alist",
5548 fringe_cursor_alist
,
5549 doc
: /* Default value of `fringe-cursor-alist' for buffers that don't override it.
5550 This is the same as (default-value 'fringe-cursor-alist'). */);
5552 DEFVAR_BUFFER_DEFAULTS ("default-scroll-up-aggressively",
5553 scroll_up_aggressively
,
5554 doc
: /* Default value of `scroll-up-aggressively'.
5555 This value applies in buffers that don't have their own local values.
5556 This is the same as (default-value 'scroll-up-aggressively). */);
5558 DEFVAR_BUFFER_DEFAULTS ("default-scroll-down-aggressively",
5559 scroll_down_aggressively
,
5560 doc
: /* Default value of `scroll-down-aggressively'.
5561 This value applies in buffers that don't have their own local values.
5562 This is the same as (default-value 'scroll-down-aggressively). */);
5564 DEFVAR_PER_BUFFER ("header-line-format",
5565 &BVAR (current_buffer
, header_line_format
),
5567 doc
: /* Analogous to `mode-line-format', but controls the header line.
5568 The header line appears, optionally, at the top of a window;
5569 the mode line appears at the bottom. */);
5571 DEFVAR_PER_BUFFER ("mode-line-format", &BVAR (current_buffer
, mode_line_format
),
5573 doc
: /* Template for displaying mode line for current buffer.
5575 The value may be nil, a string, a symbol or a list.
5577 A value of nil means don't display a mode line.
5579 For any symbol other than t or nil, the symbol's value is processed as
5580 a mode line construct. As a special exception, if that value is a
5581 string, the string is processed verbatim, without handling any
5582 %-constructs (see below). Also, unless the symbol has a non-nil
5583 `risky-local-variable' property, all properties in any strings, as
5584 well as all :eval and :propertize forms in the value, are ignored.
5586 A list whose car is a string or list is processed by processing each
5587 of the list elements recursively, as separate mode line constructs,
5588 and concatenating the results.
5590 A list of the form `(:eval FORM)' is processed by evaluating FORM and
5591 using the result as a mode line construct. Be careful--FORM should
5592 not load any files, because that can cause an infinite recursion.
5594 A list of the form `(:propertize ELT PROPS...)' is processed by
5595 processing ELT as the mode line construct, and adding the text
5596 properties PROPS to the result.
5598 A list whose car is a symbol is processed by examining the symbol's
5599 value, and, if that value is non-nil, processing the cadr of the list
5600 recursively; and if that value is nil, processing the caddr of the
5603 A list whose car is an integer is processed by processing the cadr of
5604 the list, and padding (if the number is positive) or truncating (if
5605 negative) to the width specified by that number.
5607 A string is printed verbatim in the mode line except for %-constructs:
5608 %b -- print buffer name. %f -- print visited file name.
5609 %F -- print frame name.
5610 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
5611 %& is like %*, but ignore read-only-ness.
5612 % means buffer is read-only and * means it is modified.
5613 For a modified read-only buffer, %* gives % and %+ gives *.
5614 %s -- print process status. %l -- print the current line number.
5615 %c -- print the current column number (this makes editing slower).
5616 To make the column number update correctly in all cases,
5617 `column-number-mode' must be non-nil.
5618 %i -- print the size of the buffer.
5619 %I -- like %i, but use k, M, G, etc., to abbreviate.
5620 %p -- print percent of buffer above top of window, or Top, Bot or All.
5621 %P -- print percent of buffer above bottom of window, perhaps plus Top,
5622 or print Bottom or All.
5623 %n -- print Narrow if appropriate.
5624 %t -- visited file is text or binary (if OS supports this distinction).
5625 %z -- print mnemonics of keyboard, terminal, and buffer coding systems.
5626 %Z -- like %z, but including the end-of-line format.
5627 %e -- print error message about full memory.
5628 %@ -- print @ or hyphen. @ means that default-directory is on a
5630 %[ -- print one [ for each recursive editing level. %] similar.
5631 %% -- print %. %- -- print infinitely many dashes.
5632 Decimal digits after the % specify field width to which to pad. */);
5634 DEFVAR_BUFFER_DEFAULTS ("default-major-mode", major_mode
,
5635 doc
: /* Value of `major-mode' for new buffers. */);
5637 DEFVAR_PER_BUFFER ("major-mode", &BVAR (current_buffer
, major_mode
),
5639 doc
: /* Symbol for current buffer's major mode.
5640 The default value (normally `fundamental-mode') affects new buffers.
5641 A value of nil means to use the current buffer's major mode, provided
5642 it is not marked as "special".
5644 When a mode is used by default, `find-file' switches to it before it
5645 reads the contents into the buffer and before it finishes setting up
5646 the buffer. Thus, the mode and its hooks should not expect certain
5647 variables such as `buffer-read-only' and `buffer-file-coding-system'
5650 DEFVAR_PER_BUFFER ("mode-name", &BVAR (current_buffer
, mode_name
),
5652 doc
: /* Pretty name of current buffer's major mode.
5653 Usually a string, but can use any of the constructs for `mode-line-format',
5655 Format with `format-mode-line' to produce a string value. */);
5657 DEFVAR_PER_BUFFER ("local-abbrev-table", &BVAR (current_buffer
, abbrev_table
), Qnil
,
5658 doc
: /* Local (mode-specific) abbrev table of current buffer. */);
5660 DEFVAR_PER_BUFFER ("abbrev-mode", &BVAR (current_buffer
, abbrev_mode
), Qnil
,
5661 doc
: /* Non-nil if Abbrev mode is enabled.
5662 Use the command `abbrev-mode' to change this variable. */);
5664 DEFVAR_PER_BUFFER ("case-fold-search", &BVAR (current_buffer
, case_fold_search
),
5666 doc
: /* Non-nil if searches and matches should ignore case. */);
5668 DEFVAR_PER_BUFFER ("fill-column", &BVAR (current_buffer
, fill_column
),
5670 doc
: /* Column beyond which automatic line-wrapping should happen.
5671 Interactively, you can set the buffer local value using \\[set-fill-column]. */);
5673 DEFVAR_PER_BUFFER ("left-margin", &BVAR (current_buffer
, left_margin
),
5675 doc
: /* Column for the default `indent-line-function' to indent to.
5676 Linefeed indents to this column in Fundamental mode. */);
5678 DEFVAR_PER_BUFFER ("tab-width", &BVAR (current_buffer
, tab_width
),
5680 doc
: /* Distance between tab stops (for display of tab characters), in columns.
5681 NOTE: This controls the display width of a TAB character, and not
5682 the size of an indentation step.
5683 This should be an integer greater than zero. */);
5685 DEFVAR_PER_BUFFER ("ctl-arrow", &BVAR (current_buffer
, ctl_arrow
), Qnil
,
5686 doc
: /* Non-nil means display control chars with uparrow.
5687 A value of nil means use backslash and octal digits.
5688 This variable does not apply to characters whose display is specified
5689 in the current display table (if there is one). */);
5691 DEFVAR_PER_BUFFER ("enable-multibyte-characters",
5692 &BVAR (current_buffer
, enable_multibyte_characters
),
5694 doc
: /* Non-nil means the buffer contents are regarded as multi-byte characters.
5695 Otherwise they are regarded as unibyte. This affects the display,
5696 file I/O and the behavior of various editing commands.
5698 This variable is buffer-local but you cannot set it directly;
5699 use the function `set-buffer-multibyte' to change a buffer's representation.
5700 See also Info node `(elisp)Text Representations'. */);
5701 XSYMBOL (intern_c_string ("enable-multibyte-characters"))->constant
= 1;
5703 DEFVAR_PER_BUFFER ("buffer-file-coding-system",
5704 &BVAR (current_buffer
, buffer_file_coding_system
), Qnil
,
5705 doc
: /* Coding system to be used for encoding the buffer contents on saving.
5706 This variable applies to saving the buffer, and also to `write-region'
5707 and other functions that use `write-region'.
5708 It does not apply to sending output to subprocesses, however.
5710 If this is nil, the buffer is saved without any code conversion
5711 unless some coding system is specified in `file-coding-system-alist'
5712 for the buffer file.
5714 If the text to be saved cannot be encoded as specified by this variable,
5715 an alternative encoding is selected by `select-safe-coding-system', which see.
5717 The variable `coding-system-for-write', if non-nil, overrides this variable.
5719 This variable is never applied to a way of decoding a file while reading it. */);
5721 DEFVAR_PER_BUFFER ("bidi-display-reordering",
5722 &BVAR (current_buffer
, bidi_display_reordering
), Qnil
,
5723 doc
: /* Non-nil means reorder bidirectional text for display in the visual order. */);
5725 DEFVAR_PER_BUFFER ("bidi-paragraph-direction",
5726 &BVAR (current_buffer
, bidi_paragraph_direction
), Qnil
,
5727 doc
: /* If non-nil, forces directionality of text paragraphs in the buffer.
5729 If this is nil (the default), the direction of each paragraph is
5730 determined by the first strong directional character of its text.
5731 The values of `right-to-left' and `left-to-right' override that.
5732 Any other value is treated as nil.
5734 This variable has no effect unless the buffer's value of
5735 \`bidi-display-reordering' is non-nil. */);
5737 DEFVAR_PER_BUFFER ("truncate-lines", &BVAR (current_buffer
, truncate_lines
), Qnil
,
5738 doc
: /* Non-nil means do not display continuation lines.
5739 Instead, give each line of text just one screen line.
5741 Note that this is overridden by the variable
5742 `truncate-partial-width-windows' if that variable is non-nil
5743 and this buffer is not full-frame width.
5745 Minibuffers set this variable to nil. */);
5747 DEFVAR_PER_BUFFER ("word-wrap", &BVAR (current_buffer
, word_wrap
), Qnil
,
5748 doc
: /* Non-nil means to use word-wrapping for continuation lines.
5749 When word-wrapping is on, continuation lines are wrapped at the space
5750 or tab character nearest to the right window edge.
5751 If nil, continuation lines are wrapped at the right screen edge.
5753 This variable has no effect if long lines are truncated (see
5754 `truncate-lines' and `truncate-partial-width-windows'). If you use
5755 word-wrapping, you might want to reduce the value of
5756 `truncate-partial-width-windows', since wrapping can make text readable
5757 in narrower windows.
5759 Instead of setting this variable directly, most users should use
5760 Visual Line mode . Visual Line mode, when enabled, sets `word-wrap'
5761 to t, and additionally redefines simple editing commands to act on
5762 visual lines rather than logical lines. See the documentation of
5763 `visual-line-mode'. */);
5765 DEFVAR_PER_BUFFER ("default-directory", &BVAR (current_buffer
, directory
),
5767 doc
: /* Name of default directory of current buffer. Should end with slash.
5768 To interactively change the default directory, use command `cd'. */);
5770 DEFVAR_PER_BUFFER ("auto-fill-function", &BVAR (current_buffer
, auto_fill_function
),
5772 doc
: /* Function called (if non-nil) to perform auto-fill.
5773 It is called after self-inserting any character specified in
5774 the `auto-fill-chars' table.
5775 NOTE: This variable is not a hook;
5776 its value may not be a list of functions. */);
5778 DEFVAR_PER_BUFFER ("buffer-file-name", &BVAR (current_buffer
, filename
),
5780 doc
: /* Name of file visited in current buffer, or nil if not visiting a file.
5781 This should be an absolute file name. */);
5783 DEFVAR_PER_BUFFER ("buffer-file-truename", &BVAR (current_buffer
, file_truename
),
5785 doc
: /* Abbreviated truename of file visited in current buffer, or nil if none.
5786 The truename of a file is calculated by `file-truename'
5787 and then abbreviated with `abbreviate-file-name'. */);
5789 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
5790 &BVAR (current_buffer
, auto_save_file_name
),
5792 doc
: /* Name of file for auto-saving current buffer.
5793 If it is nil, that means don't auto-save this buffer. */);
5795 DEFVAR_PER_BUFFER ("buffer-read-only", &BVAR (current_buffer
, read_only
), Qnil
,
5796 doc
: /* Non-nil if this buffer is read-only. */);
5798 DEFVAR_PER_BUFFER ("buffer-backed-up", &BVAR (current_buffer
, backed_up
), Qnil
,
5799 doc
: /* Non-nil if this buffer's file has been backed up.
5800 Backing up is done before the first time the file is saved. */);
5802 DEFVAR_PER_BUFFER ("buffer-saved-size", &BVAR (current_buffer
, save_length
),
5804 doc
: /* Length of current buffer when last read in, saved or auto-saved.
5806 -1 means auto-saving turned off until next real save.
5808 If you set this to -2, that means don't turn off auto-saving in this buffer
5809 if its text size shrinks. If you use `buffer-swap-text' on a buffer,
5810 you probably should set this to -2 in that buffer. */);
5812 DEFVAR_PER_BUFFER ("selective-display", &BVAR (current_buffer
, selective_display
),
5814 doc
: /* Non-nil enables selective display.
5815 An integer N as value means display only lines
5816 that start with less than N columns of space.
5817 A value of t means that the character ^M makes itself and
5818 all the rest of the line invisible; also, when saving the buffer
5819 in a file, save the ^M as a newline. */);
5821 DEFVAR_PER_BUFFER ("selective-display-ellipses",
5822 &BVAR (current_buffer
, selective_display_ellipses
),
5824 doc
: /* Non-nil means display ... on previous line when a line is invisible. */);
5826 DEFVAR_PER_BUFFER ("overwrite-mode", &BVAR (current_buffer
, overwrite_mode
),
5828 doc
: /* Non-nil if self-insertion should replace existing text.
5829 The value should be one of `overwrite-mode-textual',
5830 `overwrite-mode-binary', or nil.
5831 If it is `overwrite-mode-textual', self-insertion still
5832 inserts at the end of a line, and inserts when point is before a tab,
5833 until the tab is filled in.
5834 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too. */);
5836 DEFVAR_PER_BUFFER ("buffer-display-table", &BVAR (current_buffer
, display_table
),
5838 doc
: /* Display table that controls display of the contents of current buffer.
5840 If this variable is nil, the value of `standard-display-table' is used.
5841 Each window can have its own, overriding display table, see
5842 `set-window-display-table' and `window-display-table'.
5844 The display table is a char-table created with `make-display-table'.
5845 A char-table is an array indexed by character codes. Normal array
5846 primitives `aref' and `aset' can be used to access elements of a char-table.
5848 Each of the char-table elements control how to display the corresponding
5849 text character: the element at index C in the table says how to display
5850 the character whose code is C. Each element should be a vector of
5851 characters or nil. The value nil means display the character in the
5852 default fashion; otherwise, the characters from the vector are delivered
5853 to the screen instead of the original character.
5855 For example, (aset buffer-display-table ?X [?Y]) tells Emacs
5856 to display a capital Y instead of each X character.
5858 In addition, a char-table has six extra slots to control the display of:
5860 the end of a truncated screen line (extra-slot 0, a single character);
5861 the end of a continued line (extra-slot 1, a single character);
5862 the escape character used to display character codes in octal
5863 (extra-slot 2, a single character);
5864 the character used as an arrow for control characters (extra-slot 3,
5865 a single character);
5866 the decoration indicating the presence of invisible lines (extra-slot 4,
5867 a vector of characters);
5868 the character used to draw the border between side-by-side windows
5869 (extra-slot 5, a single character).
5871 See also the functions `display-table-slot' and `set-display-table-slot'. */);
5873 DEFVAR_PER_BUFFER ("left-margin-width", &BVAR (current_buffer
, left_margin_cols
),
5875 doc
: /* Width in columns of left marginal area for display of a buffer.
5876 A value of nil means no marginal area.
5878 Setting this variable does not take effect until a new buffer is displayed
5879 in a window. To make the change take effect, call `set-window-buffer'. */);
5881 DEFVAR_PER_BUFFER ("right-margin-width", &BVAR (current_buffer
, right_margin_cols
),
5883 doc
: /* Width in columns of right marginal area for display of a buffer.
5884 A value of nil means no marginal area.
5886 Setting this variable does not take effect until a new buffer is displayed
5887 in a window. To make the change take effect, call `set-window-buffer'. */);
5889 DEFVAR_PER_BUFFER ("left-fringe-width", &BVAR (current_buffer
, left_fringe_width
),
5891 doc
: /* Width of this buffer's left fringe (in pixels).
5892 A value of 0 means no left fringe is shown in this buffer's window.
5893 A value of nil means to use the left fringe width from the window's frame.
5895 Setting this variable does not take effect until a new buffer is displayed
5896 in a window. To make the change take effect, call `set-window-buffer'. */);
5898 DEFVAR_PER_BUFFER ("right-fringe-width", &BVAR (current_buffer
, right_fringe_width
),
5900 doc
: /* Width of this buffer's right fringe (in pixels).
5901 A value of 0 means no right fringe is shown in this buffer's window.
5902 A value of nil means to use the right fringe width from the window's frame.
5904 Setting this variable does not take effect until a new buffer is displayed
5905 in a window. To make the change take effect, call `set-window-buffer'. */);
5907 DEFVAR_PER_BUFFER ("fringes-outside-margins", &BVAR (current_buffer
, fringes_outside_margins
),
5909 doc
: /* Non-nil means to display fringes outside display margins.
5910 A value of nil means to display fringes between margins and buffer text.
5912 Setting this variable does not take effect until a new buffer is displayed
5913 in a window. To make the change take effect, call `set-window-buffer'. */);
5915 DEFVAR_PER_BUFFER ("scroll-bar-width", &BVAR (current_buffer
, scroll_bar_width
),
5917 doc
: /* Width of this buffer's vertical scroll bars in pixels.
5918 A value of nil means to use the scroll bar width from the window's frame. */);
5920 DEFVAR_PER_BUFFER ("scroll-bar-height", &BVAR (current_buffer
, scroll_bar_height
),
5922 doc
: /* Height of this buffer's horizontal scroll bars in pixels.
5923 A value of nil means to use the scroll bar height from the window's frame. */);
5925 DEFVAR_PER_BUFFER ("vertical-scroll-bar", &BVAR (current_buffer
, vertical_scroll_bar_type
),
5926 Qvertical_scroll_bar
,
5927 doc
: /* Position of this buffer's vertical scroll bar.
5928 The value takes effect whenever you tell a window to display this buffer;
5929 for instance, with `set-window-buffer' or when `display-buffer' displays it.
5931 A value of `left' or `right' means put the vertical scroll bar at that side
5932 of the window; a value of nil means don't show any vertical scroll bars.
5933 A value of t (the default) means do whatever the window's frame specifies. */);
5935 DEFVAR_PER_BUFFER ("horizontal-scroll-bar", &BVAR (current_buffer
, horizontal_scroll_bar_type
),
5937 doc
: /* Position of this buffer's horizontal scroll bar.
5938 The value takes effect whenever you tell a window to display this buffer;
5939 for instance, with `set-window-buffer' or when `display-buffer' displays it.
5941 A value of `bottom' means put the horizontal scroll bar at the bottom of
5942 the window; a value of nil means don't show any horizontal scroll bars.
5943 A value of t (the default) means do whatever the window's frame
5946 DEFVAR_PER_BUFFER ("indicate-empty-lines",
5947 &BVAR (current_buffer
, indicate_empty_lines
), Qnil
,
5948 doc
: /* Visually indicate empty lines after the buffer end.
5949 If non-nil, a bitmap is displayed in the left fringe of a window on
5950 window-systems. */);
5952 DEFVAR_PER_BUFFER ("indicate-buffer-boundaries",
5953 &BVAR (current_buffer
, indicate_buffer_boundaries
), Qnil
,
5954 doc
: /* Visually indicate buffer boundaries and scrolling.
5955 If non-nil, the first and last line of the buffer are marked in the fringe
5956 of a window on window-systems with angle bitmaps, or if the window can be
5957 scrolled, the top and bottom line of the window are marked with up and down
5960 If value is a symbol `left' or `right', both angle and arrow bitmaps
5961 are displayed in the left or right fringe, resp. Any other value
5962 that doesn't look like an alist means display the angle bitmaps in
5963 the left fringe but no arrows.
5965 You can exercise more precise control by using an alist as the
5966 value. Each alist element (INDICATOR . POSITION) specifies
5967 where to show one of the indicators. INDICATOR is one of `top',
5968 `bottom', `up', `down', or t, which specifies the default position,
5969 and POSITION is one of `left', `right', or nil, meaning do not show
5972 For example, ((top . left) (t . right)) places the top angle bitmap in
5973 left fringe, the bottom angle bitmap in right fringe, and both arrow
5974 bitmaps in right fringe. To show just the angle bitmaps in the left
5975 fringe, but no arrow bitmaps, use ((top . left) (bottom . left)). */);
5977 DEFVAR_PER_BUFFER ("fringe-indicator-alist",
5978 &BVAR (current_buffer
, fringe_indicator_alist
), Qnil
,
5979 doc
: /* Mapping from logical to physical fringe indicator bitmaps.
5980 The value is an alist where each element (INDICATOR . BITMAPS)
5981 specifies the fringe bitmaps used to display a specific logical
5984 INDICATOR specifies the logical indicator type which is one of the
5985 following symbols: `truncation' , `continuation', `overlay-arrow',
5986 `top', `bottom', `top-bottom', `up', `down', empty-line', or `unknown'.
5988 BITMAPS is a list of symbols (LEFT RIGHT [LEFT1 RIGHT1]) which specifies
5989 the actual bitmap shown in the left or right fringe for the logical
5990 indicator. LEFT and RIGHT are the bitmaps shown in the left and/or
5991 right fringe for the specific indicator. The LEFT1 or RIGHT1 bitmaps
5992 are used only for the `bottom' and `top-bottom' indicators when the
5993 last (only) line has no final newline. BITMAPS may also be a single
5994 symbol which is used in both left and right fringes. */);
5996 DEFVAR_PER_BUFFER ("fringe-cursor-alist",
5997 &BVAR (current_buffer
, fringe_cursor_alist
), Qnil
,
5998 doc
: /* Mapping from logical to physical fringe cursor bitmaps.
5999 The value is an alist where each element (CURSOR . BITMAP)
6000 specifies the fringe bitmaps used to display a specific logical
6001 cursor type in the fringe.
6003 CURSOR specifies the logical cursor type which is one of the following
6004 symbols: `box' , `hollow', `bar', `hbar', or `hollow-small'. The last
6005 one is used to show a hollow cursor on narrow lines display lines
6006 where the normal hollow cursor will not fit.
6008 BITMAP is the corresponding fringe bitmap shown for the logical
6011 DEFVAR_PER_BUFFER ("scroll-up-aggressively",
6012 &BVAR (current_buffer
, scroll_up_aggressively
), Qfraction
,
6013 doc
: /* How far to scroll windows upward.
6014 If you move point off the bottom, the window scrolls automatically.
6015 This variable controls how far it scrolls. The value nil, the default,
6016 means scroll to center point. A fraction means scroll to put point
6017 that fraction of the window's height from the bottom of the window.
6018 When the value is 0.0, point goes at the bottom line, which in the
6019 simple case that you moved off with C-f means scrolling just one line.
6020 1.0 means point goes at the top, so that in that simple case, the
6021 window scrolls by a full window height. Meaningful values are
6022 between 0.0 and 1.0, inclusive. */);
6024 DEFVAR_PER_BUFFER ("scroll-down-aggressively",
6025 &BVAR (current_buffer
, scroll_down_aggressively
), Qfraction
,
6026 doc
: /* How far to scroll windows downward.
6027 If you move point off the top, the window scrolls automatically.
6028 This variable controls how far it scrolls. The value nil, the default,
6029 means scroll to center point. A fraction means scroll to put point
6030 that fraction of the window's height from the top of the window.
6031 When the value is 0.0, point goes at the top line, which in the
6032 simple case that you moved off with C-b means scrolling just one line.
6033 1.0 means point goes at the bottom, so that in that simple case, the
6034 window scrolls by a full window height. Meaningful values are
6035 between 0.0 and 1.0, inclusive. */);
6037 DEFVAR_LISP ("before-change-functions", Vbefore_change_functions
,
6038 doc
: /* List of functions to call before each text change.
6039 Two arguments are passed to each function: the positions of
6040 the beginning and end of the range of old text to be changed.
6041 \(For an insertion, the beginning and end are at the same place.)
6042 No information is given about the length of the text after the change.
6044 Buffer changes made while executing the `before-change-functions'
6045 don't call any before-change or after-change functions.
6046 That's because `inhibit-modification-hooks' is temporarily set non-nil.
6048 If an unhandled error happens in running these functions,
6049 the variable's value remains nil. That prevents the error
6050 from happening repeatedly and making Emacs nonfunctional. */);
6051 Vbefore_change_functions
= Qnil
;
6053 DEFVAR_LISP ("after-change-functions", Vafter_change_functions
,
6054 doc
: /* List of functions to call after each text change.
6055 Three arguments are passed to each function: the positions of
6056 the beginning and end of the range of changed text,
6057 and the length in chars of the pre-change text replaced by that range.
6058 \(For an insertion, the pre-change length is zero;
6059 for a deletion, that length is the number of chars deleted,
6060 and the post-change beginning and end are at the same place.)
6062 Buffer changes made while executing the `after-change-functions'
6063 don't call any before-change or after-change functions.
6064 That's because `inhibit-modification-hooks' is temporarily set non-nil.
6066 If an unhandled error happens in running these functions,
6067 the variable's value remains nil. That prevents the error
6068 from happening repeatedly and making Emacs nonfunctional. */);
6069 Vafter_change_functions
= Qnil
;
6071 DEFVAR_LISP ("first-change-hook", Vfirst_change_hook
,
6072 doc
: /* A list of functions to call before changing a buffer which is unmodified.
6073 The functions are run using the `run-hooks' function. */);
6074 Vfirst_change_hook
= Qnil
;
6076 DEFVAR_PER_BUFFER ("buffer-undo-list", &BVAR (current_buffer
, undo_list
), Qnil
,
6077 doc
: /* List of undo entries in current buffer.
6078 Recent changes come first; older changes follow newer.
6080 An entry (BEG . END) represents an insertion which begins at
6081 position BEG and ends at position END.
6083 An entry (TEXT . POSITION) represents the deletion of the string TEXT
6084 from (abs POSITION). If POSITION is positive, point was at the front
6085 of the text being deleted; if negative, point was at the end.
6087 An entry (t HIGH LOW USEC PSEC) indicates that the buffer was previously
6088 unmodified; (HIGH LOW USEC PSEC) is in the same style as (current-time)
6089 and is the visited file's modification time, as of that time. If the
6090 modification time of the most recent save is different, this entry is
6093 An entry (t . 0) means means the buffer was previously unmodified but
6094 its time stamp was unknown because it was not associated with a file.
6095 An entry (t . -1) is similar, except that it means the buffer's visited
6098 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
6099 was modified between BEG and END. PROPERTY is the property name,
6100 and VALUE is the old value.
6102 An entry (apply FUN-NAME . ARGS) means undo the change with
6103 \(apply FUN-NAME ARGS).
6105 An entry (apply DELTA BEG END FUN-NAME . ARGS) supports selective undo
6106 in the active region. BEG and END is the range affected by this entry
6107 and DELTA is the number of characters added or deleted in that range by
6110 An entry (MARKER . DISTANCE) indicates that the marker MARKER
6111 was adjusted in position by the offset DISTANCE (an integer).
6113 An entry of the form POSITION indicates that point was at the buffer
6114 location given by the integer. Undoing an entry of this form places
6117 Entries with value `nil' mark undo boundaries. The undo command treats
6118 the changes between two undo boundaries as a single step to be undone.
6120 If the value of the variable is t, undo information is not recorded. */);
6122 DEFVAR_PER_BUFFER ("mark-active", &BVAR (current_buffer
, mark_active
), Qnil
,
6123 doc
: /* Non-nil means the mark and region are currently active in this buffer. */);
6125 DEFVAR_PER_BUFFER ("cache-long-scans", &BVAR (current_buffer
, cache_long_scans
), Qnil
,
6126 doc
: /* Non-nil means that Emacs should use caches in attempt to speedup buffer scans.
6128 There is no reason to set this to nil except for debugging purposes.
6130 Normally, the line-motion functions work by scanning the buffer for
6131 newlines. Columnar operations (like `move-to-column' and
6132 `compute-motion') also work by scanning the buffer, summing character
6133 widths as they go. This works well for ordinary text, but if the
6134 buffer's lines are very long (say, more than 500 characters), these
6135 motion functions will take longer to execute. Emacs may also take
6136 longer to update the display.
6138 If `cache-long-scans' is non-nil, these motion functions cache the
6139 results of their scans, and consult the cache to avoid rescanning
6140 regions of the buffer until the text is modified. The caches are most
6141 beneficial when they prevent the most searching---that is, when the
6142 buffer contains long lines and large regions of characters with the
6143 same, fixed screen width.
6145 When `cache-long-scans' is non-nil, processing short lines will
6146 become slightly slower (because of the overhead of consulting the
6147 cache), and the caches will use memory roughly proportional to the
6148 number of newlines and characters whose screen width varies.
6150 Bidirectional editing also requires buffer scans to find paragraph
6151 separators. If you have large paragraphs or no paragraph separators
6152 at all, these scans may be slow. If `cache-long-scans' is non-nil,
6153 results of these scans are cached. This doesn't help too much if
6154 paragraphs are of the reasonable (few thousands of characters) size.
6156 The caches require no explicit maintenance; their accuracy is
6157 maintained internally by the Emacs primitives. Enabling or disabling
6158 the cache should not affect the behavior of any of the motion
6159 functions; it should only affect their performance. */);
6161 DEFVAR_PER_BUFFER ("point-before-scroll", &BVAR (current_buffer
, point_before_scroll
), Qnil
,
6162 doc
: /* Value of point before the last series of scroll operations, or nil. */);
6164 DEFVAR_PER_BUFFER ("buffer-file-format", &BVAR (current_buffer
, file_format
), Qnil
,
6165 doc
: /* List of formats to use when saving this buffer.
6166 Formats are defined by `format-alist'. This variable is
6167 set when a file is visited. */);
6169 DEFVAR_PER_BUFFER ("buffer-auto-save-file-format",
6170 &BVAR (current_buffer
, auto_save_file_format
), Qnil
,
6171 doc
: /* Format in which to write auto-save files.
6172 Should be a list of symbols naming formats that are defined in `format-alist'.
6173 If it is t, which is the default, auto-save files are written in the
6174 same format as a regular save would use. */);
6176 DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
6177 &BVAR (current_buffer
, invisibility_spec
), Qnil
,
6178 doc
: /* Invisibility spec of this buffer.
6179 The default is t, which means that text is invisible if it has a non-nil
6180 `invisible' property.
6181 This variable can also be a list. The list can have two kinds of elements:
6182 `ATOM' and `(ATOM . ELLIPSIS)'. A text character is invisible if its
6183 `invisible' property is `ATOM', or has an `invisible' property that is a list
6184 that contains `ATOM'.
6185 If the `(ATOM . ELLIPSIS)' form is used, and `ELLIPSIS' is non-nil, an
6186 ellipsis will be displayed after the invisible characters.
6187 Setting this variable is very fast, much faster than scanning all the text in
6188 the buffer looking for properties to change. */);
6190 DEFVAR_PER_BUFFER ("buffer-display-count",
6191 &BVAR (current_buffer
, display_count
), Qintegerp
,
6192 doc
: /* A number incremented each time this buffer is displayed in a window.
6193 The function `set-window-buffer' increments it. */);
6195 DEFVAR_PER_BUFFER ("buffer-display-time",
6196 &BVAR (current_buffer
, display_time
), Qnil
,
6197 doc
: /* Time stamp updated each time this buffer is displayed in a window.
6198 The function `set-window-buffer' updates this variable
6199 to the value obtained by calling `current-time'.
6200 If the buffer has never been shown in a window, the value is nil. */);
6202 DEFVAR_LISP ("transient-mark-mode", Vtransient_mark_mode
,
6203 doc
: /* Non-nil if Transient Mark mode is enabled.
6204 See the command `transient-mark-mode' for a description of this minor mode.
6206 Non-nil also enables highlighting of the region whenever the mark is active.
6207 The variable `highlight-nonselected-windows' controls whether to highlight
6208 all windows or just the selected window.
6210 Lisp programs may give this variable certain special values:
6212 - A value of `lambda' enables Transient Mark mode temporarily.
6213 It is disabled again after any subsequent action that would
6214 normally deactivate the mark (e.g. buffer modification).
6216 - A value of (only . OLDVAL) enables Transient Mark mode
6217 temporarily. After any subsequent point motion command that is
6218 not shift-translated, or any other action that would normally
6219 deactivate the mark (e.g. buffer modification), the value of
6220 `transient-mark-mode' is set to OLDVAL. */);
6221 Vtransient_mark_mode
= Qnil
;
6223 DEFVAR_LISP ("inhibit-read-only", Vinhibit_read_only
,
6224 doc
: /* Non-nil means disregard read-only status of buffers or characters.
6225 If the value is t, disregard `buffer-read-only' and all `read-only'
6226 text properties. If the value is a list, disregard `buffer-read-only'
6227 and disregard a `read-only' text property if the property value
6228 is a member of the list. */);
6229 Vinhibit_read_only
= Qnil
;
6231 DEFVAR_PER_BUFFER ("cursor-type", &BVAR (current_buffer
, cursor_type
), Qnil
,
6232 doc
: /* Cursor to use when this buffer is in the selected window.
6233 Values are interpreted as follows:
6235 t use the cursor specified for the frame
6236 nil don't display a cursor
6237 box display a filled box cursor
6238 hollow display a hollow box cursor
6239 bar display a vertical bar cursor with default width
6240 (bar . WIDTH) display a vertical bar cursor with width WIDTH
6241 hbar display a horizontal bar cursor with default height
6242 (hbar . HEIGHT) display a horizontal bar cursor with height HEIGHT
6243 ANYTHING ELSE display a hollow box cursor
6245 When the buffer is displayed in a non-selected window, the
6246 cursor's appearance is instead controlled by the variable
6247 `cursor-in-non-selected-windows'. */);
6249 DEFVAR_PER_BUFFER ("line-spacing",
6250 &BVAR (current_buffer
, extra_line_spacing
), Qnumberp
,
6251 doc
: /* Additional space to put between lines when displaying a buffer.
6252 The space is measured in pixels, and put below lines on graphic displays,
6253 see `display-graphic-p'.
6254 If value is a floating point number, it specifies the spacing relative
6255 to the default frame line height. A value of nil means add no extra space. */);
6257 DEFVAR_PER_BUFFER ("cursor-in-non-selected-windows",
6258 &BVAR (current_buffer
, cursor_in_non_selected_windows
), Qnil
,
6259 doc
: /* Non-nil means show a cursor in non-selected windows.
6260 If nil, only shows a cursor in the selected window.
6261 If t, displays a cursor related to the usual cursor type
6262 \(a solid box becomes hollow, a bar becomes a narrower bar).
6263 You can also specify the cursor type as in the `cursor-type' variable.
6264 Use Custom to set this variable and update the display." */);
6266 DEFVAR_LISP ("kill-buffer-query-functions", Vkill_buffer_query_functions
,
6267 doc
: /* List of functions called with no args to query before killing a buffer.
6268 The buffer being killed will be current while the functions are running.
6270 If any of them returns nil, the buffer is not killed. Functions run by
6271 this hook are supposed to not change the current buffer. */);
6272 Vkill_buffer_query_functions
= Qnil
;
6274 DEFVAR_LISP ("change-major-mode-hook", Vchange_major_mode_hook
,
6275 doc
: /* Normal hook run before changing the major mode of a buffer.
6276 The function `kill-all-local-variables' runs this before doing anything else. */);
6277 Vchange_major_mode_hook
= Qnil
;
6278 DEFSYM (Qchange_major_mode_hook
, "change-major-mode-hook");
6280 DEFVAR_LISP ("buffer-list-update-hook", Vbuffer_list_update_hook
,
6281 doc
: /* Hook run when the buffer list changes.
6282 Functions running this hook are, `get-buffer-create',
6283 `make-indirect-buffer', `rename-buffer', `kill-buffer',
6284 `bury-buffer-internal' and `select-window'. */);
6285 Vbuffer_list_update_hook
= Qnil
;
6286 DEFSYM (Qbuffer_list_update_hook
, "buffer-list-update-hook");
6288 defsubr (&Sbuffer_live_p
);
6289 defsubr (&Sbuffer_list
);
6290 defsubr (&Sget_buffer
);
6291 defsubr (&Sget_file_buffer
);
6292 defsubr (&Sget_buffer_create
);
6293 defsubr (&Smake_indirect_buffer
);
6294 defsubr (&Sgenerate_new_buffer_name
);
6295 defsubr (&Sbuffer_name
);
6296 defsubr (&Sbuffer_file_name
);
6297 defsubr (&Sbuffer_base_buffer
);
6298 defsubr (&Sbuffer_local_value
);
6299 defsubr (&Sbuffer_local_variables
);
6300 defsubr (&Sbuffer_modified_p
);
6301 defsubr (&Sforce_mode_line_update
);
6302 defsubr (&Sset_buffer_modified_p
);
6303 defsubr (&Sbuffer_modified_tick
);
6304 defsubr (&Sbuffer_chars_modified_tick
);
6305 defsubr (&Srename_buffer
);
6306 defsubr (&Sother_buffer
);
6307 defsubr (&Sbuffer_enable_undo
);
6308 defsubr (&Skill_buffer
);
6309 defsubr (&Sbury_buffer_internal
);
6310 defsubr (&Sset_buffer_major_mode
);
6311 defsubr (&Scurrent_buffer
);
6312 defsubr (&Sset_buffer
);
6313 defsubr (&Sbarf_if_buffer_read_only
);
6314 defsubr (&Serase_buffer
);
6315 defsubr (&Sbuffer_swap_text
);
6316 defsubr (&Sset_buffer_multibyte
);
6317 defsubr (&Skill_all_local_variables
);
6319 defsubr (&Soverlayp
);
6320 defsubr (&Smake_overlay
);
6321 defsubr (&Sdelete_overlay
);
6322 defsubr (&Sdelete_all_overlays
);
6323 defsubr (&Smove_overlay
);
6324 defsubr (&Soverlay_start
);
6325 defsubr (&Soverlay_end
);
6326 defsubr (&Soverlay_buffer
);
6327 defsubr (&Soverlay_properties
);
6328 defsubr (&Soverlays_at
);
6329 defsubr (&Soverlays_in
);
6330 defsubr (&Snext_overlay_change
);
6331 defsubr (&Sprevious_overlay_change
);
6332 defsubr (&Soverlay_recenter
);
6333 defsubr (&Soverlay_lists
);
6334 defsubr (&Soverlay_get
);
6335 defsubr (&Soverlay_put
);
6336 defsubr (&Srestore_buffer_modified_p
);
6340 keys_of_buffer (void)
6342 initial_define_key (control_x_map
, 'b', "switch-to-buffer");
6343 initial_define_key (control_x_map
, 'k', "kill-buffer");
6345 /* This must not be in syms_of_buffer, because Qdisabled is not
6346 initialized when that function gets called. */
6347 Fput (intern_c_string ("erase-buffer"), Qdisabled
, Qt
);