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>
34 #include "intervals.h"
38 #include "character.h"
40 #include "region-cache.h"
42 #include "blockinput.h"
47 #include "w32heap.h" /* for mmap_* */
50 struct buffer
*current_buffer
; /* The current buffer. */
52 /* First buffer in chain of all buffers (in reverse order of creation).
53 Threaded through ->header.next.buffer. */
55 struct buffer
*all_buffers
;
57 /* This structure holds the default values of the buffer-local variables
58 defined with DEFVAR_PER_BUFFER, that have special slots in each buffer.
59 The default value occupies the same slot in this structure
60 as an individual buffer's value occupies in that buffer.
61 Setting the default value also goes through the alist of buffers
62 and stores into each buffer that does not say it has a local value. */
64 struct buffer
alignas (GCALIGNMENT
) buffer_defaults
;
66 /* This structure marks which slots in a buffer have corresponding
67 default values in buffer_defaults.
68 Each such slot has a nonzero value in this structure.
69 The value has only one nonzero bit.
71 When a buffer has its own local value for a slot,
72 the entry for that slot (found in the same slot in this structure)
73 is turned on in the buffer's local_flags array.
75 If a slot in this structure is -1, then even though there may
76 be a DEFVAR_PER_BUFFER for the slot, there is no default value for it;
77 and the corresponding slot in buffer_defaults is not used.
79 If a slot in this structure corresponding to a DEFVAR_PER_BUFFER is
80 zero, that is a bug. */
82 struct buffer buffer_local_flags
;
84 /* This structure holds the names of symbols whose values may be
85 buffer-local. It is indexed and accessed in the same way as the above. */
87 struct buffer
alignas (GCALIGNMENT
) buffer_local_symbols
;
89 /* Return the symbol of the per-buffer variable at offset OFFSET in
90 the buffer structure. */
92 #define PER_BUFFER_SYMBOL(OFFSET) \
93 (*(Lisp_Object *)((OFFSET) + (char *) &buffer_local_symbols))
95 /* Maximum length of an overlay vector. */
96 #define OVERLAY_COUNT_MAX \
97 ((ptrdiff_t) min (MOST_POSITIVE_FIXNUM, \
98 min (PTRDIFF_MAX, SIZE_MAX) / word_size))
100 /* Flags indicating which built-in buffer-local variables
101 are permanent locals. */
102 static char buffer_permanent_local_flags
[MAX_PER_BUFFER_VARS
];
104 /* Number of per-buffer variables used. */
106 int last_per_buffer_idx
;
108 static void call_overlay_mod_hooks (Lisp_Object list
, Lisp_Object overlay
,
109 bool after
, Lisp_Object arg1
,
110 Lisp_Object arg2
, Lisp_Object arg3
);
111 static void swap_out_buffer_local_variables (struct buffer
*b
);
112 static void reset_buffer_local_variables (struct buffer
*, bool);
114 /* Alist of all buffer names vs the buffers. This used to be
115 a Lisp-visible variable, but is no longer, to prevent lossage
116 due to user rplac'ing this alist or its elements. */
117 Lisp_Object Vbuffer_alist
;
119 static Lisp_Object QSFundamental
; /* A string "Fundamental". */
121 static void alloc_buffer_text (struct buffer
*, ptrdiff_t);
122 static void free_buffer_text (struct buffer
*b
);
123 static struct Lisp_Overlay
* copy_overlays (struct buffer
*, struct Lisp_Overlay
*);
124 static void modify_overlay (struct buffer
*, ptrdiff_t, ptrdiff_t);
125 static Lisp_Object
buffer_lisp_local_variables (struct buffer
*, bool);
128 CHECK_OVERLAY (Lisp_Object x
)
130 CHECK_TYPE (OVERLAYP (x
), Qoverlayp
, x
);
133 /* These setters are used only in this file, so they can be private.
134 The public setters are inline functions defined in buffer.h. */
136 bset_abbrev_mode (struct buffer
*b
, Lisp_Object val
)
138 b
->abbrev_mode_
= val
;
141 bset_abbrev_table (struct buffer
*b
, Lisp_Object val
)
143 b
->abbrev_table_
= val
;
146 bset_auto_fill_function (struct buffer
*b
, Lisp_Object val
)
148 b
->auto_fill_function_
= val
;
151 bset_auto_save_file_format (struct buffer
*b
, Lisp_Object val
)
153 b
->auto_save_file_format_
= val
;
156 bset_auto_save_file_name (struct buffer
*b
, Lisp_Object val
)
158 b
->auto_save_file_name_
= val
;
161 bset_backed_up (struct buffer
*b
, Lisp_Object val
)
166 bset_begv_marker (struct buffer
*b
, Lisp_Object val
)
168 b
->begv_marker_
= val
;
171 bset_bidi_display_reordering (struct buffer
*b
, Lisp_Object val
)
173 b
->bidi_display_reordering_
= val
;
176 bset_buffer_file_coding_system (struct buffer
*b
, Lisp_Object val
)
178 b
->buffer_file_coding_system_
= val
;
181 bset_case_fold_search (struct buffer
*b
, Lisp_Object val
)
183 b
->case_fold_search_
= val
;
186 bset_ctl_arrow (struct buffer
*b
, Lisp_Object val
)
191 bset_cursor_in_non_selected_windows (struct buffer
*b
, Lisp_Object val
)
193 b
->cursor_in_non_selected_windows_
= val
;
196 bset_cursor_type (struct buffer
*b
, Lisp_Object val
)
198 b
->cursor_type_
= val
;
201 bset_display_table (struct buffer
*b
, Lisp_Object val
)
203 b
->display_table_
= val
;
206 bset_extra_line_spacing (struct buffer
*b
, Lisp_Object val
)
208 b
->extra_line_spacing_
= val
;
211 bset_file_format (struct buffer
*b
, Lisp_Object val
)
213 b
->file_format_
= val
;
216 bset_file_truename (struct buffer
*b
, Lisp_Object val
)
218 b
->file_truename_
= val
;
221 bset_fringe_cursor_alist (struct buffer
*b
, Lisp_Object val
)
223 b
->fringe_cursor_alist_
= val
;
226 bset_fringe_indicator_alist (struct buffer
*b
, Lisp_Object val
)
228 b
->fringe_indicator_alist_
= val
;
231 bset_fringes_outside_margins (struct buffer
*b
, Lisp_Object val
)
233 b
->fringes_outside_margins_
= val
;
236 bset_header_line_format (struct buffer
*b
, Lisp_Object val
)
238 b
->header_line_format_
= val
;
241 bset_indicate_buffer_boundaries (struct buffer
*b
, Lisp_Object val
)
243 b
->indicate_buffer_boundaries_
= val
;
246 bset_indicate_empty_lines (struct buffer
*b
, Lisp_Object val
)
248 b
->indicate_empty_lines_
= val
;
251 bset_invisibility_spec (struct buffer
*b
, Lisp_Object val
)
253 b
->invisibility_spec_
= val
;
256 bset_left_fringe_width (struct buffer
*b
, Lisp_Object val
)
258 b
->left_fringe_width_
= val
;
261 bset_major_mode (struct buffer
*b
, Lisp_Object val
)
263 b
->major_mode_
= val
;
266 bset_mark (struct buffer
*b
, Lisp_Object val
)
271 bset_minor_modes (struct buffer
*b
, Lisp_Object val
)
273 b
->minor_modes_
= val
;
276 bset_mode_line_format (struct buffer
*b
, Lisp_Object val
)
278 b
->mode_line_format_
= val
;
281 bset_mode_name (struct buffer
*b
, Lisp_Object val
)
286 bset_name (struct buffer
*b
, Lisp_Object val
)
291 bset_overwrite_mode (struct buffer
*b
, Lisp_Object val
)
293 b
->overwrite_mode_
= val
;
296 bset_pt_marker (struct buffer
*b
, Lisp_Object val
)
301 bset_right_fringe_width (struct buffer
*b
, Lisp_Object val
)
303 b
->right_fringe_width_
= val
;
306 bset_save_length (struct buffer
*b
, Lisp_Object val
)
308 b
->save_length_
= val
;
311 bset_scroll_bar_width (struct buffer
*b
, Lisp_Object val
)
313 b
->scroll_bar_width_
= val
;
316 bset_scroll_bar_height (struct buffer
*b
, Lisp_Object val
)
318 b
->scroll_bar_height_
= val
;
321 bset_scroll_down_aggressively (struct buffer
*b
, Lisp_Object val
)
323 b
->scroll_down_aggressively_
= val
;
326 bset_scroll_up_aggressively (struct buffer
*b
, Lisp_Object val
)
328 b
->scroll_up_aggressively_
= val
;
331 bset_selective_display (struct buffer
*b
, Lisp_Object val
)
333 b
->selective_display_
= val
;
336 bset_selective_display_ellipses (struct buffer
*b
, Lisp_Object val
)
338 b
->selective_display_ellipses_
= val
;
341 bset_vertical_scroll_bar_type (struct buffer
*b
, Lisp_Object val
)
343 b
->vertical_scroll_bar_type_
= val
;
346 bset_horizontal_scroll_bar_type (struct buffer
*b
, Lisp_Object val
)
348 b
->horizontal_scroll_bar_type_
= val
;
351 bset_word_wrap (struct buffer
*b
, Lisp_Object val
)
356 bset_zv_marker (struct buffer
*b
, Lisp_Object val
)
362 nsberror (Lisp_Object spec
)
365 error ("No buffer named %s", SDATA (spec
));
366 error ("Invalid buffer argument");
369 DEFUN ("buffer-live-p", Fbuffer_live_p
, Sbuffer_live_p
, 1, 1, 0,
370 doc
: /* Return non-nil if OBJECT is a buffer which has not been killed.
371 Value is nil if OBJECT is not a buffer or if it has been killed. */)
374 return ((BUFFERP (object
) && BUFFER_LIVE_P (XBUFFER (object
)))
378 DEFUN ("buffer-list", Fbuffer_list
, Sbuffer_list
, 0, 1, 0,
379 doc
: /* Return a list of all existing live buffers.
380 If the optional arg FRAME is a frame, we return the buffer list in the
381 proper order for that frame: the buffers show in FRAME come first,
382 followed by the rest of the buffers. */)
386 general
= Fmapcar (Qcdr
, Vbuffer_alist
);
390 Lisp_Object framelist
, prevlist
, tail
;
392 framelist
= Fcopy_sequence (XFRAME (frame
)->buffer_list
);
393 prevlist
= Fnreverse (Fcopy_sequence
394 (XFRAME (frame
)->buried_buffer_list
));
396 /* Remove from GENERAL any buffer that duplicates one in
397 FRAMELIST or PREVLIST. */
401 general
= Fdelq (XCAR (tail
), general
);
407 general
= Fdelq (XCAR (tail
), general
);
411 return CALLN (Fnconc
, framelist
, general
, prevlist
);
417 /* Like Fassoc, but use Fstring_equal to compare
418 (which ignores text properties),
419 and don't ever QUIT. */
422 assoc_ignore_text_properties (register Lisp_Object key
, Lisp_Object list
)
424 register Lisp_Object tail
;
425 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
427 register Lisp_Object elt
, tem
;
429 tem
= Fstring_equal (Fcar (elt
), key
);
436 DEFUN ("get-buffer", Fget_buffer
, Sget_buffer
, 1, 1, 0,
437 doc
: /* Return the buffer named BUFFER-OR-NAME.
438 BUFFER-OR-NAME must be either a string or a buffer. If BUFFER-OR-NAME
439 is a string and there is no buffer with that name, return nil. If
440 BUFFER-OR-NAME is a buffer, return it as given. */)
441 (register Lisp_Object buffer_or_name
)
443 if (BUFFERP (buffer_or_name
))
444 return buffer_or_name
;
445 CHECK_STRING (buffer_or_name
);
447 return Fcdr (assoc_ignore_text_properties (buffer_or_name
, Vbuffer_alist
));
450 DEFUN ("get-file-buffer", Fget_file_buffer
, Sget_file_buffer
, 1, 1, 0,
451 doc
: /* Return the buffer visiting file FILENAME (a string).
452 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
453 If there is no such live buffer, return nil.
454 See also `find-buffer-visiting'. */)
455 (register Lisp_Object filename
)
457 register Lisp_Object tail
, buf
, handler
;
459 CHECK_STRING (filename
);
460 filename
= Fexpand_file_name (filename
, Qnil
);
462 /* If the file name has special constructs in it,
463 call the corresponding file handler. */
464 handler
= Ffind_file_name_handler (filename
, Qget_file_buffer
);
467 Lisp_Object handled_buf
= call2 (handler
, Qget_file_buffer
,
469 return BUFFERP (handled_buf
) ? handled_buf
: Qnil
;
472 FOR_EACH_LIVE_BUFFER (tail
, buf
)
474 if (!STRINGP (BVAR (XBUFFER (buf
), filename
))) continue;
475 if (!NILP (Fstring_equal (BVAR (XBUFFER (buf
), filename
), filename
)))
482 get_truename_buffer (register Lisp_Object filename
)
484 register Lisp_Object tail
, buf
;
486 FOR_EACH_LIVE_BUFFER (tail
, buf
)
488 if (!STRINGP (BVAR (XBUFFER (buf
), file_truename
))) continue;
489 if (!NILP (Fstring_equal (BVAR (XBUFFER (buf
), file_truename
), filename
)))
495 DEFUN ("get-buffer-create", Fget_buffer_create
, Sget_buffer_create
, 1, 1, 0,
496 doc
: /* Return the buffer specified by BUFFER-OR-NAME, creating a new one if needed.
497 If BUFFER-OR-NAME is a string and a live buffer with that name exists,
498 return that buffer. If no such buffer exists, create a new buffer with
499 that name and return it. If BUFFER-OR-NAME starts with a space, the new
500 buffer does not keep undo information.
502 If BUFFER-OR-NAME is a buffer instead of a string, return it as given,
503 even if it is dead. The return value is never nil. */)
504 (register Lisp_Object buffer_or_name
)
506 register Lisp_Object buffer
, name
;
507 register struct buffer
*b
;
509 buffer
= Fget_buffer (buffer_or_name
);
513 if (SCHARS (buffer_or_name
) == 0)
514 error ("Empty string for buffer name is not allowed");
516 b
= allocate_buffer ();
518 /* An ordinary buffer uses its own struct buffer_text. */
519 b
->text
= &b
->own_text
;
520 b
->base_buffer
= NULL
;
521 /* No one shares the text with us now. */
523 /* No one shows us now. */
526 BUF_GAP_SIZE (b
) = 20;
528 /* We allocate extra 1-byte at the tail and keep it always '\0' for
529 anchoring a search. */
530 alloc_buffer_text (b
, BUF_GAP_SIZE (b
) + 1);
532 if (! BUF_BEG_ADDR (b
))
533 buffer_memory_full (BUF_GAP_SIZE (b
) + 1);
538 b
->pt_byte
= BEG_BYTE
;
539 b
->begv_byte
= BEG_BYTE
;
540 b
->zv_byte
= BEG_BYTE
;
543 BUF_GPT_BYTE (b
) = BEG_BYTE
;
546 BUF_Z_BYTE (b
) = BEG_BYTE
;
548 BUF_CHARS_MODIFF (b
) = 1;
549 BUF_OVERLAY_MODIFF (b
) = 1;
550 BUF_SAVE_MODIFF (b
) = 1;
552 set_buffer_intervals (b
, NULL
);
553 BUF_UNCHANGED_MODIFIED (b
) = 1;
554 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = 1;
555 BUF_END_UNCHANGED (b
) = 0;
556 BUF_BEG_UNCHANGED (b
) = 0;
557 *(BUF_GPT_ADDR (b
)) = *(BUF_Z_ADDR (b
)) = 0; /* Put an anchor '\0'. */
558 b
->text
->inhibit_shrinking
= false;
559 b
->text
->redisplay
= false;
561 b
->newline_cache
= 0;
562 b
->width_run_cache
= 0;
563 b
->bidi_paragraph_cache
= 0;
564 bset_width_table (b
, Qnil
);
565 b
->prevent_redisplay_optimizations_p
= 1;
567 /* An ordinary buffer normally doesn't need markers
568 to handle BEGV and ZV. */
569 bset_pt_marker (b
, Qnil
);
570 bset_begv_marker (b
, Qnil
);
571 bset_zv_marker (b
, Qnil
);
573 name
= Fcopy_sequence (buffer_or_name
);
574 set_string_intervals (name
, NULL
);
577 bset_undo_list (b
, SREF (name
, 0) != ' ' ? Qnil
: Qt
);
580 reset_buffer_local_variables (b
, 1);
582 bset_mark (b
, Fmake_marker ());
583 BUF_MARKERS (b
) = NULL
;
585 /* Put this in the alist of all live buffers. */
586 XSETBUFFER (buffer
, b
);
587 Vbuffer_alist
= nconc2 (Vbuffer_alist
, list1 (Fcons (name
, buffer
)));
588 /* And run buffer-list-update-hook. */
589 if (!NILP (Vrun_hooks
))
590 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
596 /* Return a list of overlays which is a copy of the overlay list
597 LIST, but for buffer B. */
599 static struct Lisp_Overlay
*
600 copy_overlays (struct buffer
*b
, struct Lisp_Overlay
*list
)
602 struct Lisp_Overlay
*result
= NULL
, *tail
= NULL
;
604 for (; list
; list
= list
->next
)
606 Lisp_Object overlay
, start
, end
;
607 struct Lisp_Marker
*m
;
609 eassert (MARKERP (list
->start
));
610 m
= XMARKER (list
->start
);
611 start
= build_marker (b
, m
->charpos
, m
->bytepos
);
612 XMARKER (start
)->insertion_type
= m
->insertion_type
;
614 eassert (MARKERP (list
->end
));
615 m
= XMARKER (list
->end
);
616 end
= build_marker (b
, m
->charpos
, m
->bytepos
);
617 XMARKER (end
)->insertion_type
= m
->insertion_type
;
619 overlay
= build_overlay (start
, end
, Fcopy_sequence (list
->plist
));
621 tail
= tail
->next
= XOVERLAY (overlay
);
623 result
= tail
= XOVERLAY (overlay
);
629 /* Set an appropriate overlay of B. */
632 set_buffer_overlays_before (struct buffer
*b
, struct Lisp_Overlay
*o
)
634 b
->overlays_before
= o
;
638 set_buffer_overlays_after (struct buffer
*b
, struct Lisp_Overlay
*o
)
640 b
->overlays_after
= o
;
643 /* Clone per-buffer values of buffer FROM.
645 Buffer TO gets the same per-buffer values as FROM, with the
646 following exceptions: (1) TO's name is left untouched, (2) markers
647 are copied and made to refer to TO, and (3) overlay lists are
651 clone_per_buffer_values (struct buffer
*from
, struct buffer
*to
)
655 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
659 /* Don't touch the `name' which should be unique for every buffer. */
660 if (offset
== PER_BUFFER_VAR_OFFSET (name
))
663 obj
= per_buffer_value (from
, offset
);
664 if (MARKERP (obj
) && XMARKER (obj
)->buffer
== from
)
666 struct Lisp_Marker
*m
= XMARKER (obj
);
668 obj
= build_marker (to
, m
->charpos
, m
->bytepos
);
669 XMARKER (obj
)->insertion_type
= m
->insertion_type
;
672 set_per_buffer_value (to
, offset
, obj
);
675 memcpy (to
->local_flags
, from
->local_flags
, sizeof to
->local_flags
);
677 set_buffer_overlays_before (to
, copy_overlays (to
, from
->overlays_before
));
678 set_buffer_overlays_after (to
, copy_overlays (to
, from
->overlays_after
));
680 /* Get (a copy of) the alist of Lisp-level local variables of FROM
681 and install that in TO. */
682 bset_local_var_alist (to
, buffer_lisp_local_variables (from
, 1));
686 /* If buffer B has markers to record PT, BEGV and ZV when it is not
687 current, update these markers. */
690 record_buffer_markers (struct buffer
*b
)
692 if (! NILP (BVAR (b
, pt_marker
)))
696 eassert (!NILP (BVAR (b
, begv_marker
)));
697 eassert (!NILP (BVAR (b
, zv_marker
)));
699 XSETBUFFER (buffer
, b
);
700 set_marker_both (BVAR (b
, pt_marker
), buffer
, b
->pt
, b
->pt_byte
);
701 set_marker_both (BVAR (b
, begv_marker
), buffer
, b
->begv
, b
->begv_byte
);
702 set_marker_both (BVAR (b
, zv_marker
), buffer
, b
->zv
, b
->zv_byte
);
707 /* If buffer B has markers to record PT, BEGV and ZV when it is not
708 current, fetch these values into B->begv etc. */
711 fetch_buffer_markers (struct buffer
*b
)
713 if (! NILP (BVAR (b
, pt_marker
)))
717 eassert (!NILP (BVAR (b
, begv_marker
)));
718 eassert (!NILP (BVAR (b
, zv_marker
)));
720 m
= BVAR (b
, pt_marker
);
721 SET_BUF_PT_BOTH (b
, marker_position (m
), marker_byte_position (m
));
723 m
= BVAR (b
, begv_marker
);
724 SET_BUF_BEGV_BOTH (b
, marker_position (m
), marker_byte_position (m
));
726 m
= BVAR (b
, zv_marker
);
727 SET_BUF_ZV_BOTH (b
, marker_position (m
), marker_byte_position (m
));
732 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer
, Smake_indirect_buffer
,
734 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ",
735 doc
: /* Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.
736 BASE-BUFFER should be a live buffer, or the name of an existing buffer.
737 NAME should be a string which is not the name of an existing buffer.
738 Optional argument CLONE non-nil means preserve BASE-BUFFER's state,
739 such as major and minor modes, in the indirect buffer.
740 CLONE nil means the indirect buffer's state is reset to default values. */)
741 (Lisp_Object base_buffer
, Lisp_Object name
, Lisp_Object clone
)
743 Lisp_Object buf
, tem
;
747 buf
= Fget_buffer (name
);
749 error ("Buffer name `%s' is in use", SDATA (name
));
752 base_buffer
= Fget_buffer (base_buffer
);
753 if (NILP (base_buffer
))
754 error ("No such buffer: `%s'", SDATA (tem
));
755 if (!BUFFER_LIVE_P (XBUFFER (base_buffer
)))
756 error ("Base buffer has been killed");
758 if (SCHARS (name
) == 0)
759 error ("Empty string for buffer name is not allowed");
761 b
= allocate_buffer ();
763 /* No double indirection - if base buffer is indirect,
764 new buffer becomes an indirect to base's base. */
765 b
->base_buffer
= (XBUFFER (base_buffer
)->base_buffer
766 ? XBUFFER (base_buffer
)->base_buffer
767 : XBUFFER (base_buffer
));
769 /* Use the base buffer's text object. */
770 b
->text
= b
->base_buffer
->text
;
771 /* We have no own text. */
772 b
->indirections
= -1;
773 /* Notify base buffer that we share the text now. */
774 b
->base_buffer
->indirections
++;
775 /* Always -1 for an indirect buffer. */
776 b
->window_count
= -1;
778 b
->pt
= b
->base_buffer
->pt
;
779 b
->begv
= b
->base_buffer
->begv
;
780 b
->zv
= b
->base_buffer
->zv
;
781 b
->pt_byte
= b
->base_buffer
->pt_byte
;
782 b
->begv_byte
= b
->base_buffer
->begv_byte
;
783 b
->zv_byte
= b
->base_buffer
->zv_byte
;
785 b
->newline_cache
= 0;
786 b
->width_run_cache
= 0;
787 b
->bidi_paragraph_cache
= 0;
788 bset_width_table (b
, Qnil
);
790 name
= Fcopy_sequence (name
);
791 set_string_intervals (name
, NULL
);
794 /* An indirect buffer shares undo list of its base (Bug#18180). */
795 bset_undo_list (b
, BVAR (b
->base_buffer
, undo_list
));
798 reset_buffer_local_variables (b
, 1);
800 /* Put this in the alist of all live buffers. */
802 Vbuffer_alist
= nconc2 (Vbuffer_alist
, list1 (Fcons (name
, buf
)));
804 bset_mark (b
, Fmake_marker ());
806 /* The multibyte status belongs to the base buffer. */
807 bset_enable_multibyte_characters
808 (b
, BVAR (b
->base_buffer
, enable_multibyte_characters
));
810 /* Make sure the base buffer has markers for its narrowing. */
811 if (NILP (BVAR (b
->base_buffer
, pt_marker
)))
813 eassert (NILP (BVAR (b
->base_buffer
, begv_marker
)));
814 eassert (NILP (BVAR (b
->base_buffer
, zv_marker
)));
816 bset_pt_marker (b
->base_buffer
,
817 build_marker (b
->base_buffer
, b
->base_buffer
->pt
,
818 b
->base_buffer
->pt_byte
));
820 bset_begv_marker (b
->base_buffer
,
821 build_marker (b
->base_buffer
, b
->base_buffer
->begv
,
822 b
->base_buffer
->begv_byte
));
824 bset_zv_marker (b
->base_buffer
,
825 build_marker (b
->base_buffer
, b
->base_buffer
->zv
,
826 b
->base_buffer
->zv_byte
));
828 XMARKER (BVAR (b
->base_buffer
, zv_marker
))->insertion_type
= 1;
833 /* Give the indirect buffer markers for its narrowing. */
834 bset_pt_marker (b
, build_marker (b
, b
->pt
, b
->pt_byte
));
835 bset_begv_marker (b
, build_marker (b
, b
->begv
, b
->begv_byte
));
836 bset_zv_marker (b
, build_marker (b
, b
->zv
, b
->zv_byte
));
837 XMARKER (BVAR (b
, zv_marker
))->insertion_type
= 1;
841 struct buffer
*old_b
= current_buffer
;
843 clone_per_buffer_values (b
->base_buffer
, b
);
844 bset_filename (b
, Qnil
);
845 bset_file_truename (b
, Qnil
);
846 bset_display_count (b
, make_number (0));
847 bset_backed_up (b
, Qnil
);
848 bset_auto_save_file_name (b
, Qnil
);
849 set_buffer_internal_1 (b
);
850 Fset (intern ("buffer-save-without-query"), Qnil
);
851 Fset (intern ("buffer-file-number"), Qnil
);
852 Fset (intern ("buffer-stale-function"), Qnil
);
853 set_buffer_internal_1 (old_b
);
856 /* Run buffer-list-update-hook. */
857 if (!NILP (Vrun_hooks
))
858 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
863 /* Mark OV as no longer associated with B. */
866 drop_overlay (struct buffer
*b
, struct Lisp_Overlay
*ov
)
868 eassert (b
== XBUFFER (Fmarker_buffer (ov
->start
)));
869 modify_overlay (b
, marker_position (ov
->start
),
870 marker_position (ov
->end
));
871 unchain_marker (XMARKER (ov
->start
));
872 unchain_marker (XMARKER (ov
->end
));
876 /* Delete all overlays of B and reset it's overlay lists. */
879 delete_all_overlays (struct buffer
*b
)
881 struct Lisp_Overlay
*ov
, *next
;
883 /* FIXME: Since each drop_overlay will scan BUF_MARKERS to unlink its
884 markers, we have an unneeded O(N^2) behavior here. */
885 for (ov
= b
->overlays_before
; ov
; ov
= next
)
887 drop_overlay (b
, ov
);
892 for (ov
= b
->overlays_after
; ov
; ov
= next
)
894 drop_overlay (b
, ov
);
899 set_buffer_overlays_before (b
, NULL
);
900 set_buffer_overlays_after (b
, NULL
);
903 /* Reinitialize everything about a buffer except its name and contents
905 If called on an already-initialized buffer, the list of overlays
906 should be deleted before calling this function, otherwise we end up
907 with overlays that claim to belong to the buffer but the buffer
908 claims it doesn't belong to it. */
911 reset_buffer (register struct buffer
*b
)
913 bset_filename (b
, Qnil
);
914 bset_file_truename (b
, Qnil
);
915 bset_directory (b
, current_buffer
? BVAR (current_buffer
, directory
) : Qnil
);
916 b
->modtime
= make_timespec (0, UNKNOWN_MODTIME_NSECS
);
917 b
->modtime_size
= -1;
918 XSETFASTINT (BVAR (b
, save_length
), 0);
919 b
->last_window_start
= 1;
920 /* It is more conservative to start out "changed" than "unchanged". */
922 b
->prevent_redisplay_optimizations_p
= 1;
923 bset_backed_up (b
, Qnil
);
924 BUF_AUTOSAVE_MODIFF (b
) = 0;
925 b
->auto_save_failure_time
= 0;
926 bset_auto_save_file_name (b
, Qnil
);
927 bset_read_only (b
, Qnil
);
928 set_buffer_overlays_before (b
, NULL
);
929 set_buffer_overlays_after (b
, NULL
);
930 b
->overlay_center
= BEG
;
931 bset_mark_active (b
, Qnil
);
932 bset_point_before_scroll (b
, Qnil
);
933 bset_file_format (b
, Qnil
);
934 bset_auto_save_file_format (b
, Qt
);
935 bset_last_selected_window (b
, Qnil
);
936 bset_display_count (b
, make_number (0));
937 bset_display_time (b
, Qnil
);
938 bset_enable_multibyte_characters
939 (b
, BVAR (&buffer_defaults
, enable_multibyte_characters
));
940 bset_cursor_type (b
, BVAR (&buffer_defaults
, cursor_type
));
941 bset_extra_line_spacing (b
, BVAR (&buffer_defaults
, extra_line_spacing
));
943 b
->display_error_modiff
= 0;
946 /* Reset buffer B's local variables info.
947 Don't use this on a buffer that has already been in use;
948 it does not treat permanent locals consistently.
949 Instead, use Fkill_all_local_variables.
951 If PERMANENT_TOO, reset permanent buffer-local variables.
952 If not, preserve those. */
955 reset_buffer_local_variables (struct buffer
*b
, bool permanent_too
)
959 /* Reset the major mode to Fundamental, together with all the
960 things that depend on the major mode.
961 default-major-mode is handled at a higher level.
962 We ignore it here. */
963 bset_major_mode (b
, Qfundamental_mode
);
964 bset_keymap (b
, Qnil
);
965 bset_mode_name (b
, QSFundamental
);
966 bset_minor_modes (b
, Qnil
);
968 /* If the standard case table has been altered and invalidated,
969 fix up its insides first. */
970 if (! (CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[0])
971 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[1])
972 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[2])))
973 Fset_standard_case_table (Vascii_downcase_table
);
975 bset_downcase_table (b
, Vascii_downcase_table
);
976 bset_upcase_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[0]);
977 bset_case_canon_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[1]);
978 bset_case_eqv_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[2]);
979 bset_invisibility_spec (b
, Qt
);
981 /* Reset all (or most) per-buffer variables to their defaults. */
983 bset_local_var_alist (b
, Qnil
);
986 Lisp_Object tmp
, prop
, last
= Qnil
;
987 for (tmp
= BVAR (b
, local_var_alist
); CONSP (tmp
); tmp
= XCDR (tmp
))
988 if (!NILP (prop
= Fget (XCAR (XCAR (tmp
)), Qpermanent_local
)))
990 /* If permanent-local, keep it. */
992 if (EQ (prop
, Qpermanent_local_hook
))
994 /* This is a partially permanent hook variable.
995 Preserve only the elements that want to be preserved. */
996 Lisp_Object list
, newlist
;
997 list
= XCDR (XCAR (tmp
));
1001 for (newlist
= Qnil
; CONSP (list
); list
= XCDR (list
))
1003 Lisp_Object elt
= XCAR (list
);
1004 /* Preserve element ELT if it's t,
1005 if it is a function with a `permanent-local-hook' property,
1006 or if it's not a symbol. */
1009 || !NILP (Fget (elt
, Qpermanent_local_hook
)))
1010 newlist
= Fcons (elt
, newlist
);
1012 XSETCDR (XCAR (tmp
), Fnreverse (newlist
));
1015 /* Delete this local variable. */
1016 else if (NILP (last
))
1017 bset_local_var_alist (b
, XCDR (tmp
));
1019 XSETCDR (last
, XCDR (tmp
));
1022 for (i
= 0; i
< last_per_buffer_idx
; ++i
)
1023 if (permanent_too
|| buffer_permanent_local_flags
[i
] == 0)
1024 SET_PER_BUFFER_VALUE_P (b
, i
, 0);
1026 /* For each slot that has a default value, copy that into the slot. */
1027 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
1029 int idx
= PER_BUFFER_IDX (offset
);
1032 || buffer_permanent_local_flags
[idx
] == 0)))
1033 set_per_buffer_value (b
, offset
, per_buffer_default (offset
));
1037 /* We split this away from generate-new-buffer, because rename-buffer
1038 and set-visited-file-name ought to be able to use this to really
1039 rename the buffer properly. */
1041 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name
,
1042 Sgenerate_new_buffer_name
, 1, 2, 0,
1043 doc
: /* Return a string that is the name of no existing buffer based on NAME.
1044 If there is no live buffer named NAME, then return NAME.
1045 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
1046 (starting at 2) until an unused name is found, and then return that name.
1047 Optional second argument IGNORE specifies a name that is okay to use (if
1048 it is in the sequence to be tried) even if a buffer with that name exists.
1050 If NAME begins with a space (i.e., a buffer that is not normally
1051 visible to users), then if buffer NAME already exists a random number
1052 is first appended to NAME, to speed up finding a non-existent buffer. */)
1053 (register Lisp_Object name
, Lisp_Object ignore
)
1055 register Lisp_Object gentemp
, tem
, tem2
;
1057 char number
[INT_BUFSIZE_BOUND (ptrdiff_t) + sizeof "<>"];
1059 CHECK_STRING (name
);
1061 tem
= Fstring_equal (name
, ignore
);
1064 tem
= Fget_buffer (name
);
1068 if (!strncmp (SSDATA (name
), " ", 1)) /* see bug#1229 */
1070 /* Note fileio.c:make_temp_name does random differently. */
1071 tem2
= concat2 (name
, make_formatted_string
1073 XFASTINT (Frandom (make_number (999999)))));
1074 tem
= Fget_buffer (tem2
);
1084 gentemp
= concat2 (tem2
, make_formatted_string
1085 (number
, "<%"pD
"d>", ++count
));
1086 tem
= Fstring_equal (gentemp
, ignore
);
1089 tem
= Fget_buffer (gentemp
);
1096 DEFUN ("buffer-name", Fbuffer_name
, Sbuffer_name
, 0, 1, 0,
1097 doc
: /* Return the name of BUFFER, as a string.
1098 BUFFER defaults to the current buffer.
1099 Return nil if BUFFER has been killed. */)
1100 (register Lisp_Object buffer
)
1102 return BVAR (decode_buffer (buffer
), name
);
1105 DEFUN ("buffer-file-name", Fbuffer_file_name
, Sbuffer_file_name
, 0, 1, 0,
1106 doc
: /* Return name of file BUFFER is visiting, or nil if none.
1107 No argument or nil as argument means use the current buffer. */)
1108 (register Lisp_Object buffer
)
1110 return BVAR (decode_buffer (buffer
), filename
);
1113 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer
, Sbuffer_base_buffer
,
1115 doc
: /* Return the base buffer of indirect buffer BUFFER.
1116 If BUFFER is not indirect, return nil.
1117 BUFFER defaults to the current buffer. */)
1118 (register Lisp_Object buffer
)
1120 struct buffer
*base
= decode_buffer (buffer
)->base_buffer
;
1121 return base
? (XSETBUFFER (buffer
, base
), buffer
) : Qnil
;
1124 DEFUN ("buffer-local-value", Fbuffer_local_value
,
1125 Sbuffer_local_value
, 2, 2, 0,
1126 doc
: /* Return the value of VARIABLE in BUFFER.
1127 If VARIABLE does not have a buffer-local binding in BUFFER, the value
1128 is the default binding of the variable. */)
1129 (register Lisp_Object variable
, register Lisp_Object buffer
)
1131 register Lisp_Object result
= buffer_local_value (variable
, buffer
);
1133 if (EQ (result
, Qunbound
))
1134 xsignal1 (Qvoid_variable
, variable
);
1140 /* Like Fbuffer_local_value, but return Qunbound if the variable is
1144 buffer_local_value (Lisp_Object variable
, Lisp_Object buffer
)
1146 register struct buffer
*buf
;
1147 register Lisp_Object result
;
1148 struct Lisp_Symbol
*sym
;
1150 CHECK_SYMBOL (variable
);
1151 CHECK_BUFFER (buffer
);
1152 buf
= XBUFFER (buffer
);
1153 sym
= XSYMBOL (variable
);
1156 switch (sym
->redirect
)
1158 case SYMBOL_VARALIAS
: sym
= indirect_variable (sym
); goto start
;
1159 case SYMBOL_PLAINVAL
: result
= SYMBOL_VAL (sym
); break;
1160 case SYMBOL_LOCALIZED
:
1161 { /* Look in local_var_alist. */
1162 struct Lisp_Buffer_Local_Value
*blv
= SYMBOL_BLV (sym
);
1163 XSETSYMBOL (variable
, sym
); /* Update In case of aliasing. */
1164 result
= Fassoc (variable
, BVAR (buf
, local_var_alist
));
1168 { /* What binding is loaded right now? */
1169 Lisp_Object current_alist_element
= blv
->valcell
;
1171 /* The value of the currently loaded binding is not
1172 stored in it, but rather in the realvalue slot.
1173 Store that value into the binding it belongs to
1174 in case that is the one we are about to use. */
1176 XSETCDR (current_alist_element
,
1177 do_symval_forwarding (blv
->fwd
));
1179 /* Now get the (perhaps updated) value out of the binding. */
1180 result
= XCDR (result
);
1183 result
= Fdefault_value (variable
);
1186 case SYMBOL_FORWARDED
:
1188 union Lisp_Fwd
*fwd
= SYMBOL_FWD (sym
);
1189 if (BUFFER_OBJFWDP (fwd
))
1190 result
= per_buffer_value (buf
, XBUFFER_OBJFWD (fwd
)->offset
);
1192 result
= Fdefault_value (variable
);
1195 default: emacs_abort ();
1201 /* Return an alist of the Lisp-level buffer-local bindings of
1202 buffer BUF. That is, don't include the variables maintained
1203 in special slots in the buffer object.
1204 If not CLONE, replace elements of the form (VAR . unbound)
1208 buffer_lisp_local_variables (struct buffer
*buf
, bool clone
)
1210 Lisp_Object result
= Qnil
;
1212 for (tail
= BVAR (buf
, local_var_alist
); CONSP (tail
); tail
= XCDR (tail
))
1214 Lisp_Object val
, elt
;
1218 /* Reference each variable in the alist in buf.
1219 If inquiring about the current buffer, this gets the current values,
1220 so store them into the alist so the alist is up to date.
1221 If inquiring about some other buffer, this swaps out any values
1222 for that buffer, making the alist up to date automatically. */
1223 val
= find_symbol_value (XCAR (elt
));
1224 /* Use the current buffer value only if buf is the current buffer. */
1225 if (buf
!= current_buffer
)
1228 result
= Fcons (!clone
&& EQ (val
, Qunbound
)
1230 : Fcons (XCAR (elt
), val
),
1237 DEFUN ("buffer-local-variables", Fbuffer_local_variables
,
1238 Sbuffer_local_variables
, 0, 1, 0,
1239 doc
: /* Return an alist of variables that are buffer-local in BUFFER.
1240 Most elements look like (SYMBOL . VALUE), describing one variable.
1241 For a symbol that is locally unbound, just the symbol appears in the value.
1242 Note that storing new VALUEs in these elements doesn't change the variables.
1243 No argument or nil as argument means use current buffer as BUFFER. */)
1244 (Lisp_Object buffer
)
1246 struct buffer
*buf
= decode_buffer (buffer
);
1247 Lisp_Object result
= buffer_lisp_local_variables (buf
, 0);
1249 /* Add on all the variables stored in special slots. */
1253 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
1255 idx
= PER_BUFFER_IDX (offset
);
1256 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
1257 && SYMBOLP (PER_BUFFER_SYMBOL (offset
)))
1259 Lisp_Object sym
= PER_BUFFER_SYMBOL (offset
);
1260 Lisp_Object val
= per_buffer_value (buf
, offset
);
1261 result
= Fcons (EQ (val
, Qunbound
) ? sym
: Fcons (sym
, val
),
1270 DEFUN ("buffer-modified-p", Fbuffer_modified_p
, Sbuffer_modified_p
,
1272 doc
: /* Return t if BUFFER was modified since its file was last read or saved.
1273 No argument or nil as argument means use current buffer as BUFFER. */)
1274 (Lisp_Object buffer
)
1276 struct buffer
*buf
= decode_buffer (buffer
);
1277 return BUF_SAVE_MODIFF (buf
) < BUF_MODIFF (buf
) ? Qt
: Qnil
;
1280 DEFUN ("force-mode-line-update", Fforce_mode_line_update
,
1281 Sforce_mode_line_update
, 0, 1, 0,
1282 doc
: /* Force redisplay of the current buffer's mode line and header line.
1283 With optional non-nil ALL, force redisplay of all mode lines and
1284 header lines. This function also forces recomputation of the
1285 menu bar menus and the frame title. */)
1290 update_mode_lines
= 10;
1291 /* FIXME: This can't be right. */
1292 current_buffer
->prevent_redisplay_optimizations_p
= true;
1294 else if (buffer_window_count (current_buffer
))
1296 bset_update_mode_line (current_buffer
);
1297 current_buffer
->prevent_redisplay_optimizations_p
= true;
1302 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p
, Sset_buffer_modified_p
,
1304 doc
: /* Mark current buffer as modified or unmodified according to FLAG.
1305 A non-nil FLAG means mark the buffer modified. */)
1308 Frestore_buffer_modified_p (flag
);
1310 /* Set update_mode_lines only if buffer is displayed in some window.
1311 Packages like jit-lock or lazy-lock preserve a buffer's modified
1312 state by recording/restoring the state around blocks of code.
1313 Setting update_mode_lines makes redisplay consider all windows
1314 (on all frames). Stealth fontification of buffers not displayed
1315 would incur additional redisplay costs if we'd set
1316 update_modes_lines unconditionally.
1318 Ideally, I think there should be another mechanism for fontifying
1319 buffers without "modifying" buffers, or redisplay should be
1320 smarter about updating the `*' in mode lines. --gerd */
1321 return Fforce_mode_line_update (Qnil
);
1324 DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p
,
1325 Srestore_buffer_modified_p
, 1, 1, 0,
1326 doc
: /* Like `set-buffer-modified-p', with a difference concerning redisplay.
1327 It is not ensured that mode lines will be updated to show the modified
1328 state of the current buffer. Use with care. */)
1333 /* If buffer becoming modified, lock the file.
1334 If buffer becoming unmodified, unlock the file. */
1336 struct buffer
*b
= current_buffer
->base_buffer
1337 ? current_buffer
->base_buffer
1340 fn
= BVAR (b
, file_truename
);
1341 /* Test buffer-file-name so that binding it to nil is effective. */
1342 if (!NILP (fn
) && ! NILP (BVAR (b
, filename
)))
1344 bool already
= SAVE_MODIFF
< MODIFF
;
1345 if (!already
&& !NILP (flag
))
1347 else if (already
&& NILP (flag
))
1351 /* Here we have a problem. SAVE_MODIFF is used here to encode
1352 buffer-modified-p (as SAVE_MODIFF<MODIFF) as well as
1353 recent-auto-save-p (as SAVE_MODIFF<auto_save_modified). So if we
1354 modify SAVE_MODIFF to affect one, we may affect the other
1356 E.g. if FLAG is nil we need to set SAVE_MODIFF to MODIFF, but
1357 if SAVE_MODIFF<auto_save_modified that means we risk changing
1358 recent-auto-save-p from t to nil.
1359 Vice versa, if FLAG is non-nil and SAVE_MODIFF>=auto_save_modified
1360 we risk changing recent-auto-save-p from nil to t. */
1361 SAVE_MODIFF
= (NILP (flag
)
1362 /* FIXME: This unavoidably sets recent-auto-save-p to nil. */
1364 /* Let's try to preserve recent-auto-save-p. */
1365 : SAVE_MODIFF
< MODIFF
? SAVE_MODIFF
1366 /* If SAVE_MODIFF == auto_save_modified == MODIFF,
1367 we can either decrease SAVE_MODIFF and auto_save_modified
1368 or increase MODIFF. */
1374 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick
, Sbuffer_modified_tick
,
1376 doc
: /* Return BUFFER's tick counter, incremented for each change in text.
1377 Each buffer has a tick counter which is incremented each time the
1378 text in that buffer is changed. It wraps around occasionally.
1379 No argument or nil as argument means use current buffer as BUFFER. */)
1380 (register Lisp_Object buffer
)
1382 return make_number (BUF_MODIFF (decode_buffer (buffer
)));
1385 DEFUN ("buffer-chars-modified-tick", Fbuffer_chars_modified_tick
,
1386 Sbuffer_chars_modified_tick
, 0, 1, 0,
1387 doc
: /* Return BUFFER's character-change tick counter.
1388 Each buffer has a character-change tick counter, which is set to the
1389 value of the buffer's tick counter (see `buffer-modified-tick'), each
1390 time text in that buffer is inserted or deleted. By comparing the
1391 values returned by two individual calls of `buffer-chars-modified-tick',
1392 you can tell whether a character change occurred in that buffer in
1393 between these calls. No argument or nil as argument means use current
1394 buffer as BUFFER. */)
1395 (register Lisp_Object buffer
)
1397 return make_number (BUF_CHARS_MODIFF (decode_buffer (buffer
)));
1400 DEFUN ("rename-buffer", Frename_buffer
, Srename_buffer
, 1, 2,
1401 "(list (read-string \"Rename buffer (to new name): \" \
1402 nil 'buffer-name-history (buffer-name (current-buffer))) \
1403 current-prefix-arg)",
1404 doc
: /* Change current buffer's name to NEWNAME (a string).
1405 If second arg UNIQUE is nil or omitted, it is an error if a
1406 buffer named NEWNAME already exists.
1407 If UNIQUE is non-nil, come up with a new name using
1408 `generate-new-buffer-name'.
1409 Interactively, you can set UNIQUE with a prefix argument.
1410 We return the name we actually gave the buffer.
1411 This does not change the name of the visited file (if any). */)
1412 (register Lisp_Object newname
, Lisp_Object unique
)
1414 register Lisp_Object tem
, buf
;
1416 CHECK_STRING (newname
);
1418 if (SCHARS (newname
) == 0)
1419 error ("Empty string is invalid as a buffer name");
1421 tem
= Fget_buffer (newname
);
1424 /* Don't short-circuit if UNIQUE is t. That is a useful way to
1425 rename the buffer automatically so you can create another
1426 with the original name. It makes UNIQUE equivalent to
1427 (rename-buffer (generate-new-buffer-name NEWNAME)). */
1428 if (NILP (unique
) && XBUFFER (tem
) == current_buffer
)
1429 return BVAR (current_buffer
, name
);
1431 newname
= Fgenerate_new_buffer_name (newname
, BVAR (current_buffer
, name
));
1433 error ("Buffer name `%s' is in use", SDATA (newname
));
1436 bset_name (current_buffer
, newname
);
1438 /* Catch redisplay's attention. Unless we do this, the mode lines for
1439 any windows displaying current_buffer will stay unchanged. */
1440 update_mode_lines
= 11;
1442 XSETBUFFER (buf
, current_buffer
);
1443 Fsetcar (Frassq (buf
, Vbuffer_alist
), newname
);
1444 if (NILP (BVAR (current_buffer
, filename
))
1445 && !NILP (BVAR (current_buffer
, auto_save_file_name
)))
1446 call0 (intern ("rename-auto-save-file"));
1448 /* Run buffer-list-update-hook. */
1449 if (!NILP (Vrun_hooks
))
1450 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1452 /* Refetch since that last call may have done GC. */
1453 return BVAR (current_buffer
, name
);
1456 /* True if B can be used as 'other-than-BUFFER' buffer. */
1459 candidate_buffer (Lisp_Object b
, Lisp_Object buffer
)
1461 return (BUFFERP (b
) && !EQ (b
, buffer
)
1462 && BUFFER_LIVE_P (XBUFFER (b
))
1463 && !BUFFER_HIDDEN_P (XBUFFER (b
)));
1466 DEFUN ("other-buffer", Fother_buffer
, Sother_buffer
, 0, 3, 0,
1467 doc
: /* Return most recently selected buffer other than BUFFER.
1468 Buffers not visible in windows are preferred to visible buffers, unless
1469 optional second argument VISIBLE-OK is non-nil. Ignore the argument
1470 BUFFER unless it denotes a live buffer. If the optional third argument
1471 FRAME specifies a live frame, then use that frame's buffer list instead
1472 of the selected frame's buffer list.
1474 The buffer is found by scanning the selected or specified frame's buffer
1475 list first, followed by the list of all buffers. If no other buffer
1476 exists, return the buffer `*scratch*' (creating it if necessary). */)
1477 (Lisp_Object buffer
, Lisp_Object visible_ok
, Lisp_Object frame
)
1479 struct frame
*f
= decode_live_frame (frame
);
1480 Lisp_Object tail
= f
->buffer_list
, pred
= f
->buffer_predicate
;
1481 Lisp_Object buf
, notsogood
= Qnil
;
1483 /* Consider buffers that have been seen in the frame first. */
1484 for (; CONSP (tail
); tail
= XCDR (tail
))
1487 if (candidate_buffer (buf
, buffer
)
1488 /* If the frame has a buffer_predicate, disregard buffers that
1489 don't fit the predicate. */
1490 && (NILP (pred
) || !NILP (call1 (pred
, buf
))))
1492 if (!NILP (visible_ok
)
1493 || NILP (Fget_buffer_window (buf
, Qvisible
)))
1495 else if (NILP (notsogood
))
1500 /* Consider alist of all buffers next. */
1501 FOR_EACH_LIVE_BUFFER (tail
, buf
)
1503 if (candidate_buffer (buf
, buffer
)
1504 /* If the frame has a buffer_predicate, disregard buffers that
1505 don't fit the predicate. */
1506 && (NILP (pred
) || !NILP (call1 (pred
, buf
))))
1508 if (!NILP (visible_ok
)
1509 || NILP (Fget_buffer_window (buf
, Qvisible
)))
1511 else if (NILP (notsogood
))
1516 if (!NILP (notsogood
))
1520 AUTO_STRING (scratch
, "*scratch*");
1521 buf
= Fget_buffer (scratch
);
1524 buf
= Fget_buffer_create (scratch
);
1525 Fset_buffer_major_mode (buf
);
1531 /* The following function is a safe variant of Fother_buffer: It doesn't
1532 pay attention to any frame-local buffer lists, doesn't care about
1533 visibility of buffers, and doesn't evaluate any frame predicates. */
1536 other_buffer_safely (Lisp_Object buffer
)
1538 Lisp_Object tail
, buf
;
1540 FOR_EACH_LIVE_BUFFER (tail
, buf
)
1541 if (candidate_buffer (buf
, buffer
))
1544 AUTO_STRING (scratch
, "*scratch*");
1545 buf
= Fget_buffer (scratch
);
1548 buf
= Fget_buffer_create (scratch
);
1549 Fset_buffer_major_mode (buf
);
1555 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo
, Sbuffer_enable_undo
,
1557 doc
: /* Start keeping undo information for buffer BUFFER.
1558 No argument or nil as argument means do this for the current buffer. */)
1559 (register Lisp_Object buffer
)
1561 Lisp_Object real_buffer
;
1564 XSETBUFFER (real_buffer
, current_buffer
);
1567 real_buffer
= Fget_buffer (buffer
);
1568 if (NILP (real_buffer
))
1572 if (EQ (BVAR (XBUFFER (real_buffer
), undo_list
), Qt
))
1573 bset_undo_list (XBUFFER (real_buffer
), Qnil
);
1578 /* Truncate undo list and shrink the gap of BUFFER. */
1581 compact_buffer (struct buffer
*buffer
)
1583 BUFFER_CHECK_INDIRECTION (buffer
);
1585 /* Skip dead buffers, indirect buffers and buffers
1586 which aren't changed since last compaction. */
1587 if (BUFFER_LIVE_P (buffer
)
1588 && (buffer
->base_buffer
== NULL
)
1589 && (BUF_COMPACT (buffer
) != BUF_MODIFF (buffer
)))
1591 /* If a buffer's undo list is Qt, that means that undo is
1592 turned off in that buffer. Calling truncate_undo_list on
1593 Qt tends to return NULL, which effectively turns undo back on.
1594 So don't call truncate_undo_list if undo_list is Qt. */
1595 if (!EQ (BVAR(buffer
, undo_list
), Qt
))
1596 truncate_undo_list (buffer
);
1598 /* Shrink buffer gaps. */
1599 if (!buffer
->text
->inhibit_shrinking
)
1601 /* If a buffer's gap size is more than 10% of the buffer
1602 size, or larger than GAP_BYTES_DFL bytes, then shrink it
1603 accordingly. Keep a minimum size of GAP_BYTES_MIN bytes. */
1604 ptrdiff_t size
= clip_to_bounds (GAP_BYTES_MIN
,
1605 BUF_Z_BYTE (buffer
) / 10,
1607 if (BUF_GAP_SIZE (buffer
) > size
)
1608 make_gap_1 (buffer
, -(BUF_GAP_SIZE (buffer
) - size
));
1610 BUF_COMPACT (buffer
) = BUF_MODIFF (buffer
);
1614 /* Set the global update_mode_lines variable non-zero if the buffer
1615 was displayed in some window. This is needed to catch the
1616 attention of redisplay to changes that might require redisplay of
1617 the frame title (which uses the same variables as mode lines) when
1618 the buffer object cannot be used for recording that fact, e.g. if
1619 the buffer is killed. */
1621 set_update_modelines_for_buf (bool disp
)
1624 update_mode_lines
= 42;
1627 DEFUN ("kill-buffer", Fkill_buffer
, Skill_buffer
, 0, 1, "bKill buffer: ",
1628 doc
: /* Kill the buffer specified by BUFFER-OR-NAME.
1629 The argument may be a buffer or the name of an existing buffer.
1630 Argument nil or omitted means kill the current buffer. Return t if the
1631 buffer is actually killed, nil otherwise.
1633 The functions in `kill-buffer-query-functions' are called with the
1634 buffer to be killed as the current buffer. If any of them returns nil,
1635 the buffer is not killed. The hook `kill-buffer-hook' is run before the
1636 buffer is actually killed. The buffer being killed will be current
1637 while the hook is running. Functions called by any of these hooks are
1638 supposed to not change the current buffer.
1640 Any processes that have this buffer as the `process-buffer' are killed
1641 with SIGHUP. This function calls `replace-buffer-in-windows' for
1642 cleaning up all windows currently displaying the buffer to be killed. */)
1643 (Lisp_Object buffer_or_name
)
1648 struct Lisp_Marker
*m
;
1649 bool buffer_was_displayed
= false;
1651 if (NILP (buffer_or_name
))
1652 buffer
= Fcurrent_buffer ();
1654 buffer
= Fget_buffer (buffer_or_name
);
1656 nsberror (buffer_or_name
);
1658 b
= XBUFFER (buffer
);
1660 /* Avoid trouble for buffer already dead. */
1661 if (!BUFFER_LIVE_P (b
))
1664 buffer_was_displayed
= buffer_window_count (b
);
1666 /* Run hooks with the buffer to be killed the current buffer. */
1668 ptrdiff_t count
= SPECPDL_INDEX ();
1670 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1671 set_buffer_internal (b
);
1673 /* First run the query functions; if any query is answered no,
1674 don't kill the buffer. */
1675 tem
= CALLN (Frun_hook_with_args_until_failure
,
1676 Qkill_buffer_query_functions
);
1678 return unbind_to (count
, Qnil
);
1680 /* Query if the buffer is still modified. */
1681 if (INTERACTIVE
&& !NILP (BVAR (b
, filename
))
1682 && BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
1684 AUTO_STRING (format
, "Buffer %s modified; kill anyway? ");
1685 tem
= do_yes_or_no_p (CALLN (Fformat
, format
, BVAR (b
, name
)));
1687 return unbind_to (count
, Qnil
);
1690 /* If the hooks have killed the buffer, exit now. */
1691 if (!BUFFER_LIVE_P (b
))
1693 set_update_modelines_for_buf (buffer_was_displayed
);
1694 return unbind_to (count
, Qt
);
1697 /* Then run the hooks. */
1698 run_hook (Qkill_buffer_hook
);
1699 unbind_to (count
, Qnil
);
1702 /* If the hooks have killed the buffer, exit now. */
1703 if (!BUFFER_LIVE_P (b
))
1705 set_update_modelines_for_buf (buffer_was_displayed
);
1709 /* We have no more questions to ask. Verify that it is valid
1710 to kill the buffer. This must be done after the questions
1711 since anything can happen within do_yes_or_no_p. */
1713 /* Don't kill the minibuffer now current. */
1714 if (EQ (buffer
, XWINDOW (minibuf_window
)->contents
))
1717 /* When we kill an ordinary buffer which shares it's buffer text
1718 with indirect buffer(s), we must kill indirect buffer(s) too.
1719 We do it at this stage so nothing terrible happens if they
1720 ask questions or their hooks get errors. */
1721 if (!b
->base_buffer
&& b
->indirections
> 0)
1723 struct buffer
*other
;
1725 FOR_EACH_BUFFER (other
)
1726 if (other
->base_buffer
== b
)
1729 XSETBUFFER (buf
, other
);
1733 /* Exit if we now have killed the base buffer (Bug#11665). */
1734 if (!BUFFER_LIVE_P (b
))
1736 set_update_modelines_for_buf (buffer_was_displayed
);
1741 /* Run replace_buffer_in_windows before making another buffer current
1742 since set-window-buffer-start-and-point will refuse to make another
1743 buffer current if the selected window does not show the current
1744 buffer (bug#10114). */
1745 replace_buffer_in_windows (buffer
);
1747 /* Exit if replacing the buffer in windows has killed our buffer. */
1748 if (!BUFFER_LIVE_P (b
))
1750 set_update_modelines_for_buf (buffer_was_displayed
);
1754 /* Make this buffer not be current. Exit if it is the sole visible
1756 if (b
== current_buffer
)
1758 tem
= Fother_buffer (buffer
, Qnil
, Qnil
);
1760 if (b
== current_buffer
)
1764 /* If the buffer now current is shown in the minibuffer and our buffer
1765 is the sole other buffer give up. */
1766 XSETBUFFER (tem
, current_buffer
);
1767 if (EQ (tem
, XWINDOW (minibuf_window
)->contents
)
1768 && EQ (buffer
, Fother_buffer (buffer
, Qnil
, Qnil
)))
1771 /* Now there is no question: we can kill the buffer. */
1773 /* Unlock this buffer's file, if it is locked. */
1776 kill_buffer_processes (buffer
);
1778 /* Killing buffer processes may run sentinels which may have killed
1780 if (!BUFFER_LIVE_P (b
))
1782 set_update_modelines_for_buf (buffer_was_displayed
);
1786 /* These may run Lisp code and into infinite loops (if someone
1787 insisted on circular lists) so allow quitting here. */
1788 frames_discard_buffer (buffer
);
1790 clear_charpos_cache (b
);
1792 tem
= Vinhibit_quit
;
1794 /* Remove the buffer from the list of all buffers. */
1795 Vbuffer_alist
= Fdelq (Frassq (buffer
, Vbuffer_alist
), Vbuffer_alist
);
1796 /* If replace_buffer_in_windows didn't do its job fix that now. */
1797 replace_buffer_in_windows_safely (buffer
);
1798 Vinhibit_quit
= tem
;
1800 /* Delete any auto-save file, if we saved it in this session.
1801 But not if the buffer is modified. */
1802 if (STRINGP (BVAR (b
, auto_save_file_name
))
1803 && BUF_AUTOSAVE_MODIFF (b
) != 0
1804 && BUF_SAVE_MODIFF (b
) < BUF_AUTOSAVE_MODIFF (b
)
1805 && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
)
1806 && NILP (Fsymbol_value (intern ("auto-save-visited-file-name"))))
1809 delete = Fsymbol_value (intern ("delete-auto-save-files"));
1810 if (! NILP (delete))
1811 internal_delete_file (BVAR (b
, auto_save_file_name
));
1814 /* Deleting an auto-save file could have killed our buffer. */
1815 if (!BUFFER_LIVE_P (b
))
1817 set_update_modelines_for_buf (buffer_was_displayed
);
1824 /* Unchain all markers that belong to this indirect buffer.
1825 Don't unchain the markers that belong to the base buffer
1826 or its other indirect buffers. */
1827 struct Lisp_Marker
**mp
= &BUF_MARKERS (b
);
1838 /* Intervals should be owned by the base buffer (Bug#16502). */
1839 i
= buffer_intervals (b
);
1843 XSETBUFFER (owner
, b
->base_buffer
);
1844 set_interval_object (i
, owner
);
1849 /* Unchain all markers of this buffer and its indirect buffers.
1850 and leave them pointing nowhere. */
1851 for (m
= BUF_MARKERS (b
); m
; )
1853 struct Lisp_Marker
*next
= m
->next
;
1858 BUF_MARKERS (b
) = NULL
;
1859 set_buffer_intervals (b
, NULL
);
1861 /* Perhaps we should explicitly free the interval tree here... */
1863 /* Since we've unlinked the markers, the overlays can't be here any more
1865 b
->overlays_before
= NULL
;
1866 b
->overlays_after
= NULL
;
1868 /* Reset the local variables, so that this buffer's local values
1869 won't be protected from GC. They would be protected
1870 if they happened to remain cached in their symbols.
1871 This gets rid of them for certain. */
1872 swap_out_buffer_local_variables (b
);
1873 reset_buffer_local_variables (b
, 1);
1875 bset_name (b
, Qnil
);
1880 /* Notify our base buffer that we don't share the text anymore. */
1881 eassert (b
->indirections
== -1);
1882 b
->base_buffer
->indirections
--;
1883 eassert (b
->base_buffer
->indirections
>= 0);
1884 /* Make sure that we wasn't confused. */
1885 eassert (b
->window_count
== -1);
1889 /* Make sure that no one shows us. */
1890 eassert (b
->window_count
== 0);
1891 /* No one shares our buffer text, can free it. */
1892 free_buffer_text (b
);
1895 if (b
->newline_cache
)
1897 free_region_cache (b
->newline_cache
);
1898 b
->newline_cache
= 0;
1900 if (b
->width_run_cache
)
1902 free_region_cache (b
->width_run_cache
);
1903 b
->width_run_cache
= 0;
1905 if (b
->bidi_paragraph_cache
)
1907 free_region_cache (b
->bidi_paragraph_cache
);
1908 b
->bidi_paragraph_cache
= 0;
1910 bset_width_table (b
, Qnil
);
1912 bset_undo_list (b
, Qnil
);
1914 /* Run buffer-list-update-hook. */
1915 if (!NILP (Vrun_hooks
))
1916 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1918 set_update_modelines_for_buf (buffer_was_displayed
);
1922 /* Move association for BUFFER to the front of buffer (a)lists. Since
1923 we do this each time BUFFER is selected visibly, the more recently
1924 selected buffers are always closer to the front of those lists. This
1925 means that other_buffer is more likely to choose a relevant buffer.
1927 Note that this moves BUFFER to the front of the buffer lists of the
1928 selected frame even if BUFFER is not shown there. If BUFFER is not
1929 shown in the selected frame, consider the present behavior a feature.
1930 `select-window' gets this right since it shows BUFFER in the selected
1931 window when calling us. */
1934 record_buffer (Lisp_Object buffer
)
1936 Lisp_Object aelt
, aelt_cons
, tem
;
1937 register struct frame
*f
= XFRAME (selected_frame
);
1939 CHECK_BUFFER (buffer
);
1941 /* Update Vbuffer_alist (we know that it has an entry for BUFFER).
1942 Don't allow quitting since this might leave the buffer list in an
1943 inconsistent state. */
1944 tem
= Vinhibit_quit
;
1946 aelt
= Frassq (buffer
, Vbuffer_alist
);
1947 aelt_cons
= Fmemq (aelt
, Vbuffer_alist
);
1948 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
1949 XSETCDR (aelt_cons
, Vbuffer_alist
);
1950 Vbuffer_alist
= aelt_cons
;
1951 Vinhibit_quit
= tem
;
1953 /* Update buffer list of selected frame. */
1954 fset_buffer_list (f
, Fcons (buffer
, Fdelq (buffer
, f
->buffer_list
)));
1955 fset_buried_buffer_list (f
, Fdelq (buffer
, f
->buried_buffer_list
));
1957 /* Run buffer-list-update-hook. */
1958 if (!NILP (Vrun_hooks
))
1959 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1963 /* Move BUFFER to the end of the buffer (a)lists. Do nothing if the
1964 buffer is killed. For the selected frame's buffer list this moves
1965 BUFFER to its end even if it was never shown in that frame. If
1966 this happens we have a feature, hence `bury-buffer-internal' should be
1967 called only when BUFFER was shown in the selected frame. */
1969 DEFUN ("bury-buffer-internal", Fbury_buffer_internal
, Sbury_buffer_internal
,
1971 doc
: /* Move BUFFER to the end of the buffer list. */)
1972 (Lisp_Object buffer
)
1974 Lisp_Object aelt
, aelt_cons
, tem
;
1975 register struct frame
*f
= XFRAME (selected_frame
);
1977 CHECK_BUFFER (buffer
);
1979 /* Update Vbuffer_alist (we know that it has an entry for BUFFER).
1980 Don't allow quitting since this might leave the buffer list in an
1981 inconsistent state. */
1982 tem
= Vinhibit_quit
;
1984 aelt
= Frassq (buffer
, Vbuffer_alist
);
1985 aelt_cons
= Fmemq (aelt
, Vbuffer_alist
);
1986 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
1987 XSETCDR (aelt_cons
, Qnil
);
1988 Vbuffer_alist
= nconc2 (Vbuffer_alist
, aelt_cons
);
1989 Vinhibit_quit
= tem
;
1991 /* Update buffer lists of selected frame. */
1992 fset_buffer_list (f
, Fdelq (buffer
, f
->buffer_list
));
1993 fset_buried_buffer_list
1994 (f
, Fcons (buffer
, Fdelq (buffer
, f
->buried_buffer_list
)));
1996 /* Run buffer-list-update-hook. */
1997 if (!NILP (Vrun_hooks
))
1998 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
2003 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode
, Sset_buffer_major_mode
, 1, 1, 0,
2004 doc
: /* Set an appropriate major mode for BUFFER.
2005 For the *scratch* buffer, use `initial-major-mode', otherwise choose a mode
2006 according to the default value of `major-mode'.
2007 Use this function before selecting the buffer, since it may need to inspect
2008 the current buffer's major mode. */)
2009 (Lisp_Object buffer
)
2012 Lisp_Object function
;
2014 CHECK_BUFFER (buffer
);
2016 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
2017 error ("Attempt to set major mode for a dead buffer");
2019 if (strcmp (SSDATA (BVAR (XBUFFER (buffer
), name
)), "*scratch*") == 0)
2020 function
= find_symbol_value (intern ("initial-major-mode"));
2023 function
= BVAR (&buffer_defaults
, major_mode
);
2025 && NILP (Fget (BVAR (current_buffer
, major_mode
), Qmode_class
)))
2026 function
= BVAR (current_buffer
, major_mode
);
2029 if (NILP (function
) || EQ (function
, Qfundamental_mode
))
2032 count
= SPECPDL_INDEX ();
2034 /* To select a nonfundamental mode,
2035 select the buffer temporarily and then call the mode function. */
2037 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2039 Fset_buffer (buffer
);
2042 return unbind_to (count
, Qnil
);
2045 DEFUN ("current-buffer", Fcurrent_buffer
, Scurrent_buffer
, 0, 0, 0,
2046 doc
: /* Return the current buffer as a Lisp object. */)
2049 register Lisp_Object buf
;
2050 XSETBUFFER (buf
, current_buffer
);
2054 /* Set the current buffer to B, and do not set windows_or_buffers_changed.
2055 This is used by redisplay. */
2058 set_buffer_internal_1 (register struct buffer
*b
)
2060 register struct buffer
*old_buf
;
2061 register Lisp_Object tail
;
2063 #ifdef USE_MMAP_FOR_BUFFERS
2064 if (b
->text
->beg
== NULL
)
2065 enlarge_buffer_text (b
, 0);
2066 #endif /* USE_MMAP_FOR_BUFFERS */
2068 if (current_buffer
== b
)
2071 BUFFER_CHECK_INDIRECTION (b
);
2073 old_buf
= current_buffer
;
2075 last_known_column_point
= -1; /* Invalidate indentation cache. */
2079 /* Put the undo list back in the base buffer, so that it appears
2080 that an indirect buffer shares the undo list of its base. */
2081 if (old_buf
->base_buffer
)
2082 bset_undo_list (old_buf
->base_buffer
, BVAR (old_buf
, undo_list
));
2084 /* If the old current buffer has markers to record PT, BEGV and ZV
2085 when it is not current, update them now. */
2086 record_buffer_markers (old_buf
);
2089 /* Get the undo list from the base buffer, so that it appears
2090 that an indirect buffer shares the undo list of its base. */
2092 bset_undo_list (b
, BVAR (b
->base_buffer
, undo_list
));
2094 /* If the new current buffer has markers to record PT, BEGV and ZV
2095 when it is not current, fetch them now. */
2096 fetch_buffer_markers (b
);
2098 /* Look down buffer's list of local Lisp variables
2099 to find and update any that forward into C variables. */
2103 for (tail
= BVAR (b
, local_var_alist
); CONSP (tail
); tail
= XCDR (tail
))
2105 Lisp_Object var
= XCAR (XCAR (tail
));
2106 struct Lisp_Symbol
*sym
= XSYMBOL (var
);
2107 if (sym
->redirect
== SYMBOL_LOCALIZED
/* Just to be sure. */
2108 && SYMBOL_BLV (sym
)->fwd
)
2109 /* Just reference the variable
2110 to cause it to become set for this buffer. */
2111 Fsymbol_value (var
);
2114 /* Do the same with any others that were local to the previous buffer */
2115 while (b
!= old_buf
&& (b
= old_buf
, b
));
2118 /* Switch to buffer B temporarily for redisplay purposes.
2119 This avoids certain things that don't need to be done within redisplay. */
2122 set_buffer_temp (struct buffer
*b
)
2124 register struct buffer
*old_buf
;
2126 if (current_buffer
== b
)
2129 old_buf
= current_buffer
;
2132 /* If the old current buffer has markers to record PT, BEGV and ZV
2133 when it is not current, update them now. */
2134 record_buffer_markers (old_buf
);
2136 /* If the new current buffer has markers to record PT, BEGV and ZV
2137 when it is not current, fetch them now. */
2138 fetch_buffer_markers (b
);
2141 DEFUN ("set-buffer", Fset_buffer
, Sset_buffer
, 1, 1, 0,
2142 doc
: /* Make buffer BUFFER-OR-NAME current for editing operations.
2143 BUFFER-OR-NAME may be a buffer or the name of an existing buffer.
2144 See also `with-current-buffer' when you want to make a buffer current
2145 temporarily. This function does not display the buffer, so its effect
2146 ends when the current command terminates. Use `switch-to-buffer' or
2147 `pop-to-buffer' to switch buffers permanently.
2148 The return value is the buffer made current. */)
2149 (register Lisp_Object buffer_or_name
)
2151 register Lisp_Object buffer
;
2152 buffer
= Fget_buffer (buffer_or_name
);
2154 nsberror (buffer_or_name
);
2155 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
2156 error ("Selecting deleted buffer");
2157 set_buffer_internal (XBUFFER (buffer
));
2162 restore_buffer (Lisp_Object buffer_or_name
)
2164 Fset_buffer (buffer_or_name
);
2167 /* Set the current buffer to BUFFER provided if it is alive. */
2170 set_buffer_if_live (Lisp_Object buffer
)
2172 if (BUFFER_LIVE_P (XBUFFER (buffer
)))
2173 set_buffer_internal (XBUFFER (buffer
));
2176 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only
,
2177 Sbarf_if_buffer_read_only
, 0, 1, 0,
2178 doc
: /* Signal a `buffer-read-only' error if the current buffer is read-only.
2179 If the text under POSITION (which defaults to point) has the
2180 `inhibit-read-only' text property set, the error will not be raised. */)
2184 XSETFASTINT (pos
, PT
);
2188 if (!NILP (BVAR (current_buffer
, read_only
))
2189 && NILP (Vinhibit_read_only
)
2190 && NILP (Fget_text_property (pos
, Qinhibit_read_only
, Qnil
)))
2191 xsignal1 (Qbuffer_read_only
, Fcurrent_buffer ());
2195 DEFUN ("erase-buffer", Ferase_buffer
, Serase_buffer
, 0, 0, "*",
2196 doc
: /* Delete the entire contents of the current buffer.
2197 Any narrowing restriction in effect (see `narrow-to-region') is removed,
2198 so the buffer is truly empty after this. */)
2205 current_buffer
->last_window_start
= 1;
2206 /* Prevent warnings, or suspension of auto saving, that would happen
2207 if future size is less than past size. Use of erase-buffer
2208 implies that the future text is not really related to the past text. */
2209 XSETFASTINT (BVAR (current_buffer
, save_length
), 0);
2214 validate_region (register Lisp_Object
*b
, register Lisp_Object
*e
)
2216 CHECK_NUMBER_COERCE_MARKER (*b
);
2217 CHECK_NUMBER_COERCE_MARKER (*e
);
2219 if (XINT (*b
) > XINT (*e
))
2222 tem
= *b
; *b
= *e
; *e
= tem
;
2225 if (! (BEGV
<= XINT (*b
) && XINT (*e
) <= ZV
))
2226 args_out_of_range_3 (Fcurrent_buffer (), *b
, *e
);
2229 /* Advance BYTE_POS up to a character boundary
2230 and return the adjusted position. */
2233 advance_to_char_boundary (ptrdiff_t byte_pos
)
2237 if (byte_pos
== BEG
)
2238 /* Beginning of buffer is always a character boundary. */
2241 c
= FETCH_BYTE (byte_pos
);
2242 if (! CHAR_HEAD_P (c
))
2244 /* We should advance BYTE_POS only when C is a constituent of a
2245 multibyte sequence. */
2246 ptrdiff_t orig_byte_pos
= byte_pos
;
2251 c
= FETCH_BYTE (byte_pos
);
2253 while (! CHAR_HEAD_P (c
) && byte_pos
> BEG
);
2255 if (byte_pos
< orig_byte_pos
)
2256 byte_pos
= orig_byte_pos
;
2257 /* If C is a constituent of a multibyte sequence, BYTE_POS was
2258 surely advance to the correct character boundary. If C is
2259 not, BYTE_POS was unchanged. */
2265 DEFUN ("buffer-swap-text", Fbuffer_swap_text
, Sbuffer_swap_text
,
2267 doc
: /* Swap the text between current buffer and BUFFER. */)
2268 (Lisp_Object buffer
)
2270 struct buffer
*other_buffer
;
2271 CHECK_BUFFER (buffer
);
2272 other_buffer
= XBUFFER (buffer
);
2274 if (!BUFFER_LIVE_P (other_buffer
))
2275 error ("Cannot swap a dead buffer's text");
2277 /* Actually, it probably works just fine.
2278 * if (other_buffer == current_buffer)
2279 * error ("Cannot swap a buffer's text with itself"); */
2281 /* Actually, this may be workable as well, tho probably only if they're
2283 if (other_buffer
->base_buffer
2284 || current_buffer
->base_buffer
)
2285 error ("Cannot swap indirect buffers's text");
2287 { /* This is probably harder to make work. */
2288 struct buffer
*other
;
2289 FOR_EACH_BUFFER (other
)
2290 if (other
->base_buffer
== other_buffer
2291 || other
->base_buffer
== current_buffer
)
2292 error ("One of the buffers to swap has indirect buffers");
2295 #define swapfield(field, type) \
2297 type tmp##field = other_buffer->field; \
2298 other_buffer->field = current_buffer->field; \
2299 current_buffer->field = tmp##field; \
2301 #define swapfield_(field, type) \
2303 type tmp##field = BVAR (other_buffer, field); \
2304 bset_##field (other_buffer, BVAR (current_buffer, field)); \
2305 bset_##field (current_buffer, tmp##field); \
2308 swapfield (own_text
, struct buffer_text
);
2309 eassert (current_buffer
->text
== ¤t_buffer
->own_text
);
2310 eassert (other_buffer
->text
== &other_buffer
->own_text
);
2312 r_alloc_reset_variable ((void **) ¤t_buffer
->own_text
.beg
,
2313 (void **) &other_buffer
->own_text
.beg
);
2314 r_alloc_reset_variable ((void **) &other_buffer
->own_text
.beg
,
2315 (void **) ¤t_buffer
->own_text
.beg
);
2316 #endif /* REL_ALLOC */
2318 swapfield (pt
, ptrdiff_t);
2319 swapfield (pt_byte
, ptrdiff_t);
2320 swapfield (begv
, ptrdiff_t);
2321 swapfield (begv_byte
, ptrdiff_t);
2322 swapfield (zv
, ptrdiff_t);
2323 swapfield (zv_byte
, ptrdiff_t);
2324 eassert (!current_buffer
->base_buffer
);
2325 eassert (!other_buffer
->base_buffer
);
2326 swapfield (indirections
, ptrdiff_t);
2327 current_buffer
->clip_changed
= 1; other_buffer
->clip_changed
= 1;
2328 swapfield (newline_cache
, struct region_cache
*);
2329 swapfield (width_run_cache
, struct region_cache
*);
2330 swapfield (bidi_paragraph_cache
, struct region_cache
*);
2331 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2332 other_buffer
->prevent_redisplay_optimizations_p
= 1;
2333 swapfield (overlays_before
, struct Lisp_Overlay
*);
2334 swapfield (overlays_after
, struct Lisp_Overlay
*);
2335 swapfield (overlay_center
, ptrdiff_t);
2336 swapfield_ (undo_list
, Lisp_Object
);
2337 swapfield_ (mark
, Lisp_Object
);
2338 swapfield_ (enable_multibyte_characters
, Lisp_Object
);
2339 swapfield_ (bidi_display_reordering
, Lisp_Object
);
2340 swapfield_ (bidi_paragraph_direction
, Lisp_Object
);
2341 /* FIXME: Not sure what we should do with these *_marker fields.
2342 Hopefully they're just nil anyway. */
2343 swapfield_ (pt_marker
, Lisp_Object
);
2344 swapfield_ (begv_marker
, Lisp_Object
);
2345 swapfield_ (zv_marker
, Lisp_Object
);
2346 bset_point_before_scroll (current_buffer
, Qnil
);
2347 bset_point_before_scroll (other_buffer
, Qnil
);
2349 current_buffer
->text
->modiff
++; other_buffer
->text
->modiff
++;
2350 current_buffer
->text
->chars_modiff
++; other_buffer
->text
->chars_modiff
++;
2351 current_buffer
->text
->overlay_modiff
++; other_buffer
->text
->overlay_modiff
++;
2352 current_buffer
->text
->beg_unchanged
= current_buffer
->text
->gpt
;
2353 current_buffer
->text
->end_unchanged
= current_buffer
->text
->gpt
;
2354 other_buffer
->text
->beg_unchanged
= other_buffer
->text
->gpt
;
2355 other_buffer
->text
->end_unchanged
= other_buffer
->text
->gpt
;
2357 struct Lisp_Marker
*m
;
2358 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
2359 if (m
->buffer
== other_buffer
)
2360 m
->buffer
= current_buffer
;
2362 /* Since there's no indirect buffer in sight, markers on
2363 BUF_MARKERS(buf) should either be for `buf' or dead. */
2364 eassert (!m
->buffer
);
2365 for (m
= BUF_MARKERS (other_buffer
); m
; m
= m
->next
)
2366 if (m
->buffer
== current_buffer
)
2367 m
->buffer
= other_buffer
;
2369 /* Since there's no indirect buffer in sight, markers on
2370 BUF_MARKERS(buf) should either be for `buf' or dead. */
2371 eassert (!m
->buffer
);
2373 { /* Some of the C code expects that both window markers of a
2374 live window points to that window's buffer. So since we
2375 just swapped the markers between the two buffers, we need
2376 to undo the effect of this swap for window markers. */
2377 Lisp_Object w
= selected_window
, ws
= Qnil
;
2378 Lisp_Object buf1
, buf2
;
2379 XSETBUFFER (buf1
, current_buffer
); XSETBUFFER (buf2
, other_buffer
);
2381 while (NILP (Fmemq (w
, ws
)))
2384 if (MARKERP (XWINDOW (w
)->pointm
)
2385 && (EQ (XWINDOW (w
)->contents
, buf1
)
2386 || EQ (XWINDOW (w
)->contents
, buf2
)))
2387 Fset_marker (XWINDOW (w
)->pointm
,
2389 (BUF_BEGV (XBUFFER (XWINDOW (w
)->contents
))),
2390 XWINDOW (w
)->contents
);
2391 /* Blindly copied from pointm part. */
2392 if (MARKERP (XWINDOW (w
)->old_pointm
)
2393 && (EQ (XWINDOW (w
)->contents
, buf1
)
2394 || EQ (XWINDOW (w
)->contents
, buf2
)))
2395 Fset_marker (XWINDOW (w
)->old_pointm
,
2397 (BUF_BEGV (XBUFFER (XWINDOW (w
)->contents
))),
2398 XWINDOW (w
)->contents
);
2399 if (MARKERP (XWINDOW (w
)->start
)
2400 && (EQ (XWINDOW (w
)->contents
, buf1
)
2401 || EQ (XWINDOW (w
)->contents
, buf2
)))
2402 Fset_marker (XWINDOW (w
)->start
,
2404 (XBUFFER (XWINDOW (w
)->contents
)->last_window_start
),
2405 XWINDOW (w
)->contents
);
2406 w
= Fnext_window (w
, Qt
, Qt
);
2410 if (current_buffer
->text
->intervals
)
2411 (eassert (EQ (current_buffer
->text
->intervals
->up
.obj
, buffer
)),
2412 XSETBUFFER (current_buffer
->text
->intervals
->up
.obj
, current_buffer
));
2413 if (other_buffer
->text
->intervals
)
2414 (eassert (EQ (other_buffer
->text
->intervals
->up
.obj
, Fcurrent_buffer ())),
2415 XSETBUFFER (other_buffer
->text
->intervals
->up
.obj
, other_buffer
));
2420 DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte
, Sset_buffer_multibyte
,
2422 doc
: /* Set the multibyte flag of the current buffer to FLAG.
2423 If FLAG is t, this makes the buffer a multibyte buffer.
2424 If FLAG is nil, this makes the buffer a single-byte buffer.
2425 In these cases, the buffer contents remain unchanged as a sequence of
2426 bytes but the contents viewed as characters do change.
2427 If FLAG is `to', this makes the buffer a multibyte buffer by changing
2428 all eight-bit bytes to eight-bit characters.
2429 If the multibyte flag was really changed, undo information of the
2430 current buffer is cleared. */)
2433 struct Lisp_Marker
*tail
, *markers
;
2434 struct buffer
*other
;
2436 bool narrowed
= (BEG
!= BEGV
|| Z
!= ZV
);
2437 bool modified_p
= !NILP (Fbuffer_modified_p (Qnil
));
2438 Lisp_Object old_undo
= BVAR (current_buffer
, undo_list
);
2440 if (current_buffer
->base_buffer
)
2441 error ("Cannot do `set-buffer-multibyte' on an indirect buffer");
2443 /* Do nothing if nothing actually changes. */
2444 if (NILP (flag
) == NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
2447 /* Don't record these buffer changes. We will put a special undo entry
2449 bset_undo_list (current_buffer
, Qt
);
2451 /* If the cached position is for this buffer, clear it out. */
2452 clear_charpos_cache (current_buffer
);
2455 begv
= BEGV_BYTE
, zv
= ZV_BYTE
;
2457 begv
= BEGV
, zv
= ZV
;
2460 error ("Changing multibyteness in a narrowed buffer");
2462 invalidate_buffer_caches (current_buffer
, BEGV
, ZV
);
2466 ptrdiff_t pos
, stop
;
2469 /* Do this first, so it can use CHAR_TO_BYTE
2470 to calculate the old correspondences. */
2471 set_intervals_multibyte (0);
2473 bset_enable_multibyte_characters (current_buffer
, Qnil
);
2479 TEMP_SET_PT_BOTH (PT_BYTE
, PT_BYTE
);
2482 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
2483 tail
->charpos
= tail
->bytepos
;
2485 /* Convert multibyte form of 8-bit characters to unibyte. */
2500 if (ASCII_CHAR_P (*p
))
2502 else if (CHAR_BYTE8_HEAD_P (*p
))
2504 c
= STRING_CHAR_AND_LENGTH (p
, bytes
);
2505 /* Delete all bytes for this 8-bit character but the
2506 last one, and change the last one to the character
2509 del_range_2 (pos
, pos
, pos
+ bytes
, pos
+ bytes
, 0);
2521 bytes
= BYTES_BY_CHAR_HEAD (*p
);
2522 p
+= bytes
, pos
+= bytes
;
2526 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2531 ptrdiff_t pos
, stop
;
2532 unsigned char *p
, *pend
;
2534 /* Be sure not to have a multibyte sequence striding over the GAP.
2535 Ex: We change this: "...abc\302 _GAP_ \241def..."
2536 to: "...abc _GAP_ \302\241def..." */
2539 && GPT_BYTE
> 1 && GPT_BYTE
< Z_BYTE
2540 && ! CHAR_HEAD_P (*(GAP_END_ADDR
)))
2542 unsigned char *q
= GPT_ADDR
- 1;
2544 while (! CHAR_HEAD_P (*q
) && q
> BEG_ADDR
) q
--;
2545 if (LEADING_CODE_P (*q
))
2547 ptrdiff_t new_gpt
= GPT_BYTE
- (GPT_ADDR
- q
);
2549 move_gap_both (new_gpt
, new_gpt
);
2553 /* Make the buffer contents valid as multibyte by converting
2554 8-bit characters to multibyte form. */
2572 if (ASCII_CHAR_P (*p
))
2574 else if (EQ (flag
, Qt
)
2575 && ! CHAR_BYTE8_HEAD_P (*p
)
2576 && (bytes
= MULTIBYTE_LENGTH (p
, pend
)) > 0)
2577 p
+= bytes
, pos
+= bytes
;
2580 unsigned char tmp
[MAX_MULTIBYTE_LENGTH
];
2583 c
= BYTE8_TO_CHAR (*p
);
2584 bytes
= CHAR_STRING (c
, tmp
);
2586 TEMP_SET_PT_BOTH (pos
+ 1, pos
+ 1);
2588 insert_1_both ((char *) tmp
+ 1, bytes
, bytes
, 1, 0, 0);
2589 /* Now the gap is after the just inserted data. */
2607 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2609 /* Do this first, so that chars_in_text asks the right question.
2610 set_intervals_multibyte needs it too. */
2611 bset_enable_multibyte_characters (current_buffer
, Qt
);
2613 GPT_BYTE
= advance_to_char_boundary (GPT_BYTE
);
2614 GPT
= chars_in_text (BEG_ADDR
, GPT_BYTE
- BEG_BYTE
) + BEG
;
2616 Z
= chars_in_text (GAP_END_ADDR
, Z_BYTE
- GPT_BYTE
) + GPT
;
2618 BEGV_BYTE
= advance_to_char_boundary (BEGV_BYTE
);
2619 if (BEGV_BYTE
> GPT_BYTE
)
2620 BEGV
= chars_in_text (GAP_END_ADDR
, BEGV_BYTE
- GPT_BYTE
) + GPT
;
2622 BEGV
= chars_in_text (BEG_ADDR
, BEGV_BYTE
- BEG_BYTE
) + BEG
;
2624 ZV_BYTE
= advance_to_char_boundary (ZV_BYTE
);
2625 if (ZV_BYTE
> GPT_BYTE
)
2626 ZV
= chars_in_text (GAP_END_ADDR
, ZV_BYTE
- GPT_BYTE
) + GPT
;
2628 ZV
= chars_in_text (BEG_ADDR
, ZV_BYTE
- BEG_BYTE
) + BEG
;
2631 ptrdiff_t byte
= advance_to_char_boundary (PT_BYTE
);
2634 if (byte
> GPT_BYTE
)
2635 position
= chars_in_text (GAP_END_ADDR
, byte
- GPT_BYTE
) + GPT
;
2637 position
= chars_in_text (BEG_ADDR
, byte
- BEG_BYTE
) + BEG
;
2638 TEMP_SET_PT_BOTH (position
, byte
);
2641 tail
= markers
= BUF_MARKERS (current_buffer
);
2643 /* This prevents BYTE_TO_CHAR (that is, buf_bytepos_to_charpos) from
2644 getting confused by the markers that have not yet been updated.
2645 It is also a signal that it should never create a marker. */
2646 BUF_MARKERS (current_buffer
) = NULL
;
2648 for (; tail
; tail
= tail
->next
)
2650 tail
->bytepos
= advance_to_char_boundary (tail
->bytepos
);
2651 tail
->charpos
= BYTE_TO_CHAR (tail
->bytepos
);
2654 /* Make sure no markers were put on the chain
2655 while the chain value was incorrect. */
2656 if (BUF_MARKERS (current_buffer
))
2659 BUF_MARKERS (current_buffer
) = markers
;
2661 /* Do this last, so it can calculate the new correspondences
2662 between chars and bytes. */
2663 set_intervals_multibyte (1);
2666 if (!EQ (old_undo
, Qt
))
2668 /* Represent all the above changes by a special undo entry. */
2669 bset_undo_list (current_buffer
,
2670 Fcons (list3 (Qapply
,
2671 intern ("set-buffer-multibyte"),
2672 NILP (flag
) ? Qt
: Qnil
),
2676 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2678 /* If buffer is shown in a window, let redisplay consider other windows. */
2679 if (buffer_window_count (current_buffer
))
2680 windows_or_buffers_changed
= 10;
2682 /* Copy this buffer's new multibyte status
2683 into all of its indirect buffers. */
2684 FOR_EACH_BUFFER (other
)
2685 if (other
->base_buffer
== current_buffer
&& BUFFER_LIVE_P (other
))
2687 BVAR (other
, enable_multibyte_characters
)
2688 = BVAR (current_buffer
, enable_multibyte_characters
);
2689 other
->prevent_redisplay_optimizations_p
= 1;
2692 /* Restore the modifiedness of the buffer. */
2693 if (!modified_p
&& !NILP (Fbuffer_modified_p (Qnil
)))
2694 Fset_buffer_modified_p (Qnil
);
2696 /* Update coding systems of this buffer's process (if any). */
2698 Lisp_Object process
;
2700 process
= Fget_buffer_process (Fcurrent_buffer ());
2701 if (PROCESSP (process
))
2702 setup_process_coding_systems (process
);
2708 DEFUN ("kill-all-local-variables", Fkill_all_local_variables
,
2709 Skill_all_local_variables
, 0, 0, 0,
2710 doc
: /* Switch to Fundamental mode by killing current buffer's local variables.
2711 Most local variable bindings are eliminated so that the default values
2712 become effective once more. Also, the syntax table is set from
2713 `standard-syntax-table', the local keymap is set to nil,
2714 and the abbrev table from `fundamental-mode-abbrev-table'.
2715 This function also forces redisplay of the mode line.
2717 Every function to select a new major mode starts by
2718 calling this function.
2720 As a special exception, local variables whose names have
2721 a non-nil `permanent-local' property are not eliminated by this function.
2723 The first thing this function does is run
2724 the normal hook `change-major-mode-hook'. */)
2727 run_hook (Qchange_major_mode_hook
);
2729 /* Make sure none of the bindings in local_var_alist
2730 remain swapped in, in their symbols. */
2732 swap_out_buffer_local_variables (current_buffer
);
2734 /* Actually eliminate all local bindings of this buffer. */
2736 reset_buffer_local_variables (current_buffer
, 0);
2738 /* Force mode-line redisplay. Useful here because all major mode
2739 commands call this function. */
2740 update_mode_lines
= 12;
2745 /* Make sure no local variables remain set up with buffer B
2746 for their current values. */
2749 swap_out_buffer_local_variables (struct buffer
*b
)
2751 Lisp_Object oalist
, alist
, buffer
;
2753 XSETBUFFER (buffer
, b
);
2754 oalist
= BVAR (b
, local_var_alist
);
2756 for (alist
= oalist
; CONSP (alist
); alist
= XCDR (alist
))
2758 Lisp_Object sym
= XCAR (XCAR (alist
));
2759 eassert (XSYMBOL (sym
)->redirect
== SYMBOL_LOCALIZED
);
2760 /* Need not do anything if some other buffer's binding is
2762 if (EQ (SYMBOL_BLV (XSYMBOL (sym
))->where
, buffer
))
2764 /* Symbol is set up for this buffer's old local value:
2766 swap_in_global_binding (XSYMBOL (sym
));
2771 /* Find all the overlays in the current buffer that contain position POS.
2772 Return the number found, and store them in a vector in *VEC_PTR.
2773 Store in *LEN_PTR the size allocated for the vector.
2774 Store in *NEXT_PTR the next position after POS where an overlay starts,
2775 or ZV if there are no more overlays between POS and ZV.
2776 Store in *PREV_PTR the previous position before POS where an overlay ends,
2777 or where an overlay starts which ends at or after POS;
2778 or BEGV if there are no such overlays from BEGV to POS.
2779 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2781 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2782 when this function is called.
2784 If EXTEND, make the vector bigger if necessary.
2785 If not, never extend the vector,
2786 and store only as many overlays as will fit.
2787 But still return the total number of overlays.
2789 If CHANGE_REQ, any position written into *PREV_PTR or
2790 *NEXT_PTR is guaranteed to be not equal to POS, unless it is the
2791 default (BEGV or ZV). */
2794 overlays_at (EMACS_INT pos
, bool extend
, Lisp_Object
**vec_ptr
,
2796 ptrdiff_t *next_ptr
, ptrdiff_t *prev_ptr
, bool change_req
)
2798 Lisp_Object overlay
, start
, end
;
2799 struct Lisp_Overlay
*tail
;
2801 ptrdiff_t len
= *len_ptr
;
2802 Lisp_Object
*vec
= *vec_ptr
;
2803 ptrdiff_t next
= ZV
;
2804 ptrdiff_t prev
= BEGV
;
2805 bool inhibit_storing
= 0;
2807 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2809 ptrdiff_t startpos
, endpos
;
2811 XSETMISC (overlay
, tail
);
2813 start
= OVERLAY_START (overlay
);
2814 end
= OVERLAY_END (overlay
);
2815 endpos
= OVERLAY_POSITION (end
);
2822 startpos
= OVERLAY_POSITION (start
);
2823 /* This one ends at or after POS
2824 so its start counts for PREV_PTR if it's before POS. */
2825 if (prev
< startpos
&& startpos
< pos
)
2829 if (startpos
<= pos
)
2833 /* The supplied vector is full.
2834 Either make it bigger, or don't store any more in it. */
2837 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2843 inhibit_storing
= 1;
2846 if (!inhibit_storing
)
2848 /* Keep counting overlays even if we can't return them all. */
2851 else if (startpos
< next
)
2855 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2857 ptrdiff_t startpos
, endpos
;
2859 XSETMISC (overlay
, tail
);
2861 start
= OVERLAY_START (overlay
);
2862 end
= OVERLAY_END (overlay
);
2863 startpos
= OVERLAY_POSITION (start
);
2866 if (startpos
< next
)
2870 endpos
= OVERLAY_POSITION (end
);
2877 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2883 inhibit_storing
= 1;
2886 if (!inhibit_storing
)
2890 if (startpos
< pos
&& startpos
> prev
)
2893 else if (endpos
< pos
&& endpos
> prev
)
2895 else if (endpos
== pos
&& startpos
> prev
2896 && (!change_req
|| startpos
< pos
))
2907 /* Find all the overlays in the current buffer that overlap the range
2908 BEG-END, or are empty at BEG, or are empty at END provided END
2909 denotes the position at the end of the current buffer.
2911 Return the number found, and store them in a vector in *VEC_PTR.
2912 Store in *LEN_PTR the size allocated for the vector.
2913 Store in *NEXT_PTR the next position after POS where an overlay starts,
2914 or ZV if there are no more overlays.
2915 Store in *PREV_PTR the previous position before POS where an overlay ends,
2916 or BEGV if there are no previous overlays.
2917 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2919 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2920 when this function is called.
2922 If EXTEND, make the vector bigger if necessary.
2923 If not, never extend the vector,
2924 and store only as many overlays as will fit.
2925 But still return the total number of overlays. */
2928 overlays_in (EMACS_INT beg
, EMACS_INT end
, bool extend
,
2929 Lisp_Object
**vec_ptr
, ptrdiff_t *len_ptr
,
2930 ptrdiff_t *next_ptr
, ptrdiff_t *prev_ptr
)
2932 Lisp_Object overlay
, ostart
, oend
;
2933 struct Lisp_Overlay
*tail
;
2935 ptrdiff_t len
= *len_ptr
;
2936 Lisp_Object
*vec
= *vec_ptr
;
2937 ptrdiff_t next
= ZV
;
2938 ptrdiff_t prev
= BEGV
;
2939 bool inhibit_storing
= 0;
2940 bool end_is_Z
= end
== Z
;
2942 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2944 ptrdiff_t startpos
, endpos
;
2946 XSETMISC (overlay
, tail
);
2948 ostart
= OVERLAY_START (overlay
);
2949 oend
= OVERLAY_END (overlay
);
2950 endpos
= OVERLAY_POSITION (oend
);
2957 startpos
= OVERLAY_POSITION (ostart
);
2958 /* Count an interval if it overlaps the range, is empty at the
2959 start of the range, or is empty at END provided END denotes the
2960 end of the buffer. */
2961 if ((beg
< endpos
&& startpos
< end
)
2962 || (startpos
== endpos
2963 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
2967 /* The supplied vector is full.
2968 Either make it bigger, or don't store any more in it. */
2971 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2977 inhibit_storing
= 1;
2980 if (!inhibit_storing
)
2982 /* Keep counting overlays even if we can't return them all. */
2985 else if (startpos
< next
)
2989 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2991 ptrdiff_t startpos
, endpos
;
2993 XSETMISC (overlay
, tail
);
2995 ostart
= OVERLAY_START (overlay
);
2996 oend
= OVERLAY_END (overlay
);
2997 startpos
= OVERLAY_POSITION (ostart
);
3000 if (startpos
< next
)
3004 endpos
= OVERLAY_POSITION (oend
);
3005 /* Count an interval if it overlaps the range, is empty at the
3006 start of the range, or is empty at END provided END denotes the
3007 end of the buffer. */
3008 if ((beg
< endpos
&& startpos
< end
)
3009 || (startpos
== endpos
3010 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
3016 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
3022 inhibit_storing
= 1;
3025 if (!inhibit_storing
)
3029 else if (endpos
< beg
&& endpos
> prev
)
3041 /* Return true if there exists an overlay with a non-nil
3042 `mouse-face' property overlapping OVERLAY. */
3045 mouse_face_overlay_overlaps (Lisp_Object overlay
)
3047 ptrdiff_t start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3048 ptrdiff_t end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3049 ptrdiff_t n
, i
, size
;
3050 Lisp_Object
*v
, tem
;
3051 Lisp_Object vbuf
[10];
3054 size
= ARRAYELTS (vbuf
);
3056 n
= overlays_in (start
, end
, 0, &v
, &size
, NULL
, NULL
);
3059 SAFE_NALLOCA (v
, 1, n
);
3060 overlays_in (start
, end
, 0, &v
, &n
, NULL
, NULL
);
3063 for (i
= 0; i
< n
; ++i
)
3064 if (!EQ (v
[i
], overlay
)
3065 && (tem
= Foverlay_get (overlay
, Qmouse_face
),
3075 /* Fast function to just test if we're at an overlay boundary. */
3077 overlay_touches_p (ptrdiff_t pos
)
3079 Lisp_Object overlay
;
3080 struct Lisp_Overlay
*tail
;
3082 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
3086 XSETMISC (overlay
,tail
);
3087 eassert (OVERLAYP (overlay
));
3089 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3092 if (endpos
== pos
|| OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
)
3096 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
3100 XSETMISC (overlay
, tail
);
3101 eassert (OVERLAYP (overlay
));
3103 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3106 if (startpos
== pos
|| OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
)
3114 Lisp_Object overlay
;
3117 EMACS_INT spriority
; /* Secondary priority. */
3121 compare_overlays (const void *v1
, const void *v2
)
3123 const struct sortvec
*s1
= v1
;
3124 const struct sortvec
*s2
= v2
;
3125 /* Return 1 if s1 should take precedence, -1 if v2 should take precedence,
3126 and 0 if they're equal. */
3127 if (s1
->priority
!= s2
->priority
)
3128 return s1
->priority
< s2
->priority
? -1 : 1;
3129 /* If the priority is equal, give precedence to the one not covered by the
3130 other. If neither covers the other, obey spriority. */
3131 else if (s1
->beg
< s2
->beg
)
3132 return (s1
->end
< s2
->end
&& s1
->spriority
> s2
->spriority
? 1 : -1);
3133 else if (s1
->beg
> s2
->beg
)
3134 return (s1
->end
> s2
->end
&& s1
->spriority
< s2
->spriority
? -1 : 1);
3135 else if (s1
->end
!= s2
->end
)
3136 return s2
->end
< s1
->end
? -1 : 1;
3137 else if (s1
->spriority
!= s2
->spriority
)
3138 return (s1
->spriority
< s2
->spriority
? -1 : 1);
3139 else if (EQ (s1
->overlay
, s2
->overlay
))
3142 /* Avoid the non-determinism of qsort by choosing an arbitrary ordering
3143 between "equal" overlays. The result can still change between
3144 invocations of Emacs, but it won't change in the middle of
3145 `find_field' (bug#6830). */
3146 return XLI (s1
->overlay
) < XLI (s2
->overlay
) ? -1 : 1;
3149 /* Sort an array of overlays by priority. The array is modified in place.
3150 The return value is the new size; this may be smaller than the original
3151 size if some of the overlays were invalid or were window-specific. */
3153 sort_overlays (Lisp_Object
*overlay_vec
, ptrdiff_t noverlays
, struct window
*w
)
3157 struct sortvec
*sortvec
;
3159 SAFE_NALLOCA (sortvec
, 1, noverlays
);
3161 /* Put the valid and relevant overlays into sortvec. */
3163 for (i
= 0, j
= 0; i
< noverlays
; i
++)
3166 Lisp_Object overlay
;
3168 overlay
= overlay_vec
[i
];
3169 if (OVERLAYP (overlay
)
3170 && OVERLAY_POSITION (OVERLAY_START (overlay
)) > 0
3171 && OVERLAY_POSITION (OVERLAY_END (overlay
)) > 0)
3173 /* If we're interested in a specific window, then ignore
3174 overlays that are limited to some other window. */
3179 window
= Foverlay_get (overlay
, Qwindow
);
3180 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3184 /* This overlay is good and counts: put it into sortvec. */
3185 sortvec
[j
].overlay
= overlay
;
3186 sortvec
[j
].beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3187 sortvec
[j
].end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3188 tem
= Foverlay_get (overlay
, Qpriority
);
3191 sortvec
[j
].priority
= 0;
3192 sortvec
[j
].spriority
= 0;
3194 else if (INTEGERP (tem
))
3196 sortvec
[j
].priority
= XINT (tem
);
3197 sortvec
[j
].spriority
= 0;
3199 else if (CONSP (tem
))
3201 Lisp_Object car
= XCAR (tem
);
3202 Lisp_Object cdr
= XCDR (tem
);
3203 sortvec
[j
].priority
= INTEGERP (car
) ? XINT (car
) : 0;
3204 sortvec
[j
].spriority
= INTEGERP (cdr
) ? XINT (cdr
) : 0;
3211 /* Sort the overlays into the proper order: increasing priority. */
3214 qsort (sortvec
, noverlays
, sizeof (struct sortvec
), compare_overlays
);
3216 for (i
= 0; i
< noverlays
; i
++)
3217 overlay_vec
[i
] = sortvec
[i
].overlay
;
3225 Lisp_Object string
, string2
;
3232 struct sortstr
*buf
; /* An array that expands as needed; never freed. */
3233 ptrdiff_t size
; /* Allocated length of that array. */
3234 ptrdiff_t used
; /* How much of the array is currently in use. */
3235 ptrdiff_t bytes
; /* Total length of the strings in buf. */
3238 /* Buffers for storing information about the overlays touching a given
3239 position. These could be automatic variables in overlay_strings, but
3240 it's more efficient to hold onto the memory instead of repeatedly
3241 allocating and freeing it. */
3242 static struct sortstrlist overlay_heads
, overlay_tails
;
3243 static unsigned char *overlay_str_buf
;
3245 /* Allocated length of overlay_str_buf. */
3246 static ptrdiff_t overlay_str_len
;
3248 /* A comparison function suitable for passing to qsort. */
3250 cmp_for_strings (const void *as1
, const void *as2
)
3252 struct sortstr
const *s1
= as1
;
3253 struct sortstr
const *s2
= as2
;
3254 if (s1
->size
!= s2
->size
)
3255 return s2
->size
< s1
->size
? -1 : 1;
3256 if (s1
->priority
!= s2
->priority
)
3257 return s1
->priority
< s2
->priority
? -1 : 1;
3262 record_overlay_string (struct sortstrlist
*ssl
, Lisp_Object str
,
3263 Lisp_Object str2
, Lisp_Object pri
, ptrdiff_t size
)
3267 if (ssl
->used
== ssl
->size
)
3268 ssl
->buf
= xpalloc (ssl
->buf
, &ssl
->size
, 5, -1, sizeof *ssl
->buf
);
3269 ssl
->buf
[ssl
->used
].string
= str
;
3270 ssl
->buf
[ssl
->used
].string2
= str2
;
3271 ssl
->buf
[ssl
->used
].size
= size
;
3272 ssl
->buf
[ssl
->used
].priority
= (INTEGERP (pri
) ? XINT (pri
) : 0);
3275 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3276 nbytes
= SCHARS (str
);
3277 else if (! STRING_MULTIBYTE (str
))
3278 nbytes
= count_size_as_multibyte (SDATA (str
),
3281 nbytes
= SBYTES (str
);
3283 if (INT_ADD_OVERFLOW (ssl
->bytes
, nbytes
))
3284 memory_full (SIZE_MAX
);
3285 ssl
->bytes
+= nbytes
;
3289 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3290 nbytes
= SCHARS (str2
);
3291 else if (! STRING_MULTIBYTE (str2
))
3292 nbytes
= count_size_as_multibyte (SDATA (str2
),
3295 nbytes
= SBYTES (str2
);
3297 if (INT_ADD_OVERFLOW (ssl
->bytes
, nbytes
))
3298 memory_full (SIZE_MAX
);
3299 ssl
->bytes
+= nbytes
;
3303 /* Concatenate the strings associated with overlays that begin or end
3304 at POS, ignoring overlays that are specific to windows other than W.
3305 The strings are concatenated in the appropriate order: shorter
3306 overlays nest inside longer ones, and higher priority inside lower.
3307 Normally all of the after-strings come first, but zero-sized
3308 overlays have their after-strings ride along with the
3309 before-strings because it would look strange to print them
3312 Returns the concatenated string's length, and return the pointer to
3313 that string via PSTR, if that variable is non-NULL. The storage of
3314 the concatenated strings may be overwritten by subsequent calls. */
3317 overlay_strings (ptrdiff_t pos
, struct window
*w
, unsigned char **pstr
)
3319 Lisp_Object overlay
, window
, str
;
3320 struct Lisp_Overlay
*ov
;
3321 ptrdiff_t startpos
, endpos
;
3322 bool multibyte
= ! NILP (BVAR (current_buffer
, enable_multibyte_characters
));
3324 overlay_heads
.used
= overlay_heads
.bytes
= 0;
3325 overlay_tails
.used
= overlay_tails
.bytes
= 0;
3326 for (ov
= current_buffer
->overlays_before
; ov
; ov
= ov
->next
)
3328 XSETMISC (overlay
, ov
);
3329 eassert (OVERLAYP (overlay
));
3331 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3332 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3335 if (endpos
!= pos
&& startpos
!= pos
)
3337 window
= Foverlay_get (overlay
, Qwindow
);
3338 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3341 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3342 record_overlay_string (&overlay_heads
, str
,
3344 ? Foverlay_get (overlay
, Qafter_string
)
3346 Foverlay_get (overlay
, Qpriority
),
3348 else if (endpos
== pos
3349 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3350 record_overlay_string (&overlay_tails
, str
, Qnil
,
3351 Foverlay_get (overlay
, Qpriority
),
3354 for (ov
= current_buffer
->overlays_after
; ov
; ov
= ov
->next
)
3356 XSETMISC (overlay
, ov
);
3357 eassert (OVERLAYP (overlay
));
3359 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3360 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3363 if (endpos
!= pos
&& startpos
!= pos
)
3365 window
= Foverlay_get (overlay
, Qwindow
);
3366 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3369 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3370 record_overlay_string (&overlay_heads
, str
,
3372 ? Foverlay_get (overlay
, Qafter_string
)
3374 Foverlay_get (overlay
, Qpriority
),
3376 else if (endpos
== pos
3377 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3378 record_overlay_string (&overlay_tails
, str
, Qnil
,
3379 Foverlay_get (overlay
, Qpriority
),
3382 if (overlay_tails
.used
> 1)
3383 qsort (overlay_tails
.buf
, overlay_tails
.used
, sizeof (struct sortstr
),
3385 if (overlay_heads
.used
> 1)
3386 qsort (overlay_heads
.buf
, overlay_heads
.used
, sizeof (struct sortstr
),
3388 if (overlay_heads
.bytes
|| overlay_tails
.bytes
)
3395 if (INT_ADD_OVERFLOW (overlay_heads
.bytes
, overlay_tails
.bytes
))
3396 memory_full (SIZE_MAX
);
3397 total
= overlay_heads
.bytes
+ overlay_tails
.bytes
;
3398 if (total
> overlay_str_len
)
3399 overlay_str_buf
= xpalloc (overlay_str_buf
, &overlay_str_len
,
3400 total
- overlay_str_len
, -1, 1);
3402 p
= overlay_str_buf
;
3403 for (i
= overlay_tails
.used
; --i
>= 0;)
3406 tem
= overlay_tails
.buf
[i
].string
;
3407 nbytes
= copy_text (SDATA (tem
), p
,
3409 STRING_MULTIBYTE (tem
), multibyte
);
3412 for (i
= 0; i
< overlay_heads
.used
; ++i
)
3415 tem
= overlay_heads
.buf
[i
].string
;
3416 nbytes
= copy_text (SDATA (tem
), p
,
3418 STRING_MULTIBYTE (tem
), multibyte
);
3420 tem
= overlay_heads
.buf
[i
].string2
;
3423 nbytes
= copy_text (SDATA (tem
), p
,
3425 STRING_MULTIBYTE (tem
), multibyte
);
3429 if (p
!= overlay_str_buf
+ total
)
3432 *pstr
= overlay_str_buf
;
3438 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
3441 recenter_overlay_lists (struct buffer
*buf
, ptrdiff_t pos
)
3443 Lisp_Object overlay
, beg
, end
;
3444 struct Lisp_Overlay
*prev
, *tail
, *next
;
3446 /* See if anything in overlays_before should move to overlays_after. */
3448 /* We don't strictly need prev in this loop; it should always be nil.
3449 But we use it for symmetry and in case that should cease to be true
3450 with some future change. */
3452 for (tail
= buf
->overlays_before
; tail
; prev
= tail
, tail
= next
)
3455 XSETMISC (overlay
, tail
);
3456 eassert (OVERLAYP (overlay
));
3458 beg
= OVERLAY_START (overlay
);
3459 end
= OVERLAY_END (overlay
);
3461 if (OVERLAY_POSITION (end
) > pos
)
3463 /* OVERLAY needs to be moved. */
3464 ptrdiff_t where
= OVERLAY_POSITION (beg
);
3465 struct Lisp_Overlay
*other
, *other_prev
;
3467 /* Splice the cons cell TAIL out of overlays_before. */
3471 set_buffer_overlays_before (buf
, next
);
3473 /* Search thru overlays_after for where to put it. */
3475 for (other
= buf
->overlays_after
; other
;
3476 other_prev
= other
, other
= other
->next
)
3478 Lisp_Object otherbeg
, otheroverlay
;
3480 XSETMISC (otheroverlay
, other
);
3481 eassert (OVERLAYP (otheroverlay
));
3483 otherbeg
= OVERLAY_START (otheroverlay
);
3484 if (OVERLAY_POSITION (otherbeg
) >= where
)
3488 /* Add TAIL to overlays_after before OTHER. */
3491 other_prev
->next
= tail
;
3493 set_buffer_overlays_after (buf
, tail
);
3497 /* We've reached the things that should stay in overlays_before.
3498 All the rest of overlays_before must end even earlier,
3503 /* See if anything in overlays_after should be in overlays_before. */
3505 for (tail
= buf
->overlays_after
; tail
; prev
= tail
, tail
= next
)
3508 XSETMISC (overlay
, tail
);
3509 eassert (OVERLAYP (overlay
));
3511 beg
= OVERLAY_START (overlay
);
3512 end
= OVERLAY_END (overlay
);
3514 /* Stop looking, when we know that nothing further
3515 can possibly end before POS. */
3516 if (OVERLAY_POSITION (beg
) > pos
)
3519 if (OVERLAY_POSITION (end
) <= pos
)
3521 /* OVERLAY needs to be moved. */
3522 ptrdiff_t where
= OVERLAY_POSITION (end
);
3523 struct Lisp_Overlay
*other
, *other_prev
;
3525 /* Splice the cons cell TAIL out of overlays_after. */
3529 set_buffer_overlays_after (buf
, next
);
3531 /* Search thru overlays_before for where to put it. */
3533 for (other
= buf
->overlays_before
; other
;
3534 other_prev
= other
, other
= other
->next
)
3536 Lisp_Object otherend
, otheroverlay
;
3538 XSETMISC (otheroverlay
, other
);
3539 eassert (OVERLAYP (otheroverlay
));
3541 otherend
= OVERLAY_END (otheroverlay
);
3542 if (OVERLAY_POSITION (otherend
) <= where
)
3546 /* Add TAIL to overlays_before before OTHER. */
3549 other_prev
->next
= tail
;
3551 set_buffer_overlays_before (buf
, tail
);
3556 buf
->overlay_center
= pos
;
3560 adjust_overlays_for_insert (ptrdiff_t pos
, ptrdiff_t length
)
3562 /* After an insertion, the lists are still sorted properly,
3563 but we may need to update the value of the overlay center. */
3564 if (current_buffer
->overlay_center
>= pos
)
3565 current_buffer
->overlay_center
+= length
;
3569 adjust_overlays_for_delete (ptrdiff_t pos
, ptrdiff_t length
)
3571 if (current_buffer
->overlay_center
< pos
)
3572 /* The deletion was to our right. No change needed; the before- and
3573 after-lists are still consistent. */
3575 else if (current_buffer
->overlay_center
- pos
> length
)
3576 /* The deletion was to our left. We need to adjust the center value
3577 to account for the change in position, but the lists are consistent
3578 given the new value. */
3579 current_buffer
->overlay_center
-= length
;
3581 /* We're right in the middle. There might be things on the after-list
3582 that now belong on the before-list. Recentering will move them,
3583 and also update the center point. */
3584 recenter_overlay_lists (current_buffer
, pos
);
3587 /* Fix up overlays that were garbled as a result of permuting markers
3588 in the range START through END. Any overlay with at least one
3589 endpoint in this range will need to be unlinked from the overlay
3590 list and reinserted in its proper place.
3591 Such an overlay might even have negative size at this point.
3592 If so, we'll make the overlay empty. */
3594 fix_start_end_in_overlays (register ptrdiff_t start
, register ptrdiff_t end
)
3596 Lisp_Object overlay
;
3597 struct Lisp_Overlay
*before_list
IF_LINT (= NULL
);
3598 struct Lisp_Overlay
*after_list
IF_LINT (= NULL
);
3599 /* These are either nil, indicating that before_list or after_list
3600 should be assigned, or the cons cell the cdr of which should be
3602 struct Lisp_Overlay
*beforep
= NULL
, *afterp
= NULL
;
3603 /* 'Parent', likewise, indicates a cons cell or
3604 current_buffer->overlays_before or overlays_after, depending
3605 which loop we're in. */
3606 struct Lisp_Overlay
*tail
, *parent
;
3607 ptrdiff_t startpos
, endpos
;
3609 /* This algorithm shifts links around instead of consing and GCing.
3610 The loop invariant is that before_list (resp. after_list) is a
3611 well-formed list except that its last element, the CDR of beforep
3612 (resp. afterp) if beforep (afterp) isn't nil or before_list
3613 (after_list) if it is, is still uninitialized. So it's not a bug
3614 that before_list isn't initialized, although it may look
3616 for (parent
= NULL
, tail
= current_buffer
->overlays_before
; tail
;)
3618 XSETMISC (overlay
, tail
);
3620 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3621 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3623 /* If the overlay is backwards, make it empty. */
3624 if (endpos
< startpos
)
3627 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3635 || (startpos
>= start
&& startpos
< end
))
3637 /* Add it to the end of the wrong list. Later on,
3638 recenter_overlay_lists will move it to the right place. */
3639 if (endpos
< current_buffer
->overlay_center
)
3644 afterp
->next
= tail
;
3652 beforep
->next
= tail
;
3656 set_buffer_overlays_before (current_buffer
, tail
->next
);
3658 parent
->next
= tail
->next
;
3662 parent
= tail
, tail
= parent
->next
;
3664 for (parent
= NULL
, tail
= current_buffer
->overlays_after
; tail
;)
3666 XSETMISC (overlay
, tail
);
3668 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3669 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3671 /* If the overlay is backwards, make it empty. */
3672 if (endpos
< startpos
)
3675 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3679 if (startpos
>= end
)
3682 if (startpos
>= start
3683 || (endpos
>= start
&& endpos
< end
))
3685 if (endpos
< current_buffer
->overlay_center
)
3690 afterp
->next
= tail
;
3698 beforep
->next
= tail
;
3702 set_buffer_overlays_after (current_buffer
, tail
->next
);
3704 parent
->next
= tail
->next
;
3708 parent
= tail
, tail
= parent
->next
;
3711 /* Splice the constructed (wrong) lists into the buffer's lists,
3712 and let the recenter function make it sane again. */
3715 beforep
->next
= current_buffer
->overlays_before
;
3716 set_buffer_overlays_before (current_buffer
, before_list
);
3721 afterp
->next
= current_buffer
->overlays_after
;
3722 set_buffer_overlays_after (current_buffer
, after_list
);
3724 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3727 /* We have two types of overlay: the one whose ending marker is
3728 after-insertion-marker (this is the usual case) and the one whose
3729 ending marker is before-insertion-marker. When `overlays_before'
3730 contains overlays of the latter type and the former type in this
3731 order and both overlays end at inserting position, inserting a text
3732 increases only the ending marker of the latter type, which results
3733 in incorrect ordering of `overlays_before'.
3735 This function fixes ordering of overlays in the slot
3736 `overlays_before' of the buffer *BP. Before the insertion, `point'
3737 was at PREV, and now is at POS. */
3740 fix_overlays_before (struct buffer
*bp
, ptrdiff_t prev
, ptrdiff_t pos
)
3742 /* If parent is nil, replace overlays_before; otherwise, parent->next. */
3743 struct Lisp_Overlay
*tail
= bp
->overlays_before
, *parent
= NULL
, *right_pair
;
3745 ptrdiff_t end
IF_LINT (= 0);
3747 /* After the insertion, the several overlays may be in incorrect
3748 order. The possibility is that, in the list `overlays_before',
3749 an overlay which ends at POS appears after an overlay which ends
3750 at PREV. Since POS is greater than PREV, we must fix the
3751 ordering of these overlays, by moving overlays ends at POS before
3752 the overlays ends at PREV. */
3754 /* At first, find a place where disordered overlays should be linked
3755 in. It is where an overlay which end before POS exists. (i.e. an
3756 overlay whose ending marker is after-insertion-marker if disorder
3759 && (XSETMISC (tem
, tail
),
3760 (end
= OVERLAY_POSITION (OVERLAY_END (tem
))) >= pos
))
3766 /* If we don't find such an overlay,
3767 or the found one ends before PREV,
3768 or the found one is the last one in the list,
3769 we don't have to fix anything. */
3770 if (!tail
|| end
< prev
|| !tail
->next
)
3773 right_pair
= parent
;
3777 /* Now, end position of overlays in the list TAIL should be before
3778 or equal to PREV. In the loop, an overlay which ends at POS is
3779 moved ahead to the place indicated by the CDR of RIGHT_PAIR. If
3780 we found an overlay which ends before PREV, the remaining
3781 overlays are in correct order. */
3784 XSETMISC (tem
, tail
);
3785 end
= OVERLAY_POSITION (OVERLAY_END (tem
));
3788 { /* This overlay is disordered. */
3789 struct Lisp_Overlay
*found
= tail
;
3791 /* Unlink the found overlay. */
3793 parent
->next
= tail
;
3794 /* Move an overlay at RIGHT_PLACE to the next of the found one,
3795 and link it into the right place. */
3798 found
->next
= bp
->overlays_before
;
3799 set_buffer_overlays_before (bp
, found
);
3803 found
->next
= right_pair
->next
;
3804 right_pair
->next
= found
;
3807 else if (end
== prev
)
3812 else /* No more disordered overlay. */
3817 DEFUN ("overlayp", Foverlayp
, Soverlayp
, 1, 1, 0,
3818 doc
: /* Return t if OBJECT is an overlay. */)
3819 (Lisp_Object object
)
3821 return (OVERLAYP (object
) ? Qt
: Qnil
);
3824 DEFUN ("make-overlay", Fmake_overlay
, Smake_overlay
, 2, 5, 0,
3825 doc
: /* Create a new overlay with range BEG to END in BUFFER and return it.
3826 If omitted, BUFFER defaults to the current buffer.
3827 BEG and END may be integers or markers.
3828 The fourth arg FRONT-ADVANCE, if non-nil, makes the marker
3829 for the front of the overlay advance when text is inserted there
3830 (which means the text *is not* included in the overlay).
3831 The fifth arg REAR-ADVANCE, if non-nil, makes the marker
3832 for the rear of the overlay advance when text is inserted there
3833 (which means the text *is* included in the overlay). */)
3834 (Lisp_Object beg
, Lisp_Object end
, Lisp_Object buffer
,
3835 Lisp_Object front_advance
, Lisp_Object rear_advance
)
3837 Lisp_Object overlay
;
3841 XSETBUFFER (buffer
, current_buffer
);
3843 CHECK_BUFFER (buffer
);
3845 if (MARKERP (beg
) && !EQ (Fmarker_buffer (beg
), buffer
))
3846 signal_error ("Marker points into wrong buffer", beg
);
3847 if (MARKERP (end
) && !EQ (Fmarker_buffer (end
), buffer
))
3848 signal_error ("Marker points into wrong buffer", end
);
3850 CHECK_NUMBER_COERCE_MARKER (beg
);
3851 CHECK_NUMBER_COERCE_MARKER (end
);
3853 if (XINT (beg
) > XINT (end
))
3856 temp
= beg
; beg
= end
; end
= temp
;
3859 b
= XBUFFER (buffer
);
3861 beg
= Fset_marker (Fmake_marker (), beg
, buffer
);
3862 end
= Fset_marker (Fmake_marker (), end
, buffer
);
3864 if (!NILP (front_advance
))
3865 XMARKER (beg
)->insertion_type
= 1;
3866 if (!NILP (rear_advance
))
3867 XMARKER (end
)->insertion_type
= 1;
3869 overlay
= build_overlay (beg
, end
, Qnil
);
3871 /* Put the new overlay on the wrong list. */
3872 end
= OVERLAY_END (overlay
);
3873 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
3875 eassert (b
->overlays_after
|| (XOVERLAY (overlay
)->next
== NULL
));
3876 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3877 set_buffer_overlays_after (b
, XOVERLAY (overlay
));
3881 eassert (b
->overlays_before
|| (XOVERLAY (overlay
)->next
== NULL
));
3882 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3883 set_buffer_overlays_before (b
, XOVERLAY (overlay
));
3885 /* This puts it in the right list, and in the right order. */
3886 recenter_overlay_lists (b
, b
->overlay_center
);
3888 /* We don't need to redisplay the region covered by the overlay, because
3889 the overlay has no properties at the moment. */
3894 /* Mark a section of BUF as needing redisplay because of overlays changes. */
3897 modify_overlay (struct buffer
*buf
, ptrdiff_t start
, ptrdiff_t end
)
3901 ptrdiff_t temp
= start
;
3906 BUF_COMPUTE_UNCHANGED (buf
, start
, end
);
3908 bset_redisplay (buf
);
3910 ++BUF_OVERLAY_MODIFF (buf
);
3913 /* Remove OVERLAY from LIST. */
3915 static struct Lisp_Overlay
*
3916 unchain_overlay (struct Lisp_Overlay
*list
, struct Lisp_Overlay
*overlay
)
3918 register struct Lisp_Overlay
*tail
, **prev
= &list
;
3920 for (tail
= list
; tail
; prev
= &tail
->next
, tail
= *prev
)
3921 if (tail
== overlay
)
3923 *prev
= overlay
->next
;
3924 overlay
->next
= NULL
;
3930 /* Remove OVERLAY from both overlay lists of B. */
3933 unchain_both (struct buffer
*b
, Lisp_Object overlay
)
3935 struct Lisp_Overlay
*ov
= XOVERLAY (overlay
);
3937 set_buffer_overlays_before (b
, unchain_overlay (b
->overlays_before
, ov
));
3938 set_buffer_overlays_after (b
, unchain_overlay (b
->overlays_after
, ov
));
3939 eassert (XOVERLAY (overlay
)->next
== NULL
);
3942 DEFUN ("move-overlay", Fmove_overlay
, Smove_overlay
, 3, 4, 0,
3943 doc
: /* Set the endpoints of OVERLAY to BEG and END in BUFFER.
3944 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.
3945 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current
3947 (Lisp_Object overlay
, Lisp_Object beg
, Lisp_Object end
, Lisp_Object buffer
)
3949 struct buffer
*b
, *ob
= 0;
3950 Lisp_Object obuffer
;
3951 ptrdiff_t count
= SPECPDL_INDEX ();
3952 ptrdiff_t n_beg
, n_end
, o_beg
IF_LINT (= 0), o_end
IF_LINT (= 0);
3954 CHECK_OVERLAY (overlay
);
3956 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3958 XSETBUFFER (buffer
, current_buffer
);
3959 CHECK_BUFFER (buffer
);
3961 if (NILP (Fbuffer_live_p (buffer
)))
3962 error ("Attempt to move overlay to a dead buffer");
3964 if (MARKERP (beg
) && !EQ (Fmarker_buffer (beg
), buffer
))
3965 signal_error ("Marker points into wrong buffer", beg
);
3966 if (MARKERP (end
) && !EQ (Fmarker_buffer (end
), buffer
))
3967 signal_error ("Marker points into wrong buffer", end
);
3969 CHECK_NUMBER_COERCE_MARKER (beg
);
3970 CHECK_NUMBER_COERCE_MARKER (end
);
3972 if (XINT (beg
) > XINT (end
))
3975 temp
= beg
; beg
= end
; end
= temp
;
3978 specbind (Qinhibit_quit
, Qt
);
3980 obuffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3981 b
= XBUFFER (buffer
);
3983 if (!NILP (obuffer
))
3985 ob
= XBUFFER (obuffer
);
3987 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3988 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3990 unchain_both (ob
, overlay
);
3993 /* Set the overlay boundaries, which may clip them. */
3994 Fset_marker (OVERLAY_START (overlay
), beg
, buffer
);
3995 Fset_marker (OVERLAY_END (overlay
), end
, buffer
);
3997 n_beg
= marker_position (OVERLAY_START (overlay
));
3998 n_end
= marker_position (OVERLAY_END (overlay
));
4000 /* If the overlay has changed buffers, do a thorough redisplay. */
4001 if (!EQ (buffer
, obuffer
))
4003 /* Redisplay where the overlay was. */
4005 modify_overlay (ob
, o_beg
, o_end
);
4007 /* Redisplay where the overlay is going to be. */
4008 modify_overlay (b
, n_beg
, n_end
);
4011 /* Redisplay the area the overlay has just left, or just enclosed. */
4014 modify_overlay (b
, o_end
, n_end
);
4015 else if (o_end
== n_end
)
4016 modify_overlay (b
, o_beg
, n_beg
);
4018 modify_overlay (b
, min (o_beg
, n_beg
), max (o_end
, n_end
));
4021 /* Delete the overlay if it is empty after clipping and has the
4022 evaporate property. */
4023 if (n_beg
== n_end
&& !NILP (Foverlay_get (overlay
, Qevaporate
)))
4024 return unbind_to (count
, Fdelete_overlay (overlay
));
4026 /* Put the overlay into the new buffer's overlay lists, first on the
4028 if (n_end
< b
->overlay_center
)
4030 XOVERLAY (overlay
)->next
= b
->overlays_after
;
4031 set_buffer_overlays_after (b
, XOVERLAY (overlay
));
4035 XOVERLAY (overlay
)->next
= b
->overlays_before
;
4036 set_buffer_overlays_before (b
, XOVERLAY (overlay
));
4039 /* This puts it in the right list, and in the right order. */
4040 recenter_overlay_lists (b
, b
->overlay_center
);
4042 return unbind_to (count
, overlay
);
4045 DEFUN ("delete-overlay", Fdelete_overlay
, Sdelete_overlay
, 1, 1, 0,
4046 doc
: /* Delete the overlay OVERLAY from its buffer. */)
4047 (Lisp_Object overlay
)
4051 ptrdiff_t count
= SPECPDL_INDEX ();
4053 CHECK_OVERLAY (overlay
);
4055 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4059 b
= XBUFFER (buffer
);
4060 specbind (Qinhibit_quit
, Qt
);
4062 unchain_both (b
, overlay
);
4063 drop_overlay (b
, XOVERLAY (overlay
));
4065 /* When deleting an overlay with before or after strings, turn off
4066 display optimizations for the affected buffer, on the basis that
4067 these strings may contain newlines. This is easier to do than to
4068 check for that situation during redisplay. */
4069 if (!windows_or_buffers_changed
4070 && (!NILP (Foverlay_get (overlay
, Qbefore_string
))
4071 || !NILP (Foverlay_get (overlay
, Qafter_string
))))
4072 b
->prevent_redisplay_optimizations_p
= 1;
4074 return unbind_to (count
, Qnil
);
4077 DEFUN ("delete-all-overlays", Fdelete_all_overlays
, Sdelete_all_overlays
, 0, 1, 0,
4078 doc
: /* Delete all overlays of BUFFER.
4079 BUFFER omitted or nil means delete all overlays of the current
4081 (Lisp_Object buffer
)
4083 delete_all_overlays (decode_buffer (buffer
));
4087 /* Overlay dissection functions. */
4089 DEFUN ("overlay-start", Foverlay_start
, Soverlay_start
, 1, 1, 0,
4090 doc
: /* Return the position at which OVERLAY starts. */)
4091 (Lisp_Object overlay
)
4093 CHECK_OVERLAY (overlay
);
4095 return (Fmarker_position (OVERLAY_START (overlay
)));
4098 DEFUN ("overlay-end", Foverlay_end
, Soverlay_end
, 1, 1, 0,
4099 doc
: /* Return the position at which OVERLAY ends. */)
4100 (Lisp_Object overlay
)
4102 CHECK_OVERLAY (overlay
);
4104 return (Fmarker_position (OVERLAY_END (overlay
)));
4107 DEFUN ("overlay-buffer", Foverlay_buffer
, Soverlay_buffer
, 1, 1, 0,
4108 doc
: /* Return the buffer OVERLAY belongs to.
4109 Return nil if OVERLAY has been deleted. */)
4110 (Lisp_Object overlay
)
4112 CHECK_OVERLAY (overlay
);
4114 return Fmarker_buffer (OVERLAY_START (overlay
));
4117 DEFUN ("overlay-properties", Foverlay_properties
, Soverlay_properties
, 1, 1, 0,
4118 doc
: /* Return a list of the properties on OVERLAY.
4119 This is a copy of OVERLAY's plist; modifying its conses has no effect on
4121 (Lisp_Object overlay
)
4123 CHECK_OVERLAY (overlay
);
4125 return Fcopy_sequence (XOVERLAY (overlay
)->plist
);
4129 DEFUN ("overlays-at", Foverlays_at
, Soverlays_at
, 1, 2, 0,
4130 doc
: /* Return a list of the overlays that contain the character at POS.
4131 If SORTED is non-nil, then sort them by decreasing priority. */)
4132 (Lisp_Object pos
, Lisp_Object sorted
)
4134 ptrdiff_t len
, noverlays
;
4135 Lisp_Object
*overlay_vec
;
4138 CHECK_NUMBER_COERCE_MARKER (pos
);
4140 if (!buffer_has_overlays ())
4144 /* We can't use alloca here because overlays_at can call xrealloc. */
4145 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4147 /* Put all the overlays we want in a vector in overlay_vec.
4148 Store the length in len. */
4149 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4153 noverlays
= sort_overlays (overlay_vec
, noverlays
,
4154 WINDOWP (sorted
) ? XWINDOW (sorted
) : NULL
);
4156 /* Make a list of them all. */
4157 result
= Flist (noverlays
, overlay_vec
);
4159 xfree (overlay_vec
);
4163 DEFUN ("overlays-in", Foverlays_in
, Soverlays_in
, 2, 2, 0,
4164 doc
: /* Return a list of the overlays that overlap the region BEG ... END.
4165 Overlap means that at least one character is contained within the overlay
4166 and also contained within the specified region.
4167 Empty overlays are included in the result if they are located at BEG,
4168 between BEG and END, or at END provided END denotes the position at the
4169 end of the buffer. */)
4170 (Lisp_Object beg
, Lisp_Object end
)
4172 ptrdiff_t len
, noverlays
;
4173 Lisp_Object
*overlay_vec
;
4176 CHECK_NUMBER_COERCE_MARKER (beg
);
4177 CHECK_NUMBER_COERCE_MARKER (end
);
4179 if (!buffer_has_overlays ())
4183 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4185 /* Put all the overlays we want in a vector in overlay_vec.
4186 Store the length in len. */
4187 noverlays
= overlays_in (XINT (beg
), XINT (end
), 1, &overlay_vec
, &len
,
4190 /* Make a list of them all. */
4191 result
= Flist (noverlays
, overlay_vec
);
4193 xfree (overlay_vec
);
4197 DEFUN ("next-overlay-change", Fnext_overlay_change
, Snext_overlay_change
,
4199 doc
: /* Return the next position after POS where an overlay starts or ends.
4200 If there are no overlay boundaries from POS to (point-max),
4201 the value is (point-max). */)
4204 ptrdiff_t i
, len
, noverlays
;
4206 Lisp_Object
*overlay_vec
;
4208 CHECK_NUMBER_COERCE_MARKER (pos
);
4210 if (!buffer_has_overlays ())
4211 return make_number (ZV
);
4214 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4216 /* Put all the overlays we want in a vector in overlay_vec.
4217 Store the length in len.
4218 endpos gets the position where the next overlay starts. */
4219 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4222 /* If any of these overlays ends before endpos,
4223 use its ending point instead. */
4224 for (i
= 0; i
< noverlays
; i
++)
4229 oend
= OVERLAY_END (overlay_vec
[i
]);
4230 oendpos
= OVERLAY_POSITION (oend
);
4231 if (oendpos
< endpos
)
4235 xfree (overlay_vec
);
4236 return make_number (endpos
);
4239 DEFUN ("previous-overlay-change", Fprevious_overlay_change
,
4240 Sprevious_overlay_change
, 1, 1, 0,
4241 doc
: /* Return the previous position before POS where an overlay starts or ends.
4242 If there are no overlay boundaries from (point-min) to POS,
4243 the value is (point-min). */)
4247 Lisp_Object
*overlay_vec
;
4250 CHECK_NUMBER_COERCE_MARKER (pos
);
4252 if (!buffer_has_overlays ())
4253 return make_number (BEGV
);
4255 /* At beginning of buffer, we know the answer;
4256 avoid bug subtracting 1 below. */
4257 if (XINT (pos
) == BEGV
)
4261 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4263 /* Put all the overlays we want in a vector in overlay_vec.
4264 Store the length in len.
4265 prevpos gets the position of the previous change. */
4266 overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4269 xfree (overlay_vec
);
4270 return make_number (prevpos
);
4273 /* These functions are for debugging overlays. */
4275 DEFUN ("overlay-lists", Foverlay_lists
, Soverlay_lists
, 0, 0, 0,
4276 doc
: /* Return a pair of lists giving all the overlays of the current buffer.
4277 The car has all the overlays before the overlay center;
4278 the cdr has all the overlays after the overlay center.
4279 Recentering overlays moves overlays between these lists.
4280 The lists you get are copies, so that changing them has no effect.
4281 However, the overlays you get are the real objects that the buffer uses. */)
4284 struct Lisp_Overlay
*ol
;
4285 Lisp_Object before
= Qnil
, after
= Qnil
, tmp
;
4287 for (ol
= current_buffer
->overlays_before
; ol
; ol
= ol
->next
)
4290 before
= Fcons (tmp
, before
);
4292 for (ol
= current_buffer
->overlays_after
; ol
; ol
= ol
->next
)
4295 after
= Fcons (tmp
, after
);
4298 return Fcons (Fnreverse (before
), Fnreverse (after
));
4301 DEFUN ("overlay-recenter", Foverlay_recenter
, Soverlay_recenter
, 1, 1, 0,
4302 doc
: /* Recenter the overlays of the current buffer around position POS.
4303 That makes overlay lookup faster for positions near POS (but perhaps slower
4304 for positions far away from POS). */)
4308 CHECK_NUMBER_COERCE_MARKER (pos
);
4310 p
= clip_to_bounds (PTRDIFF_MIN
, XINT (pos
), PTRDIFF_MAX
);
4311 recenter_overlay_lists (current_buffer
, p
);
4315 DEFUN ("overlay-get", Foverlay_get
, Soverlay_get
, 2, 2, 0,
4316 doc
: /* Get the property of overlay OVERLAY with property name PROP. */)
4317 (Lisp_Object overlay
, Lisp_Object prop
)
4319 CHECK_OVERLAY (overlay
);
4320 return lookup_char_property (XOVERLAY (overlay
)->plist
, prop
, 0);
4323 DEFUN ("overlay-put", Foverlay_put
, Soverlay_put
, 3, 3, 0,
4324 doc
: /* Set one property of overlay OVERLAY: give property PROP value VALUE.
4325 VALUE will be returned.*/)
4326 (Lisp_Object overlay
, Lisp_Object prop
, Lisp_Object value
)
4328 Lisp_Object tail
, buffer
;
4331 CHECK_OVERLAY (overlay
);
4333 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4335 for (tail
= XOVERLAY (overlay
)->plist
;
4336 CONSP (tail
) && CONSP (XCDR (tail
));
4337 tail
= XCDR (XCDR (tail
)))
4338 if (EQ (XCAR (tail
), prop
))
4340 changed
= !EQ (XCAR (XCDR (tail
)), value
);
4341 XSETCAR (XCDR (tail
), value
);
4344 /* It wasn't in the list, so add it to the front. */
4345 changed
= !NILP (value
);
4347 (overlay
, Fcons (prop
, Fcons (value
, XOVERLAY (overlay
)->plist
)));
4349 if (! NILP (buffer
))
4352 modify_overlay (XBUFFER (buffer
),
4353 marker_position (OVERLAY_START (overlay
)),
4354 marker_position (OVERLAY_END (overlay
)));
4355 if (EQ (prop
, Qevaporate
) && ! NILP (value
)
4356 && (OVERLAY_POSITION (OVERLAY_START (overlay
))
4357 == OVERLAY_POSITION (OVERLAY_END (overlay
))))
4358 Fdelete_overlay (overlay
);
4364 /* Subroutine of report_overlay_modification. */
4366 /* Lisp vector holding overlay hook functions to call.
4367 Vector elements come in pairs.
4368 Each even-index element is a list of hook functions.
4369 The following odd-index element is the overlay they came from.
4371 Before the buffer change, we fill in this vector
4372 as we call overlay hook functions.
4373 After the buffer change, we get the functions to call from this vector.
4374 This way we always call the same functions before and after the change. */
4375 static Lisp_Object last_overlay_modification_hooks
;
4377 /* Number of elements actually used in last_overlay_modification_hooks. */
4378 static ptrdiff_t last_overlay_modification_hooks_used
;
4380 /* Add one functionlist/overlay pair
4381 to the end of last_overlay_modification_hooks. */
4384 add_overlay_mod_hooklist (Lisp_Object functionlist
, Lisp_Object overlay
)
4386 ptrdiff_t oldsize
= ASIZE (last_overlay_modification_hooks
);
4388 if (oldsize
- 1 <= last_overlay_modification_hooks_used
)
4389 last_overlay_modification_hooks
=
4390 larger_vector (last_overlay_modification_hooks
, 2, -1);
4391 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4392 functionlist
); last_overlay_modification_hooks_used
++;
4393 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4394 overlay
); last_overlay_modification_hooks_used
++;
4397 /* Run the modification-hooks of overlays that include
4398 any part of the text in START to END.
4399 If this change is an insertion, also
4400 run the insert-before-hooks of overlay starting at END,
4401 and the insert-after-hooks of overlay ending at START.
4403 This is called both before and after the modification.
4404 AFTER is true when we call after the modification.
4406 ARG1, ARG2, ARG3 are arguments to pass to the hook functions.
4407 When AFTER is nonzero, they are the start position,
4408 the position after the inserted new text,
4409 and the length of deleted or replaced old text. */
4412 report_overlay_modification (Lisp_Object start
, Lisp_Object end
, bool after
,
4413 Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
)
4415 Lisp_Object prop
, overlay
;
4416 struct Lisp_Overlay
*tail
;
4417 /* True if this change is an insertion. */
4418 bool insertion
= (after
? XFASTINT (arg3
) == 0 : EQ (start
, end
));
4423 /* We used to run the functions as soon as we found them and only register
4424 them in last_overlay_modification_hooks for the purpose of the `after'
4425 case. But running elisp code as we traverse the list of overlays is
4426 painful because the list can be modified by the elisp code so we had to
4427 copy at several places. We now simply do a read-only traversal that
4428 only collects the functions to run and we run them afterwards. It's
4429 simpler, especially since all the code was already there. -stef */
4433 /* We are being called before a change.
4434 Scan the overlays to find the functions to call. */
4435 last_overlay_modification_hooks_used
= 0;
4436 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4438 ptrdiff_t startpos
, endpos
;
4439 Lisp_Object ostart
, oend
;
4441 XSETMISC (overlay
, tail
);
4443 ostart
= OVERLAY_START (overlay
);
4444 oend
= OVERLAY_END (overlay
);
4445 endpos
= OVERLAY_POSITION (oend
);
4446 if (XFASTINT (start
) > endpos
)
4448 startpos
= OVERLAY_POSITION (ostart
);
4449 if (insertion
&& (XFASTINT (start
) == startpos
4450 || XFASTINT (end
) == startpos
))
4452 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4454 add_overlay_mod_hooklist (prop
, overlay
);
4456 if (insertion
&& (XFASTINT (start
) == endpos
4457 || XFASTINT (end
) == endpos
))
4459 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4461 add_overlay_mod_hooklist (prop
, overlay
);
4463 /* Test for intersecting intervals. This does the right thing
4464 for both insertion and deletion. */
4465 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4467 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4469 add_overlay_mod_hooklist (prop
, overlay
);
4473 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4475 ptrdiff_t startpos
, endpos
;
4476 Lisp_Object ostart
, oend
;
4478 XSETMISC (overlay
, tail
);
4480 ostart
= OVERLAY_START (overlay
);
4481 oend
= OVERLAY_END (overlay
);
4482 startpos
= OVERLAY_POSITION (ostart
);
4483 endpos
= OVERLAY_POSITION (oend
);
4484 if (XFASTINT (end
) < startpos
)
4486 if (insertion
&& (XFASTINT (start
) == startpos
4487 || XFASTINT (end
) == startpos
))
4489 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4491 add_overlay_mod_hooklist (prop
, overlay
);
4493 if (insertion
&& (XFASTINT (start
) == endpos
4494 || XFASTINT (end
) == endpos
))
4496 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4498 add_overlay_mod_hooklist (prop
, overlay
);
4500 /* Test for intersecting intervals. This does the right thing
4501 for both insertion and deletion. */
4502 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4504 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4506 add_overlay_mod_hooklist (prop
, overlay
);
4512 /* Call the functions recorded in last_overlay_modification_hooks.
4513 First copy the vector contents, in case some of these hooks
4514 do subsequent modification of the buffer. */
4515 ptrdiff_t size
= last_overlay_modification_hooks_used
;
4520 SAFE_ALLOCA_LISP (copy
, size
);
4521 memcpy (copy
, XVECTOR (last_overlay_modification_hooks
)->contents
,
4524 for (i
= 0; i
< size
;)
4526 Lisp_Object prop_i
, overlay_i
;
4528 overlay_i
= copy
[i
++];
4529 call_overlay_mod_hooks (prop_i
, overlay_i
, after
, arg1
, arg2
, arg3
);
4537 call_overlay_mod_hooks (Lisp_Object list
, Lisp_Object overlay
, bool after
,
4538 Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
)
4540 while (CONSP (list
))
4543 call4 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
);
4545 call5 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
, arg3
);
4550 /* Delete any zero-sized overlays at position POS, if the `evaporate'
4553 evaporate_overlays (ptrdiff_t pos
)
4555 Lisp_Object overlay
, hit_list
;
4556 struct Lisp_Overlay
*tail
;
4559 if (pos
<= current_buffer
->overlay_center
)
4560 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4563 XSETMISC (overlay
, tail
);
4564 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4567 if (endpos
== pos
&& OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
4568 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4569 hit_list
= Fcons (overlay
, hit_list
);
4572 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4575 XSETMISC (overlay
, tail
);
4576 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4579 if (startpos
== pos
&& OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
4580 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4581 hit_list
= Fcons (overlay
, hit_list
);
4583 for (; CONSP (hit_list
); hit_list
= XCDR (hit_list
))
4584 Fdelete_overlay (XCAR (hit_list
));
4587 /***********************************************************************
4588 Allocation with mmap
4589 ***********************************************************************/
4591 /* Note: WINDOWSNT implements this stuff on w32heap.c. */
4592 #if defined USE_MMAP_FOR_BUFFERS && !defined WINDOWSNT
4594 #include <sys/mman.h>
4597 #ifdef MAP_ANONYMOUS
4598 #define MAP_ANON MAP_ANONYMOUS
4605 #define MAP_FAILED ((void *) -1)
4613 /* Memory is allocated in regions which are mapped using mmap(2).
4614 The current implementation lets the system select mapped
4615 addresses; we're not using MAP_FIXED in general, except when
4616 trying to enlarge regions.
4618 Each mapped region starts with a mmap_region structure, the user
4619 area starts after that structure, aligned to MEM_ALIGN.
4621 +-----------------------+
4622 | struct mmap_info + |
4624 +-----------------------+
4628 +-----------------------+ */
4632 /* User-specified size. */
4633 size_t nbytes_specified
;
4635 /* Number of bytes mapped */
4636 size_t nbytes_mapped
;
4638 /* Pointer to the location holding the address of the memory
4639 allocated with the mmap'd block. The variable actually points
4640 after this structure. */
4643 /* Next and previous in list of all mmap'd regions. */
4644 struct mmap_region
*next
, *prev
;
4647 /* Doubly-linked list of mmap'd regions. */
4649 static struct mmap_region
*mmap_regions
;
4651 /* File descriptor for mmap. If we don't have anonymous mapping,
4652 /dev/zero will be opened on it. */
4656 /* Page size on this system. */
4658 static int mmap_page_size
;
4660 /* 1 means mmap has been initialized. */
4662 static bool mmap_initialized_p
;
4664 /* Value is X rounded up to the next multiple of N. */
4666 #define ROUND(X, N) (((X) + (N) - 1) / (N) * (N))
4668 /* Size of mmap_region structure plus padding. */
4670 #define MMAP_REGION_STRUCT_SIZE \
4671 ROUND (sizeof (struct mmap_region), MEM_ALIGN)
4673 /* Given a pointer P to the start of the user-visible part of a mapped
4674 region, return a pointer to the start of the region. */
4676 #define MMAP_REGION(P) \
4677 ((struct mmap_region *) ((char *) (P) - MMAP_REGION_STRUCT_SIZE))
4679 /* Given a pointer P to the start of a mapped region, return a pointer
4680 to the start of the user-visible part of the region. */
4682 #define MMAP_USER_AREA(P) \
4683 ((void *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
4685 #define MEM_ALIGN sizeof (double)
4687 /* Predicate returning true if part of the address range [START .. END]
4688 is currently mapped. Used to prevent overwriting an existing
4691 Default is to conservatively assume the address range is occupied by
4692 something else. This can be overridden by system configuration
4693 files if system-specific means to determine this exists. */
4695 #ifndef MMAP_ALLOCATED_P
4696 #define MMAP_ALLOCATED_P(start, end) 1
4699 /* Perform necessary initializations for the use of mmap. */
4705 /* The value of mmap_fd is initially 0 in temacs, and -1
4706 in a dumped Emacs. */
4709 /* No anonymous mmap -- we need the file descriptor. */
4710 mmap_fd
= emacs_open ("/dev/zero", O_RDONLY
, 0);
4712 fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno
));
4714 #endif /* MAP_ANON == 0 */
4716 if (mmap_initialized_p
)
4718 mmap_initialized_p
= 1;
4724 mmap_page_size
= getpagesize ();
4727 /* Unmap a region. P is a pointer to the start of the user-araa of
4731 mmap_free_1 (struct mmap_region
*r
)
4734 r
->next
->prev
= r
->prev
;
4736 r
->prev
->next
= r
->next
;
4738 mmap_regions
= r
->next
;
4740 if (munmap (r
, r
->nbytes_mapped
) == -1)
4741 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4745 /* Enlarge region R by NPAGES pages. NPAGES < 0 means shrink R.
4746 Value is true if successful. */
4749 mmap_enlarge (struct mmap_region
*r
, int npages
)
4751 char *region_end
= (char *) r
+ r
->nbytes_mapped
;
4757 /* Unmap pages at the end of the region. */
4758 nbytes
= - npages
* mmap_page_size
;
4759 if (munmap (region_end
- nbytes
, nbytes
) == -1)
4760 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4763 r
->nbytes_mapped
-= nbytes
;
4767 else if (npages
> 0)
4769 nbytes
= npages
* mmap_page_size
;
4771 /* Try to map additional pages at the end of the region. We
4772 cannot do this if the address range is already occupied by
4773 something else because mmap deletes any previous mapping.
4774 I'm not sure this is worth doing, let's see. */
4775 if (!MMAP_ALLOCATED_P (region_end
, region_end
+ nbytes
))
4779 p
= mmap (region_end
, nbytes
, PROT_READ
| PROT_WRITE
,
4780 MAP_ANON
| MAP_PRIVATE
| MAP_FIXED
, mmap_fd
, 0);
4781 if (p
== MAP_FAILED
)
4782 ; /* fprintf (stderr, "mmap: %s\n", emacs_strerror (errno)); */
4783 else if (p
!= region_end
)
4785 /* Kernels are free to choose a different address. In
4786 that case, unmap what we've mapped above; we have
4788 if (munmap (p
, nbytes
) == -1)
4789 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4793 r
->nbytes_mapped
+= nbytes
;
4803 /* Allocate a block of storage large enough to hold NBYTES bytes of
4804 data. A pointer to the data is returned in *VAR. VAR is thus the
4805 address of some variable which will use the data area.
4807 The allocation of 0 bytes is valid.
4809 If we can't allocate the necessary memory, set *VAR to null, and
4813 mmap_alloc (void **var
, size_t nbytes
)
4820 map
= ROUND (nbytes
+ MMAP_REGION_STRUCT_SIZE
, mmap_page_size
);
4821 p
= mmap (NULL
, map
, PROT_READ
| PROT_WRITE
, MAP_ANON
| MAP_PRIVATE
,
4824 if (p
== MAP_FAILED
)
4826 if (errno
!= ENOMEM
)
4827 fprintf (stderr
, "mmap: %s\n", emacs_strerror (errno
));
4832 struct mmap_region
*r
= p
;
4834 r
->nbytes_specified
= nbytes
;
4835 r
->nbytes_mapped
= map
;
4838 r
->next
= mmap_regions
;
4843 p
= MMAP_USER_AREA (p
);
4850 /* Free a block of relocatable storage whose data is pointed to by
4851 PTR. Store 0 in *PTR to show there's no block allocated. */
4854 mmap_free (void **var
)
4860 mmap_free_1 (MMAP_REGION (*var
));
4866 /* Given a pointer at address VAR to data allocated with mmap_alloc,
4867 resize it to size NBYTES. Change *VAR to reflect the new block,
4868 and return this value. If more memory cannot be allocated, then
4869 leave *VAR unchanged, and return null. */
4872 mmap_realloc (void **var
, size_t nbytes
)
4879 result
= mmap_alloc (var
, nbytes
);
4880 else if (nbytes
== 0)
4883 result
= mmap_alloc (var
, nbytes
);
4887 struct mmap_region
*r
= MMAP_REGION (*var
);
4888 size_t room
= r
->nbytes_mapped
- MMAP_REGION_STRUCT_SIZE
;
4893 void *old_ptr
= *var
;
4895 /* Try to map additional pages at the end of the region.
4896 If that fails, allocate a new region, copy data
4897 from the old region, then free it. */
4898 if (mmap_enlarge (r
, (ROUND (nbytes
- room
, mmap_page_size
)
4901 r
->nbytes_specified
= nbytes
;
4902 *var
= result
= old_ptr
;
4904 else if (mmap_alloc (var
, nbytes
))
4906 memcpy (*var
, old_ptr
, r
->nbytes_specified
);
4907 mmap_free_1 (MMAP_REGION (old_ptr
));
4909 r
= MMAP_REGION (result
);
4910 r
->nbytes_specified
= nbytes
;
4918 else if (room
- nbytes
>= mmap_page_size
)
4920 /* Shrinking by at least a page. Let's give some
4921 memory back to the system.
4923 The extra parens are to make the division happens first,
4924 on positive values, so we know it will round towards
4926 mmap_enlarge (r
, - ((room
- nbytes
) / mmap_page_size
));
4928 r
->nbytes_specified
= nbytes
;
4932 /* Leave it alone. */
4934 r
->nbytes_specified
= nbytes
;
4942 #endif /* USE_MMAP_FOR_BUFFERS */
4946 /***********************************************************************
4947 Buffer-text Allocation
4948 ***********************************************************************/
4950 /* Allocate NBYTES bytes for buffer B's text buffer. */
4953 alloc_buffer_text (struct buffer
*b
, ptrdiff_t nbytes
)
4958 #if defined USE_MMAP_FOR_BUFFERS
4959 p
= mmap_alloc ((void **) &b
->text
->beg
, nbytes
);
4960 #elif defined REL_ALLOC
4961 p
= r_alloc ((void **) &b
->text
->beg
, nbytes
);
4963 p
= xmalloc (nbytes
);
4969 memory_full (nbytes
);
4976 /* Enlarge buffer B's text buffer by DELTA bytes. DELTA < 0 means
4980 enlarge_buffer_text (struct buffer
*b
, ptrdiff_t delta
)
4983 ptrdiff_t nbytes
= (BUF_Z_BYTE (b
) - BUF_BEG_BYTE (b
) + BUF_GAP_SIZE (b
) + 1
4986 #if defined USE_MMAP_FOR_BUFFERS
4987 p
= mmap_realloc ((void **) &b
->text
->beg
, nbytes
);
4988 #elif defined REL_ALLOC
4989 p
= r_re_alloc ((void **) &b
->text
->beg
, nbytes
);
4991 p
= xrealloc (b
->text
->beg
, nbytes
);
4997 memory_full (nbytes
);
5000 BUF_BEG_ADDR (b
) = p
;
5005 /* Free buffer B's text buffer. */
5008 free_buffer_text (struct buffer
*b
)
5012 #if defined USE_MMAP_FOR_BUFFERS
5013 mmap_free ((void **) &b
->text
->beg
);
5014 #elif defined REL_ALLOC
5015 r_alloc_free ((void **) &b
->text
->beg
);
5017 xfree (b
->text
->beg
);
5020 BUF_BEG_ADDR (b
) = NULL
;
5026 /***********************************************************************
5028 ***********************************************************************/
5031 init_buffer_once (void)
5035 memset (buffer_permanent_local_flags
, 0, sizeof buffer_permanent_local_flags
);
5037 /* 0 means not a lisp var, -1 means always local, else mask. */
5038 memset (&buffer_local_flags
, 0, sizeof buffer_local_flags
);
5039 bset_filename (&buffer_local_flags
, make_number (-1));
5040 bset_directory (&buffer_local_flags
, make_number (-1));
5041 bset_backed_up (&buffer_local_flags
, make_number (-1));
5042 bset_save_length (&buffer_local_flags
, make_number (-1));
5043 bset_auto_save_file_name (&buffer_local_flags
, make_number (-1));
5044 bset_read_only (&buffer_local_flags
, make_number (-1));
5045 bset_major_mode (&buffer_local_flags
, make_number (-1));
5046 bset_mode_name (&buffer_local_flags
, make_number (-1));
5047 bset_undo_list (&buffer_local_flags
, make_number (-1));
5048 bset_mark_active (&buffer_local_flags
, make_number (-1));
5049 bset_point_before_scroll (&buffer_local_flags
, make_number (-1));
5050 bset_file_truename (&buffer_local_flags
, make_number (-1));
5051 bset_invisibility_spec (&buffer_local_flags
, make_number (-1));
5052 bset_file_format (&buffer_local_flags
, make_number (-1));
5053 bset_auto_save_file_format (&buffer_local_flags
, make_number (-1));
5054 bset_display_count (&buffer_local_flags
, make_number (-1));
5055 bset_display_time (&buffer_local_flags
, make_number (-1));
5056 bset_enable_multibyte_characters (&buffer_local_flags
, make_number (-1));
5058 /* These used to be stuck at 0 by default, but now that the all-zero value
5059 means Qnil, we have to initialize them explicitly. */
5060 bset_name (&buffer_local_flags
, make_number (0));
5061 bset_mark (&buffer_local_flags
, make_number (0));
5062 bset_local_var_alist (&buffer_local_flags
, make_number (0));
5063 bset_keymap (&buffer_local_flags
, make_number (0));
5064 bset_downcase_table (&buffer_local_flags
, make_number (0));
5065 bset_upcase_table (&buffer_local_flags
, make_number (0));
5066 bset_case_canon_table (&buffer_local_flags
, make_number (0));
5067 bset_case_eqv_table (&buffer_local_flags
, make_number (0));
5068 bset_minor_modes (&buffer_local_flags
, make_number (0));
5069 bset_width_table (&buffer_local_flags
, make_number (0));
5070 bset_pt_marker (&buffer_local_flags
, make_number (0));
5071 bset_begv_marker (&buffer_local_flags
, make_number (0));
5072 bset_zv_marker (&buffer_local_flags
, make_number (0));
5073 bset_last_selected_window (&buffer_local_flags
, make_number (0));
5076 XSETFASTINT (BVAR (&buffer_local_flags
, mode_line_format
), idx
); ++idx
;
5077 XSETFASTINT (BVAR (&buffer_local_flags
, abbrev_mode
), idx
); ++idx
;
5078 XSETFASTINT (BVAR (&buffer_local_flags
, overwrite_mode
), idx
); ++idx
;
5079 XSETFASTINT (BVAR (&buffer_local_flags
, case_fold_search
), idx
); ++idx
;
5080 XSETFASTINT (BVAR (&buffer_local_flags
, auto_fill_function
), idx
); ++idx
;
5081 XSETFASTINT (BVAR (&buffer_local_flags
, selective_display
), idx
); ++idx
;
5082 XSETFASTINT (BVAR (&buffer_local_flags
, selective_display_ellipses
), idx
); ++idx
;
5083 XSETFASTINT (BVAR (&buffer_local_flags
, tab_width
), idx
); ++idx
;
5084 XSETFASTINT (BVAR (&buffer_local_flags
, truncate_lines
), idx
); ++idx
;
5085 XSETFASTINT (BVAR (&buffer_local_flags
, word_wrap
), idx
); ++idx
;
5086 XSETFASTINT (BVAR (&buffer_local_flags
, ctl_arrow
), idx
); ++idx
;
5087 XSETFASTINT (BVAR (&buffer_local_flags
, fill_column
), idx
); ++idx
;
5088 XSETFASTINT (BVAR (&buffer_local_flags
, left_margin
), idx
); ++idx
;
5089 XSETFASTINT (BVAR (&buffer_local_flags
, abbrev_table
), idx
); ++idx
;
5090 XSETFASTINT (BVAR (&buffer_local_flags
, display_table
), idx
); ++idx
;
5091 XSETFASTINT (BVAR (&buffer_local_flags
, syntax_table
), idx
); ++idx
;
5092 XSETFASTINT (BVAR (&buffer_local_flags
, cache_long_scans
), idx
); ++idx
;
5093 XSETFASTINT (BVAR (&buffer_local_flags
, category_table
), idx
); ++idx
;
5094 XSETFASTINT (BVAR (&buffer_local_flags
, bidi_display_reordering
), idx
); ++idx
;
5095 XSETFASTINT (BVAR (&buffer_local_flags
, bidi_paragraph_direction
), idx
); ++idx
;
5096 XSETFASTINT (BVAR (&buffer_local_flags
, buffer_file_coding_system
), idx
);
5097 /* Make this one a permanent local. */
5098 buffer_permanent_local_flags
[idx
++] = 1;
5099 XSETFASTINT (BVAR (&buffer_local_flags
, left_margin_cols
), idx
); ++idx
;
5100 XSETFASTINT (BVAR (&buffer_local_flags
, right_margin_cols
), idx
); ++idx
;
5101 XSETFASTINT (BVAR (&buffer_local_flags
, left_fringe_width
), idx
); ++idx
;
5102 XSETFASTINT (BVAR (&buffer_local_flags
, right_fringe_width
), idx
); ++idx
;
5103 XSETFASTINT (BVAR (&buffer_local_flags
, fringes_outside_margins
), idx
); ++idx
;
5104 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_bar_width
), idx
); ++idx
;
5105 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_bar_height
), idx
); ++idx
;
5106 XSETFASTINT (BVAR (&buffer_local_flags
, vertical_scroll_bar_type
), idx
); ++idx
;
5107 XSETFASTINT (BVAR (&buffer_local_flags
, horizontal_scroll_bar_type
), idx
); ++idx
;
5108 XSETFASTINT (BVAR (&buffer_local_flags
, indicate_empty_lines
), idx
); ++idx
;
5109 XSETFASTINT (BVAR (&buffer_local_flags
, indicate_buffer_boundaries
), idx
); ++idx
;
5110 XSETFASTINT (BVAR (&buffer_local_flags
, fringe_indicator_alist
), idx
); ++idx
;
5111 XSETFASTINT (BVAR (&buffer_local_flags
, fringe_cursor_alist
), idx
); ++idx
;
5112 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_up_aggressively
), idx
); ++idx
;
5113 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_down_aggressively
), idx
); ++idx
;
5114 XSETFASTINT (BVAR (&buffer_local_flags
, header_line_format
), idx
); ++idx
;
5115 XSETFASTINT (BVAR (&buffer_local_flags
, cursor_type
), idx
); ++idx
;
5116 XSETFASTINT (BVAR (&buffer_local_flags
, extra_line_spacing
), idx
); ++idx
;
5117 XSETFASTINT (BVAR (&buffer_local_flags
, cursor_in_non_selected_windows
), idx
); ++idx
;
5119 /* Need more room? */
5120 if (idx
>= MAX_PER_BUFFER_VARS
)
5122 last_per_buffer_idx
= idx
;
5124 /* Make sure all markable slots in buffer_defaults
5125 are initialized reasonably, so mark_buffer won't choke. */
5126 reset_buffer (&buffer_defaults
);
5127 eassert (NILP (BVAR (&buffer_defaults
, name
)));
5128 reset_buffer_local_variables (&buffer_defaults
, 1);
5129 eassert (NILP (BVAR (&buffer_local_symbols
, name
)));
5130 reset_buffer (&buffer_local_symbols
);
5131 reset_buffer_local_variables (&buffer_local_symbols
, 1);
5132 /* Prevent GC from getting confused. */
5133 buffer_defaults
.text
= &buffer_defaults
.own_text
;
5134 buffer_local_symbols
.text
= &buffer_local_symbols
.own_text
;
5135 /* No one will share the text with these buffers, but let's play it safe. */
5136 buffer_defaults
.indirections
= 0;
5137 buffer_local_symbols
.indirections
= 0;
5138 /* Likewise no one will display them. */
5139 buffer_defaults
.window_count
= 0;
5140 buffer_local_symbols
.window_count
= 0;
5141 set_buffer_intervals (&buffer_defaults
, NULL
);
5142 set_buffer_intervals (&buffer_local_symbols
, NULL
);
5143 /* This is not strictly necessary, but let's make them initialized. */
5144 bset_name (&buffer_defaults
, build_pure_c_string (" *buffer-defaults*"));
5145 bset_name (&buffer_local_symbols
, build_pure_c_string (" *buffer-local-symbols*"));
5146 BUFFER_PVEC_INIT (&buffer_defaults
);
5147 BUFFER_PVEC_INIT (&buffer_local_symbols
);
5149 /* Set up the default values of various buffer slots. */
5150 /* Must do these before making the first buffer! */
5152 /* real setup is done in bindings.el */
5153 bset_mode_line_format (&buffer_defaults
, build_pure_c_string ("%-"));
5154 bset_header_line_format (&buffer_defaults
, Qnil
);
5155 bset_abbrev_mode (&buffer_defaults
, Qnil
);
5156 bset_overwrite_mode (&buffer_defaults
, Qnil
);
5157 bset_case_fold_search (&buffer_defaults
, Qt
);
5158 bset_auto_fill_function (&buffer_defaults
, Qnil
);
5159 bset_selective_display (&buffer_defaults
, Qnil
);
5160 bset_selective_display_ellipses (&buffer_defaults
, Qt
);
5161 bset_abbrev_table (&buffer_defaults
, Qnil
);
5162 bset_display_table (&buffer_defaults
, Qnil
);
5163 bset_undo_list (&buffer_defaults
, Qnil
);
5164 bset_mark_active (&buffer_defaults
, Qnil
);
5165 bset_file_format (&buffer_defaults
, Qnil
);
5166 bset_auto_save_file_format (&buffer_defaults
, Qt
);
5167 set_buffer_overlays_before (&buffer_defaults
, NULL
);
5168 set_buffer_overlays_after (&buffer_defaults
, NULL
);
5169 buffer_defaults
.overlay_center
= BEG
;
5171 XSETFASTINT (BVAR (&buffer_defaults
, tab_width
), 8);
5172 bset_truncate_lines (&buffer_defaults
, Qnil
);
5173 bset_word_wrap (&buffer_defaults
, Qnil
);
5174 bset_ctl_arrow (&buffer_defaults
, Qt
);
5175 bset_bidi_display_reordering (&buffer_defaults
, Qt
);
5176 bset_bidi_paragraph_direction (&buffer_defaults
, Qnil
);
5177 bset_cursor_type (&buffer_defaults
, Qt
);
5178 bset_extra_line_spacing (&buffer_defaults
, Qnil
);
5179 bset_cursor_in_non_selected_windows (&buffer_defaults
, Qt
);
5181 bset_enable_multibyte_characters (&buffer_defaults
, Qt
);
5182 bset_buffer_file_coding_system (&buffer_defaults
, Qnil
);
5183 XSETFASTINT (BVAR (&buffer_defaults
, fill_column
), 70);
5184 XSETFASTINT (BVAR (&buffer_defaults
, left_margin
), 0);
5185 bset_cache_long_scans (&buffer_defaults
, Qt
);
5186 bset_file_truename (&buffer_defaults
, Qnil
);
5187 XSETFASTINT (BVAR (&buffer_defaults
, display_count
), 0);
5188 XSETFASTINT (BVAR (&buffer_defaults
, left_margin_cols
), 0);
5189 XSETFASTINT (BVAR (&buffer_defaults
, right_margin_cols
), 0);
5190 bset_left_fringe_width (&buffer_defaults
, Qnil
);
5191 bset_right_fringe_width (&buffer_defaults
, Qnil
);
5192 bset_fringes_outside_margins (&buffer_defaults
, Qnil
);
5193 bset_scroll_bar_width (&buffer_defaults
, Qnil
);
5194 bset_scroll_bar_height (&buffer_defaults
, Qnil
);
5195 bset_vertical_scroll_bar_type (&buffer_defaults
, Qt
);
5196 bset_horizontal_scroll_bar_type (&buffer_defaults
, Qt
);
5197 bset_indicate_empty_lines (&buffer_defaults
, Qnil
);
5198 bset_indicate_buffer_boundaries (&buffer_defaults
, Qnil
);
5199 bset_fringe_indicator_alist (&buffer_defaults
, Qnil
);
5200 bset_fringe_cursor_alist (&buffer_defaults
, Qnil
);
5201 bset_scroll_up_aggressively (&buffer_defaults
, Qnil
);
5202 bset_scroll_down_aggressively (&buffer_defaults
, Qnil
);
5203 bset_display_time (&buffer_defaults
, Qnil
);
5205 /* Assign the local-flags to the slots that have default values.
5206 The local flag is a bit that is used in the buffer
5207 to say that it has its own local value for the slot.
5208 The local flag bits are in the local_var_flags slot of the buffer. */
5210 /* Nothing can work if this isn't true. */
5211 { verify (sizeof (EMACS_INT
) == word_size
); }
5213 Vbuffer_alist
= Qnil
;
5217 QSFundamental
= build_pure_c_string ("Fundamental");
5219 DEFSYM (Qfundamental_mode
, "fundamental-mode");
5220 bset_major_mode (&buffer_defaults
, Qfundamental_mode
);
5222 DEFSYM (Qmode_class
, "mode-class");
5223 DEFSYM (Qprotected_field
, "protected-field");
5225 DEFSYM (Qpermanent_local
, "permanent-local");
5226 DEFSYM (Qkill_buffer_hook
, "kill-buffer-hook");
5227 Fput (Qkill_buffer_hook
, Qpermanent_local
, Qt
);
5229 /* Super-magic invisible buffer. */
5230 Vprin1_to_string_buffer
= Fget_buffer_create (build_pure_c_string (" prin1"));
5231 Vbuffer_alist
= Qnil
;
5233 Fset_buffer (Fget_buffer_create (build_pure_c_string ("*scratch*")));
5235 inhibit_modification_hooks
= 0;
5239 init_buffer (int initialized
)
5245 #ifdef USE_MMAP_FOR_BUFFERS
5251 /* These must be reset in the dumped Emacs, to avoid stale
5252 references to mmap'ed memory from before the dump.
5254 WINDOWSNT doesn't need this because it doesn't track mmap'ed
5255 regions by hand (see w32heap.c, which uses system APIs for
5256 that purpose), and thus doesn't use mmap_regions. */
5257 mmap_regions
= NULL
;
5261 /* The dumped buffers reference addresses of buffer text
5262 recorded by temacs, that cannot be used by the dumped Emacs.
5263 We map new memory for their text here.
5265 Implementation note: the buffers we carry from temacs are:
5266 " prin1", "*scratch*", " *Minibuf-0*", "*Messages*", and
5267 " *code-conversion-work*". They are created by
5268 init_buffer_once and init_window_once (which are not called
5269 in the dumped Emacs), and by the first call to coding.c routines. */
5272 b
->text
->beg
= NULL
;
5273 enlarge_buffer_text (b
, 0);
5280 /* Only buffers with allocated buffer text should be present at
5281 this point in temacs. */
5284 eassert (b
->text
->beg
!= NULL
);
5287 #else /* not USE_MMAP_FOR_BUFFERS */
5288 /* Avoid compiler warnings. */
5290 #endif /* USE_MMAP_FOR_BUFFERS */
5292 AUTO_STRING (scratch
, "*scratch*");
5293 Fset_buffer (Fget_buffer_create (scratch
));
5294 if (NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
)))
5295 Fset_buffer_multibyte (Qnil
);
5297 pwd
= get_current_dir_name ();
5301 fprintf (stderr
, "Error getting directory: %s\n",
5302 emacs_strerror (errno
));
5303 bset_directory (current_buffer
, Qnil
);
5307 /* Maybe this should really use some standard subroutine
5308 whose definition is filename syntax dependent. */
5310 if (!(IS_DIRECTORY_SEP (pwd
[len
- 1])))
5312 /* Grow buffer to add directory separator and '\0'. */
5313 pwd
= realloc (pwd
, len
+ 2);
5315 fatal ("get_current_dir_name: %s\n", strerror (errno
));
5316 pwd
[len
] = DIRECTORY_SEP
;
5317 pwd
[len
+ 1] = '\0';
5321 /* At this moment, we still don't know how to decode the directory
5322 name. So, we keep the bytes in unibyte form so that file I/O
5323 routines correctly get the original bytes. */
5324 bset_directory (current_buffer
, make_unibyte_string (pwd
, len
));
5326 /* Add /: to the front of the name
5327 if it would otherwise be treated as magic. */
5328 temp
= Ffind_file_name_handler (BVAR (current_buffer
, directory
), Qt
);
5330 /* If the default dir is just /, TEMP is non-nil
5331 because of the ange-ftp completion handler.
5332 However, it is not necessary to turn / into /:/.
5333 So avoid doing that. */
5334 && strcmp ("/", SSDATA (BVAR (current_buffer
, directory
))))
5336 AUTO_STRING (slash_colon
, "/:");
5337 bset_directory (current_buffer
,
5338 concat2 (slash_colon
,
5339 BVAR (current_buffer
, directory
)));
5343 temp
= get_minibuffer (0);
5344 bset_directory (XBUFFER (temp
), BVAR (current_buffer
, directory
));
5349 /* Similar to defvar_lisp but define a variable whose value is the
5350 Lisp_Object stored in the current buffer. LNAME is the Lisp-level
5351 variable name. VNAME is the name of the buffer slot. PREDICATE
5352 is nil for a general Lisp variable. If PREDICATE is non-nil, then
5353 only Lisp values that satisfies the PREDICATE are allowed (except
5354 that nil is allowed too). DOC is a dummy where you write the doc
5355 string as a comment. */
5357 #define DEFVAR_PER_BUFFER(lname, vname, predicate, doc) \
5359 static struct Lisp_Buffer_Objfwd bo_fwd; \
5360 defvar_per_buffer (&bo_fwd, lname, vname, predicate); \
5364 defvar_per_buffer (struct Lisp_Buffer_Objfwd
*bo_fwd
, const char *namestring
,
5365 Lisp_Object
*address
, Lisp_Object predicate
)
5367 struct Lisp_Symbol
*sym
;
5370 sym
= XSYMBOL (intern (namestring
));
5371 offset
= (char *)address
- (char *)current_buffer
;
5373 bo_fwd
->type
= Lisp_Fwd_Buffer_Obj
;
5374 bo_fwd
->offset
= offset
;
5375 bo_fwd
->predicate
= predicate
;
5376 sym
->declared_special
= 1;
5377 sym
->redirect
= SYMBOL_FORWARDED
;
5378 SET_SYMBOL_FWD (sym
, (union Lisp_Fwd
*) bo_fwd
);
5379 XSETSYMBOL (PER_BUFFER_SYMBOL (offset
), sym
);
5381 if (PER_BUFFER_IDX (offset
) == 0)
5382 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
5383 slot of buffer_local_flags. */
5388 /* Initialize the buffer routines. */
5390 syms_of_buffer (void)
5392 staticpro (&last_overlay_modification_hooks
);
5393 last_overlay_modification_hooks
5394 = Fmake_vector (make_number (10), Qnil
);
5396 staticpro (&QSFundamental
);
5397 staticpro (&Vbuffer_alist
);
5399 DEFSYM (Qchoice
, "choice");
5400 DEFSYM (Qleft
, "left");
5401 DEFSYM (Qright
, "right");
5402 DEFSYM (Qrange
, "range");
5404 DEFSYM (Qpermanent_local_hook
, "permanent-local-hook");
5405 DEFSYM (Qoverlayp
, "overlayp");
5406 DEFSYM (Qevaporate
, "evaporate");
5407 DEFSYM (Qmodification_hooks
, "modification-hooks");
5408 DEFSYM (Qinsert_in_front_hooks
, "insert-in-front-hooks");
5409 DEFSYM (Qinsert_behind_hooks
, "insert-behind-hooks");
5410 DEFSYM (Qget_file_buffer
, "get-file-buffer");
5411 DEFSYM (Qpriority
, "priority");
5412 DEFSYM (Qbefore_string
, "before-string");
5413 DEFSYM (Qafter_string
, "after-string");
5414 DEFSYM (Qfirst_change_hook
, "first-change-hook");
5415 DEFSYM (Qbefore_change_functions
, "before-change-functions");
5416 DEFSYM (Qafter_change_functions
, "after-change-functions");
5417 DEFSYM (Qkill_buffer_query_functions
, "kill-buffer-query-functions");
5419 DEFSYM (Qvertical_scroll_bar
, "vertical-scroll-bar");
5420 Fput (Qvertical_scroll_bar
, Qchoice
, list4 (Qnil
, Qt
, Qleft
, Qright
));
5421 DEFSYM (Qhorizontal_scroll_bar
, "horizontal-scroll-bar");
5423 DEFSYM (Qfraction
, "fraction");
5424 Fput (Qfraction
, Qrange
, Fcons (make_float (0.0), make_float (1.0)));
5426 DEFSYM (Qoverwrite_mode
, "overwrite-mode");
5427 Fput (Qoverwrite_mode
, Qchoice
,
5428 list3 (Qnil
, intern ("overwrite-mode-textual"),
5429 Qoverwrite_mode_binary
));
5431 Fput (Qprotected_field
, Qerror_conditions
,
5432 listn (CONSTYPE_PURE
, 2, Qprotected_field
, Qerror
));
5433 Fput (Qprotected_field
, Qerror_message
,
5434 build_pure_c_string ("Attempt to modify a protected field"));
5436 DEFVAR_BUFFER_DEFAULTS ("default-mode-line-format",
5438 doc
: /* Default value of `mode-line-format' for buffers that don't override it.
5439 This is the same as (default-value \\='mode-line-format). */);
5441 DEFVAR_BUFFER_DEFAULTS ("default-header-line-format",
5443 doc
: /* Default value of `header-line-format' for buffers that don't override it.
5444 This is the same as (default-value \\='header-line-format). */);
5446 DEFVAR_BUFFER_DEFAULTS ("default-cursor-type", cursor_type
,
5447 doc
: /* Default value of `cursor-type' for buffers that don't override it.
5448 This is the same as (default-value \\='cursor-type). */);
5450 DEFVAR_BUFFER_DEFAULTS ("default-line-spacing",
5452 doc
: /* Default value of `line-spacing' for buffers that don't override it.
5453 This is the same as (default-value \\='line-spacing). */);
5455 DEFVAR_BUFFER_DEFAULTS ("default-cursor-in-non-selected-windows",
5456 cursor_in_non_selected_windows
,
5457 doc
: /* Default value of `cursor-in-non-selected-windows'.
5458 This is the same as (default-value \\='cursor-in-non-selected-windows). */);
5460 DEFVAR_BUFFER_DEFAULTS ("default-abbrev-mode",
5462 doc
: /* Default value of `abbrev-mode' for buffers that do not override it.
5463 This is the same as (default-value \\='abbrev-mode). */);
5465 DEFVAR_BUFFER_DEFAULTS ("default-ctl-arrow",
5467 doc
: /* Default value of `ctl-arrow' for buffers that do not override it.
5468 This is the same as (default-value \\='ctl-arrow). */);
5470 DEFVAR_BUFFER_DEFAULTS ("default-enable-multibyte-characters",
5471 enable_multibyte_characters
,
5472 doc
: /* Default value of `enable-multibyte-characters' for buffers not overriding it.
5473 This is the same as (default-value \\='enable-multibyte-characters). */);
5475 DEFVAR_BUFFER_DEFAULTS ("default-buffer-file-coding-system",
5476 buffer_file_coding_system
,
5477 doc
: /* Default value of `buffer-file-coding-system' for buffers not overriding it.
5478 This is the same as (default-value \\='buffer-file-coding-system). */);
5480 DEFVAR_BUFFER_DEFAULTS ("default-truncate-lines",
5482 doc
: /* Default value of `truncate-lines' for buffers that do not override it.
5483 This is the same as (default-value \\='truncate-lines). */);
5485 DEFVAR_BUFFER_DEFAULTS ("default-fill-column",
5487 doc
: /* Default value of `fill-column' for buffers that do not override it.
5488 This is the same as (default-value \\='fill-column). */);
5490 DEFVAR_BUFFER_DEFAULTS ("default-left-margin",
5492 doc
: /* Default value of `left-margin' for buffers that do not override it.
5493 This is the same as (default-value \\='left-margin). */);
5495 DEFVAR_BUFFER_DEFAULTS ("default-tab-width",
5497 doc
: /* Default value of `tab-width' for buffers that do not override it.
5498 NOTE: This controls the display width of a TAB character, and not
5499 the size of an indentation step.
5500 This is the same as (default-value \\='tab-width). */);
5502 DEFVAR_BUFFER_DEFAULTS ("default-case-fold-search",
5504 doc
: /* Default value of `case-fold-search' for buffers that don't override it.
5505 This is the same as (default-value \\='case-fold-search). */);
5507 DEFVAR_BUFFER_DEFAULTS ("default-left-margin-width",
5509 doc
: /* Default value of `left-margin-width' for buffers that don't override it.
5510 This is the same as (default-value \\='left-margin-width). */);
5512 DEFVAR_BUFFER_DEFAULTS ("default-right-margin-width",
5514 doc
: /* Default value of `right-margin-width' for buffers that don't override it.
5515 This is the same as (default-value \\='right-margin-width). */);
5517 DEFVAR_BUFFER_DEFAULTS ("default-left-fringe-width",
5519 doc
: /* Default value of `left-fringe-width' for buffers that don't override it.
5520 This is the same as (default-value \\='left-fringe-width). */);
5522 DEFVAR_BUFFER_DEFAULTS ("default-right-fringe-width",
5524 doc
: /* Default value of `right-fringe-width' for buffers that don't override it.
5525 This is the same as (default-value \\='right-fringe-width). */);
5527 DEFVAR_BUFFER_DEFAULTS ("default-fringes-outside-margins",
5528 fringes_outside_margins
,
5529 doc
: /* Default value of `fringes-outside-margins' for buffers that don't override it.
5530 This is the same as (default-value \\='fringes-outside-margins). */);
5532 DEFVAR_BUFFER_DEFAULTS ("default-scroll-bar-width",
5534 doc
: /* Default value of `scroll-bar-width' for buffers that don't override it.
5535 This is the same as (default-value \\='scroll-bar-width). */);
5537 DEFVAR_BUFFER_DEFAULTS ("default-vertical-scroll-bar",
5538 vertical_scroll_bar_type
,
5539 doc
: /* Default value of `vertical-scroll-bar' for buffers that don't override it.
5540 This is the same as (default-value \\='vertical-scroll-bar). */);
5542 DEFVAR_BUFFER_DEFAULTS ("default-indicate-empty-lines",
5543 indicate_empty_lines
,
5544 doc
: /* Default value of `indicate-empty-lines' for buffers that don't override it.
5545 This is the same as (default-value \\='indicate-empty-lines). */);
5547 DEFVAR_BUFFER_DEFAULTS ("default-indicate-buffer-boundaries",
5548 indicate_buffer_boundaries
,
5549 doc
: /* Default value of `indicate-buffer-boundaries' for buffers that don't override it.
5550 This is the same as (default-value \\='indicate-buffer-boundaries). */);
5552 DEFVAR_BUFFER_DEFAULTS ("default-fringe-indicator-alist",
5553 fringe_indicator_alist
,
5554 doc
: /* Default value of `fringe-indicator-alist' for buffers that don't override it.
5555 This is the same as (default-value \\='fringe-indicator-alist). */);
5557 DEFVAR_BUFFER_DEFAULTS ("default-fringe-cursor-alist",
5558 fringe_cursor_alist
,
5559 doc
: /* Default value of `fringe-cursor-alist' for buffers that don't override it.
5560 This is the same as (default-value \\='fringe-cursor-alist). */);
5562 DEFVAR_BUFFER_DEFAULTS ("default-scroll-up-aggressively",
5563 scroll_up_aggressively
,
5564 doc
: /* Default value of `scroll-up-aggressively'.
5565 This value applies in buffers that don't have their own local values.
5566 This is the same as (default-value \\='scroll-up-aggressively). */);
5568 DEFVAR_BUFFER_DEFAULTS ("default-scroll-down-aggressively",
5569 scroll_down_aggressively
,
5570 doc
: /* Default value of `scroll-down-aggressively'.
5571 This value applies in buffers that don't have their own local values.
5572 This is the same as (default-value \\='scroll-down-aggressively). */);
5574 DEFVAR_PER_BUFFER ("header-line-format",
5575 &BVAR (current_buffer
, header_line_format
),
5577 doc
: /* Analogous to `mode-line-format', but controls the header line.
5578 The header line appears, optionally, at the top of a window;
5579 the mode line appears at the bottom. */);
5581 DEFVAR_PER_BUFFER ("mode-line-format", &BVAR (current_buffer
, mode_line_format
),
5583 doc
: /* Template for displaying mode line for current buffer.
5585 The value may be nil, a string, a symbol or a list.
5587 A value of nil means don't display a mode line.
5589 For any symbol other than t or nil, the symbol's value is processed as
5590 a mode line construct. As a special exception, if that value is a
5591 string, the string is processed verbatim, without handling any
5592 %-constructs (see below). Also, unless the symbol has a non-nil
5593 `risky-local-variable' property, all properties in any strings, as
5594 well as all :eval and :propertize forms in the value, are ignored.
5596 A list whose car is a string or list is processed by processing each
5597 of the list elements recursively, as separate mode line constructs,
5598 and concatenating the results.
5600 A list of the form `(:eval FORM)' is processed by evaluating FORM and
5601 using the result as a mode line construct. Be careful--FORM should
5602 not load any files, because that can cause an infinite recursion.
5604 A list of the form `(:propertize ELT PROPS...)' is processed by
5605 processing ELT as the mode line construct, and adding the text
5606 properties PROPS to the result.
5608 A list whose car is a symbol is processed by examining the symbol's
5609 value, and, if that value is non-nil, processing the cadr of the list
5610 recursively; and if that value is nil, processing the caddr of the
5613 A list whose car is an integer is processed by processing the cadr of
5614 the list, and padding (if the number is positive) or truncating (if
5615 negative) to the width specified by that number.
5617 A string is printed verbatim in the mode line except for %-constructs:
5618 %b -- print buffer name. %f -- print visited file name.
5619 %F -- print frame name.
5620 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
5621 %& is like %*, but ignore read-only-ness.
5622 % means buffer is read-only and * means it is modified.
5623 For a modified read-only buffer, %* gives % and %+ gives *.
5624 %s -- print process status. %l -- print the current line number.
5625 %c -- print the current column number (this makes editing slower).
5626 To make the column number update correctly in all cases,
5627 `column-number-mode' must be non-nil.
5628 %i -- print the size of the buffer.
5629 %I -- like %i, but use k, M, G, etc., to abbreviate.
5630 %p -- print percent of buffer above top of window, or Top, Bot or All.
5631 %P -- print percent of buffer above bottom of window, perhaps plus Top,
5632 or print Bottom or All.
5633 %n -- print Narrow if appropriate.
5634 %t -- visited file is text or binary (if OS supports this distinction).
5635 %z -- print mnemonics of keyboard, terminal, and buffer coding systems.
5636 %Z -- like %z, but including the end-of-line format.
5637 %e -- print error message about full memory.
5638 %@ -- print @ or hyphen. @ means that default-directory is on a
5640 %[ -- print one [ for each recursive editing level. %] similar.
5641 %% -- print %. %- -- print infinitely many dashes.
5642 Decimal digits after the % specify field width to which to pad. */);
5644 DEFVAR_BUFFER_DEFAULTS ("default-major-mode", major_mode
,
5645 doc
: /* Value of `major-mode' for new buffers. */);
5647 DEFVAR_PER_BUFFER ("major-mode", &BVAR (current_buffer
, major_mode
),
5649 doc
: /* Symbol for current buffer's major mode.
5650 The default value (normally `fundamental-mode') affects new buffers.
5651 A value of nil means to use the current buffer's major mode, provided
5652 it is not marked as "special".
5654 When a mode is used by default, `find-file' switches to it before it
5655 reads the contents into the buffer and before it finishes setting up
5656 the buffer. Thus, the mode and its hooks should not expect certain
5657 variables such as `buffer-read-only' and `buffer-file-coding-system'
5660 DEFVAR_PER_BUFFER ("mode-name", &BVAR (current_buffer
, mode_name
),
5662 doc
: /* Pretty name of current buffer's major mode.
5663 Usually a string, but can use any of the constructs for `mode-line-format',
5665 Format with `format-mode-line' to produce a string value. */);
5667 DEFVAR_PER_BUFFER ("local-abbrev-table", &BVAR (current_buffer
, abbrev_table
), Qnil
,
5668 doc
: /* Local (mode-specific) abbrev table of current buffer. */);
5670 DEFVAR_PER_BUFFER ("abbrev-mode", &BVAR (current_buffer
, abbrev_mode
), Qnil
,
5671 doc
: /* Non-nil if Abbrev mode is enabled.
5672 Use the command `abbrev-mode' to change this variable. */);
5674 DEFVAR_PER_BUFFER ("case-fold-search", &BVAR (current_buffer
, case_fold_search
),
5676 doc
: /* Non-nil if searches and matches should ignore case. */);
5678 DEFVAR_PER_BUFFER ("fill-column", &BVAR (current_buffer
, fill_column
),
5680 doc
: /* Column beyond which automatic line-wrapping should happen.
5681 Interactively, you can set the buffer local value using \\[set-fill-column]. */);
5683 DEFVAR_PER_BUFFER ("left-margin", &BVAR (current_buffer
, left_margin
),
5685 doc
: /* Column for the default `indent-line-function' to indent to.
5686 Linefeed indents to this column in Fundamental mode. */);
5688 DEFVAR_PER_BUFFER ("tab-width", &BVAR (current_buffer
, tab_width
),
5690 doc
: /* Distance between tab stops (for display of tab characters), in columns.
5691 NOTE: This controls the display width of a TAB character, and not
5692 the size of an indentation step.
5693 This should be an integer greater than zero. */);
5695 DEFVAR_PER_BUFFER ("ctl-arrow", &BVAR (current_buffer
, ctl_arrow
), Qnil
,
5696 doc
: /* Non-nil means display control chars with uparrow.
5697 A value of nil means use backslash and octal digits.
5698 This variable does not apply to characters whose display is specified
5699 in the current display table (if there is one). */);
5701 DEFVAR_PER_BUFFER ("enable-multibyte-characters",
5702 &BVAR (current_buffer
, enable_multibyte_characters
),
5704 doc
: /* Non-nil means the buffer contents are regarded as multi-byte characters.
5705 Otherwise they are regarded as unibyte. This affects the display,
5706 file I/O and the behavior of various editing commands.
5708 This variable is buffer-local but you cannot set it directly;
5709 use the function `set-buffer-multibyte' to change a buffer's representation.
5710 See also Info node `(elisp)Text Representations'. */);
5711 XSYMBOL (intern_c_string ("enable-multibyte-characters"))->constant
= 1;
5713 DEFVAR_PER_BUFFER ("buffer-file-coding-system",
5714 &BVAR (current_buffer
, buffer_file_coding_system
), Qnil
,
5715 doc
: /* Coding system to be used for encoding the buffer contents on saving.
5716 This variable applies to saving the buffer, and also to `write-region'
5717 and other functions that use `write-region'.
5718 It does not apply to sending output to subprocesses, however.
5720 If this is nil, the buffer is saved without any code conversion
5721 unless some coding system is specified in `file-coding-system-alist'
5722 for the buffer file.
5724 If the text to be saved cannot be encoded as specified by this variable,
5725 an alternative encoding is selected by `select-safe-coding-system', which see.
5727 The variable `coding-system-for-write', if non-nil, overrides this variable.
5729 This variable is never applied to a way of decoding a file while reading it. */);
5731 DEFVAR_PER_BUFFER ("bidi-display-reordering",
5732 &BVAR (current_buffer
, bidi_display_reordering
), Qnil
,
5733 doc
: /* Non-nil means reorder bidirectional text for display in the visual order. */);
5735 DEFVAR_PER_BUFFER ("bidi-paragraph-direction",
5736 &BVAR (current_buffer
, bidi_paragraph_direction
), Qnil
,
5737 doc
: /* If non-nil, forces directionality of text paragraphs in the buffer.
5739 If this is nil (the default), the direction of each paragraph is
5740 determined by the first strong directional character of its text.
5741 The values of `right-to-left' and `left-to-right' override that.
5742 Any other value is treated as nil.
5744 This variable has no effect unless the buffer's value of
5745 `bidi-display-reordering' is non-nil. */);
5747 DEFVAR_PER_BUFFER ("truncate-lines", &BVAR (current_buffer
, truncate_lines
), Qnil
,
5748 doc
: /* Non-nil means do not display continuation lines.
5749 Instead, give each line of text just one screen line.
5751 Note that this is overridden by the variable
5752 `truncate-partial-width-windows' if that variable is non-nil
5753 and this buffer is not full-frame width.
5755 Minibuffers set this variable to nil. */);
5757 DEFVAR_PER_BUFFER ("word-wrap", &BVAR (current_buffer
, word_wrap
), Qnil
,
5758 doc
: /* Non-nil means to use word-wrapping for continuation lines.
5759 When word-wrapping is on, continuation lines are wrapped at the space
5760 or tab character nearest to the right window edge.
5761 If nil, continuation lines are wrapped at the right screen edge.
5763 This variable has no effect if long lines are truncated (see
5764 `truncate-lines' and `truncate-partial-width-windows'). If you use
5765 word-wrapping, you might want to reduce the value of
5766 `truncate-partial-width-windows', since wrapping can make text readable
5767 in narrower windows.
5769 Instead of setting this variable directly, most users should use
5770 Visual Line mode . Visual Line mode, when enabled, sets `word-wrap'
5771 to t, and additionally redefines simple editing commands to act on
5772 visual lines rather than logical lines. See the documentation of
5773 `visual-line-mode'. */);
5775 DEFVAR_PER_BUFFER ("default-directory", &BVAR (current_buffer
, directory
),
5777 doc
: /* Name of default directory of current buffer. Should end with slash.
5778 To interactively change the default directory, use command `cd'. */);
5780 DEFVAR_PER_BUFFER ("auto-fill-function", &BVAR (current_buffer
, auto_fill_function
),
5782 doc
: /* Function called (if non-nil) to perform auto-fill.
5783 It is called after self-inserting any character specified in
5784 the `auto-fill-chars' table.
5785 NOTE: This variable is not a hook;
5786 its value may not be a list of functions. */);
5788 DEFVAR_PER_BUFFER ("buffer-file-name", &BVAR (current_buffer
, filename
),
5790 doc
: /* Name of file visited in current buffer, or nil if not visiting a file.
5791 This should be an absolute file name. */);
5793 DEFVAR_PER_BUFFER ("buffer-file-truename", &BVAR (current_buffer
, file_truename
),
5795 doc
: /* Abbreviated truename of file visited in current buffer, or nil if none.
5796 The truename of a file is calculated by `file-truename'
5797 and then abbreviated with `abbreviate-file-name'. */);
5799 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
5800 &BVAR (current_buffer
, auto_save_file_name
),
5802 doc
: /* Name of file for auto-saving current buffer.
5803 If it is nil, that means don't auto-save this buffer. */);
5805 DEFVAR_PER_BUFFER ("buffer-read-only", &BVAR (current_buffer
, read_only
), Qnil
,
5806 doc
: /* Non-nil if this buffer is read-only. */);
5808 DEFVAR_PER_BUFFER ("buffer-backed-up", &BVAR (current_buffer
, backed_up
), Qnil
,
5809 doc
: /* Non-nil if this buffer's file has been backed up.
5810 Backing up is done before the first time the file is saved. */);
5812 DEFVAR_PER_BUFFER ("buffer-saved-size", &BVAR (current_buffer
, save_length
),
5814 doc
: /* Length of current buffer when last read in, saved or auto-saved.
5816 -1 means auto-saving turned off until next real save.
5818 If you set this to -2, that means don't turn off auto-saving in this buffer
5819 if its text size shrinks. If you use `buffer-swap-text' on a buffer,
5820 you probably should set this to -2 in that buffer. */);
5822 DEFVAR_PER_BUFFER ("selective-display", &BVAR (current_buffer
, selective_display
),
5824 doc
: /* Non-nil enables selective display.
5825 An integer N as value means display only lines
5826 that start with less than N columns of space.
5827 A value of t means that the character ^M makes itself and
5828 all the rest of the line invisible; also, when saving the buffer
5829 in a file, save the ^M as a newline. */);
5831 DEFVAR_PER_BUFFER ("selective-display-ellipses",
5832 &BVAR (current_buffer
, selective_display_ellipses
),
5834 doc
: /* Non-nil means display ... on previous line when a line is invisible. */);
5836 DEFVAR_PER_BUFFER ("overwrite-mode", &BVAR (current_buffer
, overwrite_mode
),
5838 doc
: /* Non-nil if self-insertion should replace existing text.
5839 The value should be one of `overwrite-mode-textual',
5840 `overwrite-mode-binary', or nil.
5841 If it is `overwrite-mode-textual', self-insertion still
5842 inserts at the end of a line, and inserts when point is before a tab,
5843 until the tab is filled in.
5844 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too. */);
5846 DEFVAR_PER_BUFFER ("buffer-display-table", &BVAR (current_buffer
, display_table
),
5848 doc
: /* Display table that controls display of the contents of current buffer.
5850 If this variable is nil, the value of `standard-display-table' is used.
5851 Each window can have its own, overriding display table, see
5852 `set-window-display-table' and `window-display-table'.
5854 The display table is a char-table created with `make-display-table'.
5855 A char-table is an array indexed by character codes. Normal array
5856 primitives `aref' and `aset' can be used to access elements of a char-table.
5858 Each of the char-table elements control how to display the corresponding
5859 text character: the element at index C in the table says how to display
5860 the character whose code is C. Each element should be a vector of
5861 characters or nil. The value nil means display the character in the
5862 default fashion; otherwise, the characters from the vector are delivered
5863 to the screen instead of the original character.
5865 For example, (aset buffer-display-table ?X [?Y]) tells Emacs
5866 to display a capital Y instead of each X character.
5868 In addition, a char-table has six extra slots to control the display of:
5870 the end of a truncated screen line (extra-slot 0, a single character);
5871 the end of a continued line (extra-slot 1, a single character);
5872 the escape character used to display character codes in octal
5873 (extra-slot 2, a single character);
5874 the character used as an arrow for control characters (extra-slot 3,
5875 a single character);
5876 the decoration indicating the presence of invisible lines (extra-slot 4,
5877 a vector of characters);
5878 the character used to draw the border between side-by-side windows
5879 (extra-slot 5, a single character).
5881 See also the functions `display-table-slot' and `set-display-table-slot'. */);
5883 DEFVAR_PER_BUFFER ("left-margin-width", &BVAR (current_buffer
, left_margin_cols
),
5885 doc
: /* Width in columns of left marginal area for display of a buffer.
5886 A value of nil means no marginal area.
5888 Setting this variable does not take effect until a new buffer is displayed
5889 in a window. To make the change take effect, call `set-window-buffer'. */);
5891 DEFVAR_PER_BUFFER ("right-margin-width", &BVAR (current_buffer
, right_margin_cols
),
5893 doc
: /* Width in columns of right marginal area for display of a buffer.
5894 A value of nil means no marginal area.
5896 Setting this variable does not take effect until a new buffer is displayed
5897 in a window. To make the change take effect, call `set-window-buffer'. */);
5899 DEFVAR_PER_BUFFER ("left-fringe-width", &BVAR (current_buffer
, left_fringe_width
),
5901 doc
: /* Width of this buffer's left fringe (in pixels).
5902 A value of 0 means no left fringe is shown in this buffer's window.
5903 A value of nil means to use the left fringe width from the window's frame.
5905 Setting this variable does not take effect until a new buffer is displayed
5906 in a window. To make the change take effect, call `set-window-buffer'. */);
5908 DEFVAR_PER_BUFFER ("right-fringe-width", &BVAR (current_buffer
, right_fringe_width
),
5910 doc
: /* Width of this buffer's right fringe (in pixels).
5911 A value of 0 means no right fringe is shown in this buffer's window.
5912 A value of nil means to use the right fringe width from the window's frame.
5914 Setting this variable does not take effect until a new buffer is displayed
5915 in a window. To make the change take effect, call `set-window-buffer'. */);
5917 DEFVAR_PER_BUFFER ("fringes-outside-margins", &BVAR (current_buffer
, fringes_outside_margins
),
5919 doc
: /* Non-nil means to display fringes outside display margins.
5920 A value of nil means to display fringes between margins and buffer text.
5922 Setting this variable does not take effect until a new buffer is displayed
5923 in a window. To make the change take effect, call `set-window-buffer'. */);
5925 DEFVAR_PER_BUFFER ("scroll-bar-width", &BVAR (current_buffer
, scroll_bar_width
),
5927 doc
: /* Width of this buffer's vertical scroll bars in pixels.
5928 A value of nil means to use the scroll bar width from the window's frame. */);
5930 DEFVAR_PER_BUFFER ("scroll-bar-height", &BVAR (current_buffer
, scroll_bar_height
),
5932 doc
: /* Height of this buffer's horizontal scroll bars in pixels.
5933 A value of nil means to use the scroll bar height from the window's frame. */);
5935 DEFVAR_PER_BUFFER ("vertical-scroll-bar", &BVAR (current_buffer
, vertical_scroll_bar_type
),
5936 Qvertical_scroll_bar
,
5937 doc
: /* Position of this buffer's vertical 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 `left' or `right' means put the vertical scroll bar at that side
5942 of the window; a value of nil means don't show any vertical scroll bars.
5943 A value of t (the default) means do whatever the window's frame specifies. */);
5945 DEFVAR_PER_BUFFER ("horizontal-scroll-bar", &BVAR (current_buffer
, horizontal_scroll_bar_type
),
5947 doc
: /* Position of this buffer's horizontal scroll bar.
5948 The value takes effect whenever you tell a window to display this buffer;
5949 for instance, with `set-window-buffer' or when `display-buffer' displays it.
5951 A value of `bottom' means put the horizontal scroll bar at the bottom of
5952 the window; a value of nil means don't show any horizontal scroll bars.
5953 A value of t (the default) means do whatever the window's frame
5956 DEFVAR_PER_BUFFER ("indicate-empty-lines",
5957 &BVAR (current_buffer
, indicate_empty_lines
), Qnil
,
5958 doc
: /* Visually indicate empty lines after the buffer end.
5959 If non-nil, a bitmap is displayed in the left fringe of a window on
5960 window-systems. */);
5962 DEFVAR_PER_BUFFER ("indicate-buffer-boundaries",
5963 &BVAR (current_buffer
, indicate_buffer_boundaries
), Qnil
,
5964 doc
: /* Visually indicate buffer boundaries and scrolling.
5965 If non-nil, the first and last line of the buffer are marked in the fringe
5966 of a window on window-systems with angle bitmaps, or if the window can be
5967 scrolled, the top and bottom line of the window are marked with up and down
5970 If value is a symbol `left' or `right', both angle and arrow bitmaps
5971 are displayed in the left or right fringe, resp. Any other value
5972 that doesn't look like an alist means display the angle bitmaps in
5973 the left fringe but no arrows.
5975 You can exercise more precise control by using an alist as the
5976 value. Each alist element (INDICATOR . POSITION) specifies
5977 where to show one of the indicators. INDICATOR is one of `top',
5978 `bottom', `up', `down', or t, which specifies the default position,
5979 and POSITION is one of `left', `right', or nil, meaning do not show
5982 For example, ((top . left) (t . right)) places the top angle bitmap in
5983 left fringe, the bottom angle bitmap in right fringe, and both arrow
5984 bitmaps in right fringe. To show just the angle bitmaps in the left
5985 fringe, but no arrow bitmaps, use ((top . left) (bottom . left)). */);
5987 DEFVAR_PER_BUFFER ("fringe-indicator-alist",
5988 &BVAR (current_buffer
, fringe_indicator_alist
), Qnil
,
5989 doc
: /* Mapping from logical to physical fringe indicator bitmaps.
5990 The value is an alist where each element (INDICATOR . BITMAPS)
5991 specifies the fringe bitmaps used to display a specific logical
5994 INDICATOR specifies the logical indicator type which is one of the
5995 following symbols: `truncation' , `continuation', `overlay-arrow',
5996 `top', `bottom', `top-bottom', `up', `down', empty-line', or `unknown'.
5998 BITMAPS is a list of symbols (LEFT RIGHT [LEFT1 RIGHT1]) which specifies
5999 the actual bitmap shown in the left or right fringe for the logical
6000 indicator. LEFT and RIGHT are the bitmaps shown in the left and/or
6001 right fringe for the specific indicator. The LEFT1 or RIGHT1 bitmaps
6002 are used only for the `bottom' and `top-bottom' indicators when the
6003 last (only) line has no final newline. BITMAPS may also be a single
6004 symbol which is used in both left and right fringes. */);
6006 DEFVAR_PER_BUFFER ("fringe-cursor-alist",
6007 &BVAR (current_buffer
, fringe_cursor_alist
), Qnil
,
6008 doc
: /* Mapping from logical to physical fringe cursor bitmaps.
6009 The value is an alist where each element (CURSOR . BITMAP)
6010 specifies the fringe bitmaps used to display a specific logical
6011 cursor type in the fringe.
6013 CURSOR specifies the logical cursor type which is one of the following
6014 symbols: `box' , `hollow', `bar', `hbar', or `hollow-small'. The last
6015 one is used to show a hollow cursor on narrow lines display lines
6016 where the normal hollow cursor will not fit.
6018 BITMAP is the corresponding fringe bitmap shown for the logical
6021 DEFVAR_PER_BUFFER ("scroll-up-aggressively",
6022 &BVAR (current_buffer
, scroll_up_aggressively
), Qfraction
,
6023 doc
: /* How far to scroll windows upward.
6024 If you move point off the bottom, the window scrolls automatically.
6025 This variable controls how far it scrolls. The value nil, the default,
6026 means scroll to center point. A fraction means scroll to put point
6027 that fraction of the window's height from the bottom of the window.
6028 When the value is 0.0, point goes at the bottom line, which in the
6029 simple case that you moved off with C-f means scrolling just one line.
6030 1.0 means point goes at the top, so that in that simple case, the
6031 window scrolls by a full window height. Meaningful values are
6032 between 0.0 and 1.0, inclusive. */);
6034 DEFVAR_PER_BUFFER ("scroll-down-aggressively",
6035 &BVAR (current_buffer
, scroll_down_aggressively
), Qfraction
,
6036 doc
: /* How far to scroll windows downward.
6037 If you move point off the top, the window scrolls automatically.
6038 This variable controls how far it scrolls. The value nil, the default,
6039 means scroll to center point. A fraction means scroll to put point
6040 that fraction of the window's height from the top of the window.
6041 When the value is 0.0, point goes at the top line, which in the
6042 simple case that you moved off with C-b means scrolling just one line.
6043 1.0 means point goes at the bottom, so that in that simple case, the
6044 window scrolls by a full window height. Meaningful values are
6045 between 0.0 and 1.0, inclusive. */);
6047 DEFVAR_LISP ("before-change-functions", Vbefore_change_functions
,
6048 doc
: /* List of functions to call before each text change.
6049 Two arguments are passed to each function: the positions of
6050 the beginning and end of the range of old text to be changed.
6051 (For an insertion, the beginning and end are at the same place.)
6052 No information is given about the length of the text after the change.
6054 Buffer changes made while executing the `before-change-functions'
6055 don't call any before-change or after-change functions.
6056 That's because `inhibit-modification-hooks' is temporarily set non-nil.
6058 If an unhandled error happens in running these functions,
6059 the variable's value remains nil. That prevents the error
6060 from happening repeatedly and making Emacs nonfunctional. */);
6061 Vbefore_change_functions
= Qnil
;
6063 DEFVAR_LISP ("after-change-functions", Vafter_change_functions
,
6064 doc
: /* List of functions to call after each text change.
6065 Three arguments are passed to each function: the positions of
6066 the beginning and end of the range of changed text,
6067 and the length in chars of the pre-change text replaced by that range.
6068 (For an insertion, the pre-change length is zero;
6069 for a deletion, that length is the number of chars deleted,
6070 and the post-change beginning and end are at the same place.)
6072 Buffer changes made while executing the `after-change-functions'
6073 don't call any before-change or after-change functions.
6074 That's because `inhibit-modification-hooks' is temporarily set non-nil.
6076 If an unhandled error happens in running these functions,
6077 the variable's value remains nil. That prevents the error
6078 from happening repeatedly and making Emacs nonfunctional. */);
6079 Vafter_change_functions
= Qnil
;
6081 DEFVAR_LISP ("first-change-hook", Vfirst_change_hook
,
6082 doc
: /* A list of functions to call before changing a buffer which is unmodified.
6083 The functions are run using the `run-hooks' function. */);
6084 Vfirst_change_hook
= Qnil
;
6086 DEFVAR_PER_BUFFER ("buffer-undo-list", &BVAR (current_buffer
, undo_list
), Qnil
,
6087 doc
: /* List of undo entries in current buffer.
6088 Recent changes come first; older changes follow newer.
6090 An entry (BEG . END) represents an insertion which begins at
6091 position BEG and ends at position END.
6093 An entry (TEXT . POSITION) represents the deletion of the string TEXT
6094 from (abs POSITION). If POSITION is positive, point was at the front
6095 of the text being deleted; if negative, point was at the end.
6097 An entry (t HIGH LOW USEC PSEC) indicates that the buffer was previously
6098 unmodified; (HIGH LOW USEC PSEC) is in the same style as (current-time)
6099 and is the visited file's modification time, as of that time. If the
6100 modification time of the most recent save is different, this entry is
6103 An entry (t . 0) means means the buffer was previously unmodified but
6104 its time stamp was unknown because it was not associated with a file.
6105 An entry (t . -1) is similar, except that it means the buffer's visited
6108 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
6109 was modified between BEG and END. PROPERTY is the property name,
6110 and VALUE is the old value.
6112 An entry (apply FUN-NAME . ARGS) means undo the change with
6113 (apply FUN-NAME ARGS).
6115 An entry (apply DELTA BEG END FUN-NAME . ARGS) supports selective undo
6116 in the active region. BEG and END is the range affected by this entry
6117 and DELTA is the number of characters added or deleted in that range by
6120 An entry (MARKER . DISTANCE) indicates that the marker MARKER
6121 was adjusted in position by the offset DISTANCE (an integer).
6123 An entry of the form POSITION indicates that point was at the buffer
6124 location given by the integer. Undoing an entry of this form places
6127 Entries with value nil mark undo boundaries. The undo command treats
6128 the changes between two undo boundaries as a single step to be undone.
6130 If the value of the variable is t, undo information is not recorded. */);
6132 DEFVAR_PER_BUFFER ("mark-active", &BVAR (current_buffer
, mark_active
), Qnil
,
6133 doc
: /* Non-nil means the mark and region are currently active in this buffer. */);
6135 DEFVAR_PER_BUFFER ("cache-long-scans", &BVAR (current_buffer
, cache_long_scans
), Qnil
,
6136 doc
: /* Non-nil means that Emacs should use caches in attempt to speedup buffer scans.
6138 There is no reason to set this to nil except for debugging purposes.
6140 Normally, the line-motion functions work by scanning the buffer for
6141 newlines. Columnar operations (like `move-to-column' and
6142 `compute-motion') also work by scanning the buffer, summing character
6143 widths as they go. This works well for ordinary text, but if the
6144 buffer's lines are very long (say, more than 500 characters), these
6145 motion functions will take longer to execute. Emacs may also take
6146 longer to update the display.
6148 If `cache-long-scans' is non-nil, these motion functions cache the
6149 results of their scans, and consult the cache to avoid rescanning
6150 regions of the buffer until the text is modified. The caches are most
6151 beneficial when they prevent the most searching---that is, when the
6152 buffer contains long lines and large regions of characters with the
6153 same, fixed screen width.
6155 When `cache-long-scans' is non-nil, processing short lines will
6156 become slightly slower (because of the overhead of consulting the
6157 cache), and the caches will use memory roughly proportional to the
6158 number of newlines and characters whose screen width varies.
6160 Bidirectional editing also requires buffer scans to find paragraph
6161 separators. If you have large paragraphs or no paragraph separators
6162 at all, these scans may be slow. If `cache-long-scans' is non-nil,
6163 results of these scans are cached. This doesn't help too much if
6164 paragraphs are of the reasonable (few thousands of characters) size.
6166 The caches require no explicit maintenance; their accuracy is
6167 maintained internally by the Emacs primitives. Enabling or disabling
6168 the cache should not affect the behavior of any of the motion
6169 functions; it should only affect their performance. */);
6171 DEFVAR_PER_BUFFER ("point-before-scroll", &BVAR (current_buffer
, point_before_scroll
), Qnil
,
6172 doc
: /* Value of point before the last series of scroll operations, or nil. */);
6174 DEFVAR_PER_BUFFER ("buffer-file-format", &BVAR (current_buffer
, file_format
), Qnil
,
6175 doc
: /* List of formats to use when saving this buffer.
6176 Formats are defined by `format-alist'. This variable is
6177 set when a file is visited. */);
6179 DEFVAR_PER_BUFFER ("buffer-auto-save-file-format",
6180 &BVAR (current_buffer
, auto_save_file_format
), Qnil
,
6181 doc
: /* Format in which to write auto-save files.
6182 Should be a list of symbols naming formats that are defined in `format-alist'.
6183 If it is t, which is the default, auto-save files are written in the
6184 same format as a regular save would use. */);
6186 DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
6187 &BVAR (current_buffer
, invisibility_spec
), Qnil
,
6188 doc
: /* Invisibility spec of this buffer.
6189 The default is t, which means that text is invisible if it has a non-nil
6190 `invisible' property.
6191 This variable can also be a list. The list can have two kinds of elements:
6192 `ATOM' and `(ATOM . ELLIPSIS)'. A text character is invisible if its
6193 `invisible' property is `ATOM', or has an `invisible' property that is a list
6194 that contains `ATOM'.
6195 If the `(ATOM . ELLIPSIS)' form is used, and `ELLIPSIS' is non-nil, an
6196 ellipsis will be displayed after the invisible characters.
6197 Setting this variable is very fast, much faster than scanning all the text in
6198 the buffer looking for properties to change. */);
6200 DEFVAR_PER_BUFFER ("buffer-display-count",
6201 &BVAR (current_buffer
, display_count
), Qintegerp
,
6202 doc
: /* A number incremented each time this buffer is displayed in a window.
6203 The function `set-window-buffer' increments it. */);
6205 DEFVAR_PER_BUFFER ("buffer-display-time",
6206 &BVAR (current_buffer
, display_time
), Qnil
,
6207 doc
: /* Time stamp updated each time this buffer is displayed in a window.
6208 The function `set-window-buffer' updates this variable
6209 to the value obtained by calling `current-time'.
6210 If the buffer has never been shown in a window, the value is nil. */);
6212 DEFVAR_LISP ("transient-mark-mode", Vtransient_mark_mode
,
6213 doc
: /* Non-nil if Transient Mark mode is enabled.
6214 See the command `transient-mark-mode' for a description of this minor mode.
6216 Non-nil also enables highlighting of the region whenever the mark is active.
6217 The region is highlighted with the `region' face.
6218 The variable `highlight-nonselected-windows' controls whether to highlight
6219 all windows or just the selected window.
6221 Lisp programs may give this variable certain special values:
6223 - A value of `lambda' enables Transient Mark mode temporarily.
6224 It is disabled again after any subsequent action that would
6225 normally deactivate the mark (e.g. buffer modification).
6227 - A value of (only . OLDVAL) enables Transient Mark mode
6228 temporarily. After any subsequent point motion command that is
6229 not shift-translated, or any other action that would normally
6230 deactivate the mark (e.g. buffer modification), the value of
6231 `transient-mark-mode' is set to OLDVAL. */);
6232 Vtransient_mark_mode
= Qnil
;
6234 DEFVAR_LISP ("inhibit-read-only", Vinhibit_read_only
,
6235 doc
: /* Non-nil means disregard read-only status of buffers or characters.
6236 If the value is t, disregard `buffer-read-only' and all `read-only'
6237 text properties. If the value is a list, disregard `buffer-read-only'
6238 and disregard a `read-only' text property if the property value
6239 is a member of the list. */);
6240 Vinhibit_read_only
= Qnil
;
6242 DEFVAR_PER_BUFFER ("cursor-type", &BVAR (current_buffer
, cursor_type
), Qnil
,
6243 doc
: /* Cursor to use when this buffer is in the selected window.
6244 Values are interpreted as follows:
6246 t use the cursor specified for the frame
6247 nil don't display a cursor
6248 box display a filled box cursor
6249 hollow display a hollow box cursor
6250 bar display a vertical bar cursor with default width
6251 (bar . WIDTH) display a vertical bar cursor with width WIDTH
6252 hbar display a horizontal bar cursor with default height
6253 (hbar . HEIGHT) display a horizontal bar cursor with height HEIGHT
6254 ANYTHING ELSE display a hollow box cursor
6256 When the buffer is displayed in a non-selected window, the
6257 cursor's appearance is instead controlled by the variable
6258 `cursor-in-non-selected-windows'. */);
6260 DEFVAR_PER_BUFFER ("line-spacing",
6261 &BVAR (current_buffer
, extra_line_spacing
), Qnumberp
,
6262 doc
: /* Additional space to put between lines when displaying a buffer.
6263 The space is measured in pixels, and put below lines on graphic displays,
6264 see `display-graphic-p'.
6265 If value is a floating point number, it specifies the spacing relative
6266 to the default frame line height. A value of nil means add no extra space. */);
6268 DEFVAR_PER_BUFFER ("cursor-in-non-selected-windows",
6269 &BVAR (current_buffer
, cursor_in_non_selected_windows
), Qnil
,
6270 doc
: /* Non-nil means show a cursor in non-selected windows.
6271 If nil, only shows a cursor in the selected window.
6272 If t, displays a cursor related to the usual cursor type
6273 (a solid box becomes hollow, a bar becomes a narrower bar).
6274 You can also specify the cursor type as in the `cursor-type' variable.
6275 Use Custom to set this variable and update the display. */);
6277 DEFVAR_LISP ("kill-buffer-query-functions", Vkill_buffer_query_functions
,
6278 doc
: /* List of functions called with no args to query before killing a buffer.
6279 The buffer being killed will be current while the functions are running.
6281 If any of them returns nil, the buffer is not killed. Functions run by
6282 this hook are supposed to not change the current buffer. */);
6283 Vkill_buffer_query_functions
= Qnil
;
6285 DEFVAR_LISP ("change-major-mode-hook", Vchange_major_mode_hook
,
6286 doc
: /* Normal hook run before changing the major mode of a buffer.
6287 The function `kill-all-local-variables' runs this before doing anything else. */);
6288 Vchange_major_mode_hook
= Qnil
;
6289 DEFSYM (Qchange_major_mode_hook
, "change-major-mode-hook");
6291 DEFVAR_LISP ("buffer-list-update-hook", Vbuffer_list_update_hook
,
6292 doc
: /* Hook run when the buffer list changes.
6293 Functions running this hook are, `get-buffer-create',
6294 `make-indirect-buffer', `rename-buffer', `kill-buffer',
6295 `bury-buffer-internal' and `select-window'. */);
6296 Vbuffer_list_update_hook
= Qnil
;
6297 DEFSYM (Qbuffer_list_update_hook
, "buffer-list-update-hook");
6299 defsubr (&Sbuffer_live_p
);
6300 defsubr (&Sbuffer_list
);
6301 defsubr (&Sget_buffer
);
6302 defsubr (&Sget_file_buffer
);
6303 defsubr (&Sget_buffer_create
);
6304 defsubr (&Smake_indirect_buffer
);
6305 defsubr (&Sgenerate_new_buffer_name
);
6306 defsubr (&Sbuffer_name
);
6307 defsubr (&Sbuffer_file_name
);
6308 defsubr (&Sbuffer_base_buffer
);
6309 defsubr (&Sbuffer_local_value
);
6310 defsubr (&Sbuffer_local_variables
);
6311 defsubr (&Sbuffer_modified_p
);
6312 defsubr (&Sforce_mode_line_update
);
6313 defsubr (&Sset_buffer_modified_p
);
6314 defsubr (&Sbuffer_modified_tick
);
6315 defsubr (&Sbuffer_chars_modified_tick
);
6316 defsubr (&Srename_buffer
);
6317 defsubr (&Sother_buffer
);
6318 defsubr (&Sbuffer_enable_undo
);
6319 defsubr (&Skill_buffer
);
6320 defsubr (&Sbury_buffer_internal
);
6321 defsubr (&Sset_buffer_major_mode
);
6322 defsubr (&Scurrent_buffer
);
6323 defsubr (&Sset_buffer
);
6324 defsubr (&Sbarf_if_buffer_read_only
);
6325 defsubr (&Serase_buffer
);
6326 defsubr (&Sbuffer_swap_text
);
6327 defsubr (&Sset_buffer_multibyte
);
6328 defsubr (&Skill_all_local_variables
);
6330 defsubr (&Soverlayp
);
6331 defsubr (&Smake_overlay
);
6332 defsubr (&Sdelete_overlay
);
6333 defsubr (&Sdelete_all_overlays
);
6334 defsubr (&Smove_overlay
);
6335 defsubr (&Soverlay_start
);
6336 defsubr (&Soverlay_end
);
6337 defsubr (&Soverlay_buffer
);
6338 defsubr (&Soverlay_properties
);
6339 defsubr (&Soverlays_at
);
6340 defsubr (&Soverlays_in
);
6341 defsubr (&Snext_overlay_change
);
6342 defsubr (&Sprevious_overlay_change
);
6343 defsubr (&Soverlay_recenter
);
6344 defsubr (&Soverlay_lists
);
6345 defsubr (&Soverlay_get
);
6346 defsubr (&Soverlay_put
);
6347 defsubr (&Srestore_buffer_modified_p
);
6349 Fput (intern_c_string ("erase-buffer"), Qdisabled
, Qt
);
6353 keys_of_buffer (void)
6355 initial_define_key (control_x_map
, 'b', "switch-to-buffer");
6356 initial_define_key (control_x_map
, 'k', "kill-buffer");