1 /* Buffer manipulation primitives for GNU Emacs.
3 Copyright (C) 1985-1989, 1993-1995, 1997-2016 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 (at
11 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"
48 #include "w32heap.h" /* for mmap_* */
51 struct buffer
*current_buffer
; /* The current buffer. */
53 /* First buffer in chain of all buffers (in reverse order of creation).
54 Threaded through ->header.next.buffer. */
56 struct buffer
*all_buffers
;
58 /* This structure holds the default values of the buffer-local variables
59 defined with DEFVAR_PER_BUFFER, that have special slots in each buffer.
60 The default value occupies the same slot in this structure
61 as an individual buffer's value occupies in that buffer.
62 Setting the default value also goes through the alist of buffers
63 and stores into each buffer that does not say it has a local value. */
65 struct buffer
alignas (GCALIGNMENT
) buffer_defaults
;
67 /* This structure marks which slots in a buffer have corresponding
68 default values in buffer_defaults.
69 Each such slot has a nonzero value in this structure.
70 The value has only one nonzero bit.
72 When a buffer has its own local value for a slot,
73 the entry for that slot (found in the same slot in this structure)
74 is turned on in the buffer's local_flags array.
76 If a slot in this structure is -1, then even though there may
77 be a DEFVAR_PER_BUFFER for the slot, there is no default value for it;
78 and the corresponding slot in buffer_defaults is not used.
80 If a slot in this structure corresponding to a DEFVAR_PER_BUFFER is
81 zero, that is a bug. */
83 struct buffer buffer_local_flags
;
85 /* This structure holds the names of symbols whose values may be
86 buffer-local. It is indexed and accessed in the same way as the above. */
88 struct buffer
alignas (GCALIGNMENT
) buffer_local_symbols
;
90 /* Return the symbol of the per-buffer variable at offset OFFSET in
91 the buffer structure. */
93 #define PER_BUFFER_SYMBOL(OFFSET) \
94 (*(Lisp_Object *)((OFFSET) + (char *) &buffer_local_symbols))
96 /* Maximum length of an overlay vector. */
97 #define OVERLAY_COUNT_MAX \
98 ((ptrdiff_t) min (MOST_POSITIVE_FIXNUM, \
99 min (PTRDIFF_MAX, SIZE_MAX) / word_size))
101 /* Flags indicating which built-in buffer-local variables
102 are permanent locals. */
103 static char buffer_permanent_local_flags
[MAX_PER_BUFFER_VARS
];
105 /* Number of per-buffer variables used. */
107 int last_per_buffer_idx
;
109 static void call_overlay_mod_hooks (Lisp_Object list
, Lisp_Object overlay
,
110 bool after
, Lisp_Object arg1
,
111 Lisp_Object arg2
, Lisp_Object arg3
);
112 static void swap_out_buffer_local_variables (struct buffer
*b
);
113 static void reset_buffer_local_variables (struct buffer
*, bool);
115 /* Alist of all buffer names vs the buffers. This used to be
116 a Lisp-visible variable, but is no longer, to prevent lossage
117 due to user rplac'ing this alist or its elements. */
118 Lisp_Object Vbuffer_alist
;
120 static Lisp_Object QSFundamental
; /* A string "Fundamental". */
122 static void alloc_buffer_text (struct buffer
*, ptrdiff_t);
123 static void free_buffer_text (struct buffer
*b
);
124 static struct Lisp_Overlay
* copy_overlays (struct buffer
*, struct Lisp_Overlay
*);
125 static void modify_overlay (struct buffer
*, ptrdiff_t, ptrdiff_t);
126 static Lisp_Object
buffer_lisp_local_variables (struct buffer
*, bool);
129 CHECK_OVERLAY (Lisp_Object x
)
131 CHECK_TYPE (OVERLAYP (x
), Qoverlayp
, x
);
134 /* These setters are used only in this file, so they can be private.
135 The public setters are inline functions defined in buffer.h. */
137 bset_abbrev_mode (struct buffer
*b
, Lisp_Object val
)
139 b
->abbrev_mode_
= val
;
142 bset_abbrev_table (struct buffer
*b
, Lisp_Object val
)
144 b
->abbrev_table_
= val
;
147 bset_auto_fill_function (struct buffer
*b
, Lisp_Object val
)
149 b
->auto_fill_function_
= val
;
152 bset_auto_save_file_format (struct buffer
*b
, Lisp_Object val
)
154 b
->auto_save_file_format_
= val
;
157 bset_auto_save_file_name (struct buffer
*b
, Lisp_Object val
)
159 b
->auto_save_file_name_
= val
;
162 bset_backed_up (struct buffer
*b
, Lisp_Object val
)
167 bset_begv_marker (struct buffer
*b
, Lisp_Object val
)
169 b
->begv_marker_
= val
;
172 bset_bidi_display_reordering (struct buffer
*b
, Lisp_Object val
)
174 b
->bidi_display_reordering_
= val
;
177 bset_buffer_file_coding_system (struct buffer
*b
, Lisp_Object val
)
179 b
->buffer_file_coding_system_
= val
;
182 bset_case_fold_search (struct buffer
*b
, Lisp_Object val
)
184 b
->case_fold_search_
= val
;
187 bset_ctl_arrow (struct buffer
*b
, Lisp_Object val
)
192 bset_cursor_in_non_selected_windows (struct buffer
*b
, Lisp_Object val
)
194 b
->cursor_in_non_selected_windows_
= val
;
197 bset_cursor_type (struct buffer
*b
, Lisp_Object val
)
199 b
->cursor_type_
= val
;
202 bset_display_table (struct buffer
*b
, Lisp_Object val
)
204 b
->display_table_
= val
;
207 bset_extra_line_spacing (struct buffer
*b
, Lisp_Object val
)
209 b
->extra_line_spacing_
= val
;
212 bset_file_format (struct buffer
*b
, Lisp_Object val
)
214 b
->file_format_
= val
;
217 bset_file_truename (struct buffer
*b
, Lisp_Object val
)
219 b
->file_truename_
= val
;
222 bset_fringe_cursor_alist (struct buffer
*b
, Lisp_Object val
)
224 b
->fringe_cursor_alist_
= val
;
227 bset_fringe_indicator_alist (struct buffer
*b
, Lisp_Object val
)
229 b
->fringe_indicator_alist_
= val
;
232 bset_fringes_outside_margins (struct buffer
*b
, Lisp_Object val
)
234 b
->fringes_outside_margins_
= val
;
237 bset_header_line_format (struct buffer
*b
, Lisp_Object val
)
239 b
->header_line_format_
= val
;
242 bset_indicate_buffer_boundaries (struct buffer
*b
, Lisp_Object val
)
244 b
->indicate_buffer_boundaries_
= val
;
247 bset_indicate_empty_lines (struct buffer
*b
, Lisp_Object val
)
249 b
->indicate_empty_lines_
= val
;
252 bset_invisibility_spec (struct buffer
*b
, Lisp_Object val
)
254 b
->invisibility_spec_
= val
;
257 bset_left_fringe_width (struct buffer
*b
, Lisp_Object val
)
259 b
->left_fringe_width_
= val
;
262 bset_major_mode (struct buffer
*b
, Lisp_Object val
)
264 b
->major_mode_
= val
;
267 bset_mark (struct buffer
*b
, Lisp_Object val
)
272 bset_minor_modes (struct buffer
*b
, Lisp_Object val
)
274 b
->minor_modes_
= val
;
277 bset_mode_line_format (struct buffer
*b
, Lisp_Object val
)
279 b
->mode_line_format_
= val
;
282 bset_mode_name (struct buffer
*b
, Lisp_Object val
)
287 bset_name (struct buffer
*b
, Lisp_Object val
)
292 bset_overwrite_mode (struct buffer
*b
, Lisp_Object val
)
294 b
->overwrite_mode_
= val
;
297 bset_pt_marker (struct buffer
*b
, Lisp_Object val
)
302 bset_right_fringe_width (struct buffer
*b
, Lisp_Object val
)
304 b
->right_fringe_width_
= val
;
307 bset_save_length (struct buffer
*b
, Lisp_Object val
)
309 b
->save_length_
= val
;
312 bset_scroll_bar_width (struct buffer
*b
, Lisp_Object val
)
314 b
->scroll_bar_width_
= val
;
317 bset_scroll_bar_height (struct buffer
*b
, Lisp_Object val
)
319 b
->scroll_bar_height_
= val
;
322 bset_scroll_down_aggressively (struct buffer
*b
, Lisp_Object val
)
324 b
->scroll_down_aggressively_
= val
;
327 bset_scroll_up_aggressively (struct buffer
*b
, Lisp_Object val
)
329 b
->scroll_up_aggressively_
= val
;
332 bset_selective_display (struct buffer
*b
, Lisp_Object val
)
334 b
->selective_display_
= val
;
337 bset_selective_display_ellipses (struct buffer
*b
, Lisp_Object val
)
339 b
->selective_display_ellipses_
= val
;
342 bset_vertical_scroll_bar_type (struct buffer
*b
, Lisp_Object val
)
344 b
->vertical_scroll_bar_type_
= val
;
347 bset_horizontal_scroll_bar_type (struct buffer
*b
, Lisp_Object val
)
349 b
->horizontal_scroll_bar_type_
= val
;
352 bset_word_wrap (struct buffer
*b
, Lisp_Object val
)
357 bset_zv_marker (struct buffer
*b
, Lisp_Object val
)
363 nsberror (Lisp_Object spec
)
366 error ("No buffer named %s", SDATA (spec
));
367 error ("Invalid buffer argument");
370 DEFUN ("buffer-live-p", Fbuffer_live_p
, Sbuffer_live_p
, 1, 1, 0,
371 doc
: /* Return non-nil if OBJECT is a buffer which has not been killed.
372 Value is nil if OBJECT is not a buffer or if it has been killed. */)
375 return ((BUFFERP (object
) && BUFFER_LIVE_P (XBUFFER (object
)))
379 DEFUN ("buffer-list", Fbuffer_list
, Sbuffer_list
, 0, 1, 0,
380 doc
: /* Return a list of all existing live buffers.
381 If the optional arg FRAME is a frame, we return the buffer list in the
382 proper order for that frame: the buffers show in FRAME come first,
383 followed by the rest of the buffers. */)
387 general
= Fmapcar (Qcdr
, Vbuffer_alist
);
391 Lisp_Object framelist
, prevlist
, tail
;
393 framelist
= Fcopy_sequence (XFRAME (frame
)->buffer_list
);
394 prevlist
= Fnreverse (Fcopy_sequence
395 (XFRAME (frame
)->buried_buffer_list
));
397 /* Remove from GENERAL any buffer that duplicates one in
398 FRAMELIST or PREVLIST. */
402 general
= Fdelq (XCAR (tail
), general
);
408 general
= Fdelq (XCAR (tail
), general
);
412 return CALLN (Fnconc
, framelist
, general
, prevlist
);
418 /* Like Fassoc, but use Fstring_equal to compare
419 (which ignores text properties),
420 and don't ever QUIT. */
423 assoc_ignore_text_properties (register Lisp_Object key
, Lisp_Object list
)
425 register Lisp_Object tail
;
426 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
428 register Lisp_Object elt
, tem
;
430 tem
= Fstring_equal (Fcar (elt
), key
);
437 DEFUN ("get-buffer", Fget_buffer
, Sget_buffer
, 1, 1, 0,
438 doc
: /* Return the buffer named BUFFER-OR-NAME.
439 BUFFER-OR-NAME must be either a string or a buffer. If BUFFER-OR-NAME
440 is a string and there is no buffer with that name, return nil. If
441 BUFFER-OR-NAME is a buffer, return it as given. */)
442 (register Lisp_Object buffer_or_name
)
444 if (BUFFERP (buffer_or_name
))
445 return buffer_or_name
;
446 CHECK_STRING (buffer_or_name
);
448 return Fcdr (assoc_ignore_text_properties (buffer_or_name
, Vbuffer_alist
));
451 DEFUN ("get-file-buffer", Fget_file_buffer
, Sget_file_buffer
, 1, 1, 0,
452 doc
: /* Return the buffer visiting file FILENAME (a string).
453 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
454 If there is no such live buffer, return nil.
455 See also `find-buffer-visiting'. */)
456 (register Lisp_Object filename
)
458 register Lisp_Object tail
, buf
, handler
;
460 CHECK_STRING (filename
);
461 filename
= Fexpand_file_name (filename
, Qnil
);
463 /* If the file name has special constructs in it,
464 call the corresponding file handler. */
465 handler
= Ffind_file_name_handler (filename
, Qget_file_buffer
);
468 Lisp_Object handled_buf
= call2 (handler
, Qget_file_buffer
,
470 return BUFFERP (handled_buf
) ? handled_buf
: Qnil
;
473 FOR_EACH_LIVE_BUFFER (tail
, buf
)
475 if (!STRINGP (BVAR (XBUFFER (buf
), filename
))) continue;
476 if (!NILP (Fstring_equal (BVAR (XBUFFER (buf
), filename
), filename
)))
483 get_truename_buffer (register Lisp_Object filename
)
485 register Lisp_Object tail
, buf
;
487 FOR_EACH_LIVE_BUFFER (tail
, buf
)
489 if (!STRINGP (BVAR (XBUFFER (buf
), file_truename
))) continue;
490 if (!NILP (Fstring_equal (BVAR (XBUFFER (buf
), file_truename
), filename
)))
496 DEFUN ("get-buffer-create", Fget_buffer_create
, Sget_buffer_create
, 1, 1, 0,
497 doc
: /* Return the buffer specified by BUFFER-OR-NAME, creating a new one if needed.
498 If BUFFER-OR-NAME is a string and a live buffer with that name exists,
499 return that buffer. If no such buffer exists, create a new buffer with
500 that name and return it. If BUFFER-OR-NAME starts with a space, the new
501 buffer does not keep undo information.
503 If BUFFER-OR-NAME is a buffer instead of a string, return it as given,
504 even if it is dead. The return value is never nil. */)
505 (register Lisp_Object buffer_or_name
)
507 register Lisp_Object buffer
, name
;
508 register struct buffer
*b
;
510 buffer
= Fget_buffer (buffer_or_name
);
514 if (SCHARS (buffer_or_name
) == 0)
515 error ("Empty string for buffer name is not allowed");
517 b
= allocate_buffer ();
519 /* An ordinary buffer uses its own struct buffer_text. */
520 b
->text
= &b
->own_text
;
521 b
->base_buffer
= NULL
;
522 /* No one shares the text with us now. */
524 /* No one shows us now. */
527 BUF_GAP_SIZE (b
) = 20;
529 /* We allocate extra 1-byte at the tail and keep it always '\0' for
530 anchoring a search. */
531 alloc_buffer_text (b
, BUF_GAP_SIZE (b
) + 1);
533 if (! BUF_BEG_ADDR (b
))
534 buffer_memory_full (BUF_GAP_SIZE (b
) + 1);
539 b
->pt_byte
= BEG_BYTE
;
540 b
->begv_byte
= BEG_BYTE
;
541 b
->zv_byte
= BEG_BYTE
;
544 BUF_GPT_BYTE (b
) = BEG_BYTE
;
547 BUF_Z_BYTE (b
) = BEG_BYTE
;
549 BUF_CHARS_MODIFF (b
) = 1;
550 BUF_OVERLAY_MODIFF (b
) = 1;
551 BUF_SAVE_MODIFF (b
) = 1;
553 set_buffer_intervals (b
, NULL
);
554 BUF_UNCHANGED_MODIFIED (b
) = 1;
555 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = 1;
556 BUF_END_UNCHANGED (b
) = 0;
557 BUF_BEG_UNCHANGED (b
) = 0;
558 *(BUF_GPT_ADDR (b
)) = *(BUF_Z_ADDR (b
)) = 0; /* Put an anchor '\0'. */
559 b
->text
->inhibit_shrinking
= false;
560 b
->text
->redisplay
= false;
562 b
->newline_cache
= 0;
563 b
->width_run_cache
= 0;
564 b
->bidi_paragraph_cache
= 0;
565 bset_width_table (b
, Qnil
);
566 b
->prevent_redisplay_optimizations_p
= 1;
568 /* An ordinary buffer normally doesn't need markers
569 to handle BEGV and ZV. */
570 bset_pt_marker (b
, Qnil
);
571 bset_begv_marker (b
, Qnil
);
572 bset_zv_marker (b
, Qnil
);
574 name
= Fcopy_sequence (buffer_or_name
);
575 set_string_intervals (name
, NULL
);
578 bset_undo_list (b
, SREF (name
, 0) != ' ' ? Qnil
: Qt
);
581 reset_buffer_local_variables (b
, 1);
583 bset_mark (b
, Fmake_marker ());
584 BUF_MARKERS (b
) = NULL
;
586 /* Put this in the alist of all live buffers. */
587 XSETBUFFER (buffer
, b
);
588 Vbuffer_alist
= nconc2 (Vbuffer_alist
, list1 (Fcons (name
, buffer
)));
589 /* And run buffer-list-update-hook. */
590 if (!NILP (Vrun_hooks
))
591 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
597 /* Return a list of overlays which is a copy of the overlay list
598 LIST, but for buffer B. */
600 static struct Lisp_Overlay
*
601 copy_overlays (struct buffer
*b
, struct Lisp_Overlay
*list
)
603 struct Lisp_Overlay
*result
= NULL
, *tail
= NULL
;
605 for (; list
; list
= list
->next
)
607 Lisp_Object overlay
, start
, end
;
608 struct Lisp_Marker
*m
;
610 eassert (MARKERP (list
->start
));
611 m
= XMARKER (list
->start
);
612 start
= build_marker (b
, m
->charpos
, m
->bytepos
);
613 XMARKER (start
)->insertion_type
= m
->insertion_type
;
615 eassert (MARKERP (list
->end
));
616 m
= XMARKER (list
->end
);
617 end
= build_marker (b
, m
->charpos
, m
->bytepos
);
618 XMARKER (end
)->insertion_type
= m
->insertion_type
;
620 overlay
= build_overlay (start
, end
, Fcopy_sequence (list
->plist
));
622 tail
= tail
->next
= XOVERLAY (overlay
);
624 result
= tail
= XOVERLAY (overlay
);
630 /* Set an appropriate overlay of B. */
633 set_buffer_overlays_before (struct buffer
*b
, struct Lisp_Overlay
*o
)
635 b
->overlays_before
= o
;
639 set_buffer_overlays_after (struct buffer
*b
, struct Lisp_Overlay
*o
)
641 b
->overlays_after
= o
;
644 /* Clone per-buffer values of buffer FROM.
646 Buffer TO gets the same per-buffer values as FROM, with the
647 following exceptions: (1) TO's name is left untouched, (2) markers
648 are copied and made to refer to TO, and (3) overlay lists are
652 clone_per_buffer_values (struct buffer
*from
, struct buffer
*to
)
656 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
660 /* Don't touch the `name' which should be unique for every buffer. */
661 if (offset
== PER_BUFFER_VAR_OFFSET (name
))
664 obj
= per_buffer_value (from
, offset
);
665 if (MARKERP (obj
) && XMARKER (obj
)->buffer
== from
)
667 struct Lisp_Marker
*m
= XMARKER (obj
);
669 obj
= build_marker (to
, m
->charpos
, m
->bytepos
);
670 XMARKER (obj
)->insertion_type
= m
->insertion_type
;
673 set_per_buffer_value (to
, offset
, obj
);
676 memcpy (to
->local_flags
, from
->local_flags
, sizeof to
->local_flags
);
678 set_buffer_overlays_before (to
, copy_overlays (to
, from
->overlays_before
));
679 set_buffer_overlays_after (to
, copy_overlays (to
, from
->overlays_after
));
681 /* Get (a copy of) the alist of Lisp-level local variables of FROM
682 and install that in TO. */
683 bset_local_var_alist (to
, buffer_lisp_local_variables (from
, 1));
687 /* If buffer B has markers to record PT, BEGV and ZV when it is not
688 current, update these markers. */
691 record_buffer_markers (struct buffer
*b
)
693 if (! NILP (BVAR (b
, pt_marker
)))
697 eassert (!NILP (BVAR (b
, begv_marker
)));
698 eassert (!NILP (BVAR (b
, zv_marker
)));
700 XSETBUFFER (buffer
, b
);
701 set_marker_both (BVAR (b
, pt_marker
), buffer
, b
->pt
, b
->pt_byte
);
702 set_marker_both (BVAR (b
, begv_marker
), buffer
, b
->begv
, b
->begv_byte
);
703 set_marker_both (BVAR (b
, zv_marker
), buffer
, b
->zv
, b
->zv_byte
);
708 /* If buffer B has markers to record PT, BEGV and ZV when it is not
709 current, fetch these values into B->begv etc. */
712 fetch_buffer_markers (struct buffer
*b
)
714 if (! NILP (BVAR (b
, pt_marker
)))
718 eassert (!NILP (BVAR (b
, begv_marker
)));
719 eassert (!NILP (BVAR (b
, zv_marker
)));
721 m
= BVAR (b
, pt_marker
);
722 SET_BUF_PT_BOTH (b
, marker_position (m
), marker_byte_position (m
));
724 m
= BVAR (b
, begv_marker
);
725 SET_BUF_BEGV_BOTH (b
, marker_position (m
), marker_byte_position (m
));
727 m
= BVAR (b
, zv_marker
);
728 SET_BUF_ZV_BOTH (b
, marker_position (m
), marker_byte_position (m
));
733 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer
, Smake_indirect_buffer
,
735 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ",
736 doc
: /* Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.
737 BASE-BUFFER should be a live buffer, or the name of an existing buffer.
738 NAME should be a string which is not the name of an existing buffer.
739 Optional argument CLONE non-nil means preserve BASE-BUFFER's state,
740 such as major and minor modes, in the indirect buffer.
741 CLONE nil means the indirect buffer's state is reset to default values. */)
742 (Lisp_Object base_buffer
, Lisp_Object name
, Lisp_Object clone
)
744 Lisp_Object buf
, tem
;
748 buf
= Fget_buffer (name
);
750 error ("Buffer name `%s' is in use", SDATA (name
));
753 base_buffer
= Fget_buffer (base_buffer
);
754 if (NILP (base_buffer
))
755 error ("No such buffer: `%s'", SDATA (tem
));
756 if (!BUFFER_LIVE_P (XBUFFER (base_buffer
)))
757 error ("Base buffer has been killed");
759 if (SCHARS (name
) == 0)
760 error ("Empty string for buffer name is not allowed");
762 b
= allocate_buffer ();
764 /* No double indirection - if base buffer is indirect,
765 new buffer becomes an indirect to base's base. */
766 b
->base_buffer
= (XBUFFER (base_buffer
)->base_buffer
767 ? XBUFFER (base_buffer
)->base_buffer
768 : XBUFFER (base_buffer
));
770 /* Use the base buffer's text object. */
771 b
->text
= b
->base_buffer
->text
;
772 /* We have no own text. */
773 b
->indirections
= -1;
774 /* Notify base buffer that we share the text now. */
775 b
->base_buffer
->indirections
++;
776 /* Always -1 for an indirect buffer. */
777 b
->window_count
= -1;
779 b
->pt
= b
->base_buffer
->pt
;
780 b
->begv
= b
->base_buffer
->begv
;
781 b
->zv
= b
->base_buffer
->zv
;
782 b
->pt_byte
= b
->base_buffer
->pt_byte
;
783 b
->begv_byte
= b
->base_buffer
->begv_byte
;
784 b
->zv_byte
= b
->base_buffer
->zv_byte
;
786 b
->newline_cache
= 0;
787 b
->width_run_cache
= 0;
788 b
->bidi_paragraph_cache
= 0;
789 bset_width_table (b
, Qnil
);
791 name
= Fcopy_sequence (name
);
792 set_string_intervals (name
, NULL
);
795 /* An indirect buffer shares undo list of its base (Bug#18180). */
796 bset_undo_list (b
, BVAR (b
->base_buffer
, undo_list
));
799 reset_buffer_local_variables (b
, 1);
801 /* Put this in the alist of all live buffers. */
803 Vbuffer_alist
= nconc2 (Vbuffer_alist
, list1 (Fcons (name
, buf
)));
805 bset_mark (b
, Fmake_marker ());
807 /* The multibyte status belongs to the base buffer. */
808 bset_enable_multibyte_characters
809 (b
, BVAR (b
->base_buffer
, enable_multibyte_characters
));
811 /* Make sure the base buffer has markers for its narrowing. */
812 if (NILP (BVAR (b
->base_buffer
, pt_marker
)))
814 eassert (NILP (BVAR (b
->base_buffer
, begv_marker
)));
815 eassert (NILP (BVAR (b
->base_buffer
, zv_marker
)));
817 bset_pt_marker (b
->base_buffer
,
818 build_marker (b
->base_buffer
, b
->base_buffer
->pt
,
819 b
->base_buffer
->pt_byte
));
821 bset_begv_marker (b
->base_buffer
,
822 build_marker (b
->base_buffer
, b
->base_buffer
->begv
,
823 b
->base_buffer
->begv_byte
));
825 bset_zv_marker (b
->base_buffer
,
826 build_marker (b
->base_buffer
, b
->base_buffer
->zv
,
827 b
->base_buffer
->zv_byte
));
829 XMARKER (BVAR (b
->base_buffer
, zv_marker
))->insertion_type
= 1;
834 /* Give the indirect buffer markers for its narrowing. */
835 bset_pt_marker (b
, build_marker (b
, b
->pt
, b
->pt_byte
));
836 bset_begv_marker (b
, build_marker (b
, b
->begv
, b
->begv_byte
));
837 bset_zv_marker (b
, build_marker (b
, b
->zv
, b
->zv_byte
));
838 XMARKER (BVAR (b
, zv_marker
))->insertion_type
= 1;
842 struct buffer
*old_b
= current_buffer
;
844 clone_per_buffer_values (b
->base_buffer
, b
);
845 bset_filename (b
, Qnil
);
846 bset_file_truename (b
, Qnil
);
847 bset_display_count (b
, make_number (0));
848 bset_backed_up (b
, Qnil
);
849 bset_auto_save_file_name (b
, Qnil
);
850 set_buffer_internal_1 (b
);
851 Fset (intern ("buffer-save-without-query"), Qnil
);
852 Fset (intern ("buffer-file-number"), Qnil
);
853 Fset (intern ("buffer-stale-function"), Qnil
);
854 set_buffer_internal_1 (old_b
);
857 /* Run buffer-list-update-hook. */
858 if (!NILP (Vrun_hooks
))
859 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
864 /* Mark OV as no longer associated with B. */
867 drop_overlay (struct buffer
*b
, struct Lisp_Overlay
*ov
)
869 eassert (b
== XBUFFER (Fmarker_buffer (ov
->start
)));
870 modify_overlay (b
, marker_position (ov
->start
),
871 marker_position (ov
->end
));
872 unchain_marker (XMARKER (ov
->start
));
873 unchain_marker (XMARKER (ov
->end
));
877 /* Delete all overlays of B and reset it's overlay lists. */
880 delete_all_overlays (struct buffer
*b
)
882 struct Lisp_Overlay
*ov
, *next
;
884 /* FIXME: Since each drop_overlay will scan BUF_MARKERS to unlink its
885 markers, we have an unneeded O(N^2) behavior here. */
886 for (ov
= b
->overlays_before
; ov
; ov
= next
)
888 drop_overlay (b
, ov
);
893 for (ov
= b
->overlays_after
; ov
; ov
= next
)
895 drop_overlay (b
, ov
);
900 set_buffer_overlays_before (b
, NULL
);
901 set_buffer_overlays_after (b
, NULL
);
904 /* Reinitialize everything about a buffer except its name and contents
906 If called on an already-initialized buffer, the list of overlays
907 should be deleted before calling this function, otherwise we end up
908 with overlays that claim to belong to the buffer but the buffer
909 claims it doesn't belong to it. */
912 reset_buffer (register struct buffer
*b
)
914 bset_filename (b
, Qnil
);
915 bset_file_truename (b
, Qnil
);
916 bset_directory (b
, current_buffer
? BVAR (current_buffer
, directory
) : Qnil
);
917 b
->modtime
= make_timespec (0, UNKNOWN_MODTIME_NSECS
);
918 b
->modtime_size
= -1;
919 XSETFASTINT (BVAR (b
, save_length
), 0);
920 b
->last_window_start
= 1;
921 /* It is more conservative to start out "changed" than "unchanged". */
923 b
->prevent_redisplay_optimizations_p
= 1;
924 bset_backed_up (b
, Qnil
);
925 BUF_AUTOSAVE_MODIFF (b
) = 0;
926 b
->auto_save_failure_time
= 0;
927 bset_auto_save_file_name (b
, Qnil
);
928 bset_read_only (b
, Qnil
);
929 set_buffer_overlays_before (b
, NULL
);
930 set_buffer_overlays_after (b
, NULL
);
931 b
->overlay_center
= BEG
;
932 bset_mark_active (b
, Qnil
);
933 bset_point_before_scroll (b
, Qnil
);
934 bset_file_format (b
, Qnil
);
935 bset_auto_save_file_format (b
, Qt
);
936 bset_last_selected_window (b
, Qnil
);
937 bset_display_count (b
, make_number (0));
938 bset_display_time (b
, Qnil
);
939 bset_enable_multibyte_characters
940 (b
, BVAR (&buffer_defaults
, enable_multibyte_characters
));
941 bset_cursor_type (b
, BVAR (&buffer_defaults
, cursor_type
));
942 bset_extra_line_spacing (b
, BVAR (&buffer_defaults
, extra_line_spacing
));
944 b
->display_error_modiff
= 0;
947 /* Reset buffer B's local variables info.
948 Don't use this on a buffer that has already been in use;
949 it does not treat permanent locals consistently.
950 Instead, use Fkill_all_local_variables.
952 If PERMANENT_TOO, reset permanent buffer-local variables.
953 If not, preserve those. */
956 reset_buffer_local_variables (struct buffer
*b
, bool permanent_too
)
960 /* Reset the major mode to Fundamental, together with all the
961 things that depend on the major mode.
962 default-major-mode is handled at a higher level.
963 We ignore it here. */
964 bset_major_mode (b
, Qfundamental_mode
);
965 bset_keymap (b
, Qnil
);
966 bset_mode_name (b
, QSFundamental
);
967 bset_minor_modes (b
, Qnil
);
969 /* If the standard case table has been altered and invalidated,
970 fix up its insides first. */
971 if (! (CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[0])
972 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[1])
973 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[2])))
974 Fset_standard_case_table (Vascii_downcase_table
);
976 bset_downcase_table (b
, Vascii_downcase_table
);
977 bset_upcase_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[0]);
978 bset_case_canon_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[1]);
979 bset_case_eqv_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[2]);
980 bset_invisibility_spec (b
, Qt
);
982 /* Reset all (or most) per-buffer variables to their defaults. */
984 bset_local_var_alist (b
, Qnil
);
987 Lisp_Object tmp
, prop
, last
= Qnil
;
988 for (tmp
= BVAR (b
, local_var_alist
); CONSP (tmp
); tmp
= XCDR (tmp
))
989 if (!NILP (prop
= Fget (XCAR (XCAR (tmp
)), Qpermanent_local
)))
991 /* If permanent-local, keep it. */
993 if (EQ (prop
, Qpermanent_local_hook
))
995 /* This is a partially permanent hook variable.
996 Preserve only the elements that want to be preserved. */
997 Lisp_Object list
, newlist
;
998 list
= XCDR (XCAR (tmp
));
1002 for (newlist
= Qnil
; CONSP (list
); list
= XCDR (list
))
1004 Lisp_Object elt
= XCAR (list
);
1005 /* Preserve element ELT if it's t,
1006 if it is a function with a `permanent-local-hook' property,
1007 or if it's not a symbol. */
1010 || !NILP (Fget (elt
, Qpermanent_local_hook
)))
1011 newlist
= Fcons (elt
, newlist
);
1013 XSETCDR (XCAR (tmp
), Fnreverse (newlist
));
1016 /* Delete this local variable. */
1017 else if (NILP (last
))
1018 bset_local_var_alist (b
, XCDR (tmp
));
1020 XSETCDR (last
, XCDR (tmp
));
1023 for (i
= 0; i
< last_per_buffer_idx
; ++i
)
1024 if (permanent_too
|| buffer_permanent_local_flags
[i
] == 0)
1025 SET_PER_BUFFER_VALUE_P (b
, i
, 0);
1027 /* For each slot that has a default value, copy that into the slot. */
1028 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
1030 int idx
= PER_BUFFER_IDX (offset
);
1033 || buffer_permanent_local_flags
[idx
] == 0)))
1034 set_per_buffer_value (b
, offset
, per_buffer_default (offset
));
1038 /* We split this away from generate-new-buffer, because rename-buffer
1039 and set-visited-file-name ought to be able to use this to really
1040 rename the buffer properly. */
1042 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name
,
1043 Sgenerate_new_buffer_name
, 1, 2, 0,
1044 doc
: /* Return a string that is the name of no existing buffer based on NAME.
1045 If there is no live buffer named NAME, then return NAME.
1046 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
1047 \(starting at 2) until an unused name is found, and then return that name.
1048 Optional second argument IGNORE specifies a name that is okay to use (if
1049 it is in the sequence to be tried) even if a buffer with that name exists.
1051 If NAME begins with a space (i.e., a buffer that is not normally
1052 visible to users), then if buffer NAME already exists a random number
1053 is first appended to NAME, to speed up finding a non-existent buffer. */)
1054 (Lisp_Object name
, Lisp_Object ignore
)
1056 Lisp_Object genbase
;
1058 CHECK_STRING (name
);
1060 if (!NILP (Fstring_equal (name
, ignore
)) || NILP (Fget_buffer (name
)))
1063 if (SREF (name
, 0) != ' ') /* See bug#1229. */
1067 /* Note fileio.c:make_temp_name does random differently. */
1068 char number
[sizeof "-999999"];
1069 int i
= XFASTINT (Frandom (make_number (999999)));
1070 AUTO_STRING_WITH_LEN (lnumber
, number
, sprintf (number
, "-%d", i
));
1071 genbase
= concat2 (name
, lnumber
);
1072 if (NILP (Fget_buffer (genbase
)))
1076 for (ptrdiff_t count
= 2; ; count
++)
1078 char number
[INT_BUFSIZE_BOUND (ptrdiff_t) + sizeof "<>"];
1079 AUTO_STRING_WITH_LEN (lnumber
, number
,
1080 sprintf (number
, "<%"pD
"d>", count
));
1081 Lisp_Object gentemp
= concat2 (genbase
, lnumber
);
1082 if (!NILP (Fstring_equal (gentemp
, ignore
))
1083 || NILP (Fget_buffer (gentemp
)))
1089 DEFUN ("buffer-name", Fbuffer_name
, Sbuffer_name
, 0, 1, 0,
1090 doc
: /* Return the name of BUFFER, as a string.
1091 BUFFER defaults to the current buffer.
1092 Return nil if BUFFER has been killed. */)
1093 (register Lisp_Object buffer
)
1095 return BVAR (decode_buffer (buffer
), name
);
1098 DEFUN ("buffer-file-name", Fbuffer_file_name
, Sbuffer_file_name
, 0, 1, 0,
1099 doc
: /* Return name of file BUFFER is visiting, or nil if none.
1100 No argument or nil as argument means use the current buffer. */)
1101 (register Lisp_Object buffer
)
1103 return BVAR (decode_buffer (buffer
), filename
);
1106 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer
, Sbuffer_base_buffer
,
1108 doc
: /* Return the base buffer of indirect buffer BUFFER.
1109 If BUFFER is not indirect, return nil.
1110 BUFFER defaults to the current buffer. */)
1111 (register Lisp_Object buffer
)
1113 struct buffer
*base
= decode_buffer (buffer
)->base_buffer
;
1114 return base
? (XSETBUFFER (buffer
, base
), buffer
) : Qnil
;
1117 DEFUN ("buffer-local-value", Fbuffer_local_value
,
1118 Sbuffer_local_value
, 2, 2, 0,
1119 doc
: /* Return the value of VARIABLE in BUFFER.
1120 If VARIABLE does not have a buffer-local binding in BUFFER, the value
1121 is the default binding of the variable. */)
1122 (register Lisp_Object variable
, register Lisp_Object buffer
)
1124 register Lisp_Object result
= buffer_local_value (variable
, buffer
);
1126 if (EQ (result
, Qunbound
))
1127 xsignal1 (Qvoid_variable
, variable
);
1133 /* Like Fbuffer_local_value, but return Qunbound if the variable is
1137 buffer_local_value (Lisp_Object variable
, Lisp_Object buffer
)
1139 register struct buffer
*buf
;
1140 register Lisp_Object result
;
1141 struct Lisp_Symbol
*sym
;
1143 CHECK_SYMBOL (variable
);
1144 CHECK_BUFFER (buffer
);
1145 buf
= XBUFFER (buffer
);
1146 sym
= XSYMBOL (variable
);
1149 switch (sym
->redirect
)
1151 case SYMBOL_VARALIAS
: sym
= indirect_variable (sym
); goto start
;
1152 case SYMBOL_PLAINVAL
: result
= SYMBOL_VAL (sym
); break;
1153 case SYMBOL_LOCALIZED
:
1154 { /* Look in local_var_alist. */
1155 struct Lisp_Buffer_Local_Value
*blv
= SYMBOL_BLV (sym
);
1156 XSETSYMBOL (variable
, sym
); /* Update In case of aliasing. */
1157 result
= Fassoc (variable
, BVAR (buf
, local_var_alist
));
1161 { /* What binding is loaded right now? */
1162 Lisp_Object current_alist_element
= blv
->valcell
;
1164 /* The value of the currently loaded binding is not
1165 stored in it, but rather in the realvalue slot.
1166 Store that value into the binding it belongs to
1167 in case that is the one we are about to use. */
1169 XSETCDR (current_alist_element
,
1170 do_symval_forwarding (blv
->fwd
));
1172 /* Now get the (perhaps updated) value out of the binding. */
1173 result
= XCDR (result
);
1176 result
= Fdefault_value (variable
);
1179 case SYMBOL_FORWARDED
:
1181 union Lisp_Fwd
*fwd
= SYMBOL_FWD (sym
);
1182 if (BUFFER_OBJFWDP (fwd
))
1183 result
= per_buffer_value (buf
, XBUFFER_OBJFWD (fwd
)->offset
);
1185 result
= Fdefault_value (variable
);
1188 default: emacs_abort ();
1194 /* Return an alist of the Lisp-level buffer-local bindings of
1195 buffer BUF. That is, don't include the variables maintained
1196 in special slots in the buffer object.
1197 If not CLONE, replace elements of the form (VAR . unbound)
1201 buffer_lisp_local_variables (struct buffer
*buf
, bool clone
)
1203 Lisp_Object result
= Qnil
;
1205 for (tail
= BVAR (buf
, local_var_alist
); CONSP (tail
); tail
= XCDR (tail
))
1207 Lisp_Object val
, elt
;
1211 /* Reference each variable in the alist in buf.
1212 If inquiring about the current buffer, this gets the current values,
1213 so store them into the alist so the alist is up to date.
1214 If inquiring about some other buffer, this swaps out any values
1215 for that buffer, making the alist up to date automatically. */
1216 val
= find_symbol_value (XCAR (elt
));
1217 /* Use the current buffer value only if buf is the current buffer. */
1218 if (buf
!= current_buffer
)
1221 result
= Fcons (!clone
&& EQ (val
, Qunbound
)
1223 : Fcons (XCAR (elt
), val
),
1230 DEFUN ("buffer-local-variables", Fbuffer_local_variables
,
1231 Sbuffer_local_variables
, 0, 1, 0,
1232 doc
: /* Return an alist of variables that are buffer-local in BUFFER.
1233 Most elements look like (SYMBOL . VALUE), describing one variable.
1234 For a symbol that is locally unbound, just the symbol appears in the value.
1235 Note that storing new VALUEs in these elements doesn't change the variables.
1236 No argument or nil as argument means use current buffer as BUFFER. */)
1237 (Lisp_Object buffer
)
1239 struct buffer
*buf
= decode_buffer (buffer
);
1240 Lisp_Object result
= buffer_lisp_local_variables (buf
, 0);
1242 /* Add on all the variables stored in special slots. */
1246 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
1248 idx
= PER_BUFFER_IDX (offset
);
1249 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
1250 && SYMBOLP (PER_BUFFER_SYMBOL (offset
)))
1252 Lisp_Object sym
= PER_BUFFER_SYMBOL (offset
);
1253 Lisp_Object val
= per_buffer_value (buf
, offset
);
1254 result
= Fcons (EQ (val
, Qunbound
) ? sym
: Fcons (sym
, val
),
1263 DEFUN ("buffer-modified-p", Fbuffer_modified_p
, Sbuffer_modified_p
,
1265 doc
: /* Return t if BUFFER was modified since its file was last read or saved.
1266 No argument or nil as argument means use current buffer as BUFFER. */)
1267 (Lisp_Object buffer
)
1269 struct buffer
*buf
= decode_buffer (buffer
);
1270 return BUF_SAVE_MODIFF (buf
) < BUF_MODIFF (buf
) ? Qt
: Qnil
;
1273 DEFUN ("force-mode-line-update", Fforce_mode_line_update
,
1274 Sforce_mode_line_update
, 0, 1, 0,
1275 doc
: /* Force redisplay of the current buffer's mode line and header line.
1276 With optional non-nil ALL, force redisplay of all mode lines and
1277 header lines. This function also forces recomputation of the
1278 menu bar menus and the frame title. */)
1283 update_mode_lines
= 10;
1284 /* FIXME: This can't be right. */
1285 current_buffer
->prevent_redisplay_optimizations_p
= true;
1287 else if (buffer_window_count (current_buffer
))
1289 bset_update_mode_line (current_buffer
);
1290 current_buffer
->prevent_redisplay_optimizations_p
= true;
1295 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p
, Sset_buffer_modified_p
,
1297 doc
: /* Mark current buffer as modified or unmodified according to FLAG.
1298 A non-nil FLAG means mark the buffer modified. */)
1301 Frestore_buffer_modified_p (flag
);
1303 /* Set update_mode_lines only if buffer is displayed in some window.
1304 Packages like jit-lock or lazy-lock preserve a buffer's modified
1305 state by recording/restoring the state around blocks of code.
1306 Setting update_mode_lines makes redisplay consider all windows
1307 (on all frames). Stealth fontification of buffers not displayed
1308 would incur additional redisplay costs if we'd set
1309 update_modes_lines unconditionally.
1311 Ideally, I think there should be another mechanism for fontifying
1312 buffers without "modifying" buffers, or redisplay should be
1313 smarter about updating the `*' in mode lines. --gerd */
1314 return Fforce_mode_line_update (Qnil
);
1317 DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p
,
1318 Srestore_buffer_modified_p
, 1, 1, 0,
1319 doc
: /* Like `set-buffer-modified-p', with a difference concerning redisplay.
1320 It is not ensured that mode lines will be updated to show the modified
1321 state of the current buffer. Use with care. */)
1326 /* If buffer becoming modified, lock the file.
1327 If buffer becoming unmodified, unlock the file. */
1329 struct buffer
*b
= current_buffer
->base_buffer
1330 ? current_buffer
->base_buffer
1333 fn
= BVAR (b
, file_truename
);
1334 /* Test buffer-file-name so that binding it to nil is effective. */
1335 if (!NILP (fn
) && ! NILP (BVAR (b
, filename
)))
1337 bool already
= SAVE_MODIFF
< MODIFF
;
1338 if (!already
&& !NILP (flag
))
1340 else if (already
&& NILP (flag
))
1344 /* Here we have a problem. SAVE_MODIFF is used here to encode
1345 buffer-modified-p (as SAVE_MODIFF<MODIFF) as well as
1346 recent-auto-save-p (as SAVE_MODIFF<auto_save_modified). So if we
1347 modify SAVE_MODIFF to affect one, we may affect the other
1349 E.g. if FLAG is nil we need to set SAVE_MODIFF to MODIFF, but
1350 if SAVE_MODIFF<auto_save_modified that means we risk changing
1351 recent-auto-save-p from t to nil.
1352 Vice versa, if FLAG is non-nil and SAVE_MODIFF>=auto_save_modified
1353 we risk changing recent-auto-save-p from nil to t. */
1354 SAVE_MODIFF
= (NILP (flag
)
1355 /* FIXME: This unavoidably sets recent-auto-save-p to nil. */
1357 /* Let's try to preserve recent-auto-save-p. */
1358 : SAVE_MODIFF
< MODIFF
? SAVE_MODIFF
1359 /* If SAVE_MODIFF == auto_save_modified == MODIFF,
1360 we can either decrease SAVE_MODIFF and auto_save_modified
1361 or increase MODIFF. */
1367 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick
, Sbuffer_modified_tick
,
1369 doc
: /* Return BUFFER's tick counter, incremented for each change in text.
1370 Each buffer has a tick counter which is incremented each time the
1371 text in that buffer is changed. It wraps around occasionally.
1372 No argument or nil as argument means use current buffer as BUFFER. */)
1373 (register Lisp_Object buffer
)
1375 return make_number (BUF_MODIFF (decode_buffer (buffer
)));
1378 DEFUN ("buffer-chars-modified-tick", Fbuffer_chars_modified_tick
,
1379 Sbuffer_chars_modified_tick
, 0, 1, 0,
1380 doc
: /* Return BUFFER's character-change tick counter.
1381 Each buffer has a character-change tick counter, which is set to the
1382 value of the buffer's tick counter (see `buffer-modified-tick'), each
1383 time text in that buffer is inserted or deleted. By comparing the
1384 values returned by two individual calls of `buffer-chars-modified-tick',
1385 you can tell whether a character change occurred in that buffer in
1386 between these calls. No argument or nil as argument means use current
1387 buffer as BUFFER. */)
1388 (register Lisp_Object buffer
)
1390 return make_number (BUF_CHARS_MODIFF (decode_buffer (buffer
)));
1393 DEFUN ("rename-buffer", Frename_buffer
, Srename_buffer
, 1, 2,
1394 "(list (read-string \"Rename buffer (to new name): \" \
1395 nil 'buffer-name-history (buffer-name (current-buffer))) \
1396 current-prefix-arg)",
1397 doc
: /* Change current buffer's name to NEWNAME (a string).
1398 If second arg UNIQUE is nil or omitted, it is an error if a
1399 buffer named NEWNAME already exists.
1400 If UNIQUE is non-nil, come up with a new name using
1401 `generate-new-buffer-name'.
1402 Interactively, you can set UNIQUE with a prefix argument.
1403 We return the name we actually gave the buffer.
1404 This does not change the name of the visited file (if any). */)
1405 (register Lisp_Object newname
, Lisp_Object unique
)
1407 register Lisp_Object tem
, buf
;
1409 CHECK_STRING (newname
);
1411 if (SCHARS (newname
) == 0)
1412 error ("Empty string is invalid as a buffer name");
1414 tem
= Fget_buffer (newname
);
1417 /* Don't short-circuit if UNIQUE is t. That is a useful way to
1418 rename the buffer automatically so you can create another
1419 with the original name. It makes UNIQUE equivalent to
1420 (rename-buffer (generate-new-buffer-name NEWNAME)). */
1421 if (NILP (unique
) && XBUFFER (tem
) == current_buffer
)
1422 return BVAR (current_buffer
, name
);
1424 newname
= Fgenerate_new_buffer_name (newname
, BVAR (current_buffer
, name
));
1426 error ("Buffer name `%s' is in use", SDATA (newname
));
1429 bset_name (current_buffer
, newname
);
1431 /* Catch redisplay's attention. Unless we do this, the mode lines for
1432 any windows displaying current_buffer will stay unchanged. */
1433 update_mode_lines
= 11;
1435 XSETBUFFER (buf
, current_buffer
);
1436 Fsetcar (Frassq (buf
, Vbuffer_alist
), newname
);
1437 if (NILP (BVAR (current_buffer
, filename
))
1438 && !NILP (BVAR (current_buffer
, auto_save_file_name
)))
1439 call0 (intern ("rename-auto-save-file"));
1441 /* Run buffer-list-update-hook. */
1442 if (!NILP (Vrun_hooks
))
1443 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1445 /* Refetch since that last call may have done GC. */
1446 return BVAR (current_buffer
, name
);
1449 /* True if B can be used as 'other-than-BUFFER' buffer. */
1452 candidate_buffer (Lisp_Object b
, Lisp_Object buffer
)
1454 return (BUFFERP (b
) && !EQ (b
, buffer
)
1455 && BUFFER_LIVE_P (XBUFFER (b
))
1456 && !BUFFER_HIDDEN_P (XBUFFER (b
)));
1459 DEFUN ("other-buffer", Fother_buffer
, Sother_buffer
, 0, 3, 0,
1460 doc
: /* Return most recently selected buffer other than BUFFER.
1461 Buffers not visible in windows are preferred to visible buffers, unless
1462 optional second argument VISIBLE-OK is non-nil. Ignore the argument
1463 BUFFER unless it denotes a live buffer. If the optional third argument
1464 FRAME specifies a live frame, then use that frame's buffer list instead
1465 of the selected frame's buffer list.
1467 The buffer is found by scanning the selected or specified frame's buffer
1468 list first, followed by the list of all buffers. If no other buffer
1469 exists, return the buffer `*scratch*' (creating it if necessary). */)
1470 (Lisp_Object buffer
, Lisp_Object visible_ok
, Lisp_Object frame
)
1472 struct frame
*f
= decode_live_frame (frame
);
1473 Lisp_Object tail
= f
->buffer_list
, pred
= f
->buffer_predicate
;
1474 Lisp_Object buf
, notsogood
= Qnil
;
1476 /* Consider buffers that have been seen in the frame first. */
1477 for (; CONSP (tail
); tail
= XCDR (tail
))
1480 if (candidate_buffer (buf
, buffer
)
1481 /* If the frame has a buffer_predicate, disregard buffers that
1482 don't fit the predicate. */
1483 && (NILP (pred
) || !NILP (call1 (pred
, buf
))))
1485 if (!NILP (visible_ok
)
1486 || NILP (Fget_buffer_window (buf
, Qvisible
)))
1488 else if (NILP (notsogood
))
1493 /* Consider alist of all buffers next. */
1494 FOR_EACH_LIVE_BUFFER (tail
, buf
)
1496 if (candidate_buffer (buf
, buffer
)
1497 /* If the frame has a buffer_predicate, disregard buffers that
1498 don't fit the predicate. */
1499 && (NILP (pred
) || !NILP (call1 (pred
, buf
))))
1501 if (!NILP (visible_ok
)
1502 || NILP (Fget_buffer_window (buf
, Qvisible
)))
1504 else if (NILP (notsogood
))
1509 if (!NILP (notsogood
))
1513 AUTO_STRING (scratch
, "*scratch*");
1514 buf
= Fget_buffer (scratch
);
1517 buf
= Fget_buffer_create (scratch
);
1518 Fset_buffer_major_mode (buf
);
1524 /* The following function is a safe variant of Fother_buffer: It doesn't
1525 pay attention to any frame-local buffer lists, doesn't care about
1526 visibility of buffers, and doesn't evaluate any frame predicates. */
1529 other_buffer_safely (Lisp_Object buffer
)
1531 Lisp_Object tail
, buf
;
1533 FOR_EACH_LIVE_BUFFER (tail
, buf
)
1534 if (candidate_buffer (buf
, buffer
))
1537 AUTO_STRING (scratch
, "*scratch*");
1538 buf
= Fget_buffer (scratch
);
1541 buf
= Fget_buffer_create (scratch
);
1542 Fset_buffer_major_mode (buf
);
1548 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo
, Sbuffer_enable_undo
,
1550 doc
: /* Start keeping undo information for buffer BUFFER.
1551 No argument or nil as argument means do this for the current buffer. */)
1552 (register Lisp_Object buffer
)
1554 Lisp_Object real_buffer
;
1557 XSETBUFFER (real_buffer
, current_buffer
);
1560 real_buffer
= Fget_buffer (buffer
);
1561 if (NILP (real_buffer
))
1565 if (EQ (BVAR (XBUFFER (real_buffer
), undo_list
), Qt
))
1566 bset_undo_list (XBUFFER (real_buffer
), Qnil
);
1571 /* Truncate undo list and shrink the gap of BUFFER. */
1574 compact_buffer (struct buffer
*buffer
)
1576 BUFFER_CHECK_INDIRECTION (buffer
);
1578 /* Skip dead buffers, indirect buffers and buffers
1579 which aren't changed since last compaction. */
1580 if (BUFFER_LIVE_P (buffer
)
1581 && (buffer
->base_buffer
== NULL
)
1582 && (BUF_COMPACT (buffer
) != BUF_MODIFF (buffer
)))
1584 /* If a buffer's undo list is Qt, that means that undo is
1585 turned off in that buffer. Calling truncate_undo_list on
1586 Qt tends to return NULL, which effectively turns undo back on.
1587 So don't call truncate_undo_list if undo_list is Qt. */
1588 if (!EQ (BVAR(buffer
, undo_list
), Qt
))
1589 truncate_undo_list (buffer
);
1591 /* Shrink buffer gaps. */
1592 if (!buffer
->text
->inhibit_shrinking
)
1594 /* If a buffer's gap size is more than 10% of the buffer
1595 size, or larger than GAP_BYTES_DFL bytes, then shrink it
1596 accordingly. Keep a minimum size of GAP_BYTES_MIN bytes. */
1597 ptrdiff_t size
= clip_to_bounds (GAP_BYTES_MIN
,
1598 BUF_Z_BYTE (buffer
) / 10,
1600 if (BUF_GAP_SIZE (buffer
) > size
)
1601 make_gap_1 (buffer
, -(BUF_GAP_SIZE (buffer
) - size
));
1603 BUF_COMPACT (buffer
) = BUF_MODIFF (buffer
);
1607 DEFUN ("kill-buffer", Fkill_buffer
, Skill_buffer
, 0, 1, "bKill buffer: ",
1608 doc
: /* Kill the buffer specified by BUFFER-OR-NAME.
1609 The argument may be a buffer or the name of an existing buffer.
1610 Argument nil or omitted means kill the current buffer. Return t if the
1611 buffer is actually killed, nil otherwise.
1613 The functions in `kill-buffer-query-functions' are called with the
1614 buffer to be killed as the current buffer. If any of them returns nil,
1615 the buffer is not killed. The hook `kill-buffer-hook' is run before the
1616 buffer is actually killed. The buffer being killed will be current
1617 while the hook is running. Functions called by any of these hooks are
1618 supposed to not change the current buffer.
1620 Any processes that have this buffer as the `process-buffer' are killed
1621 with SIGHUP. This function calls `replace-buffer-in-windows' for
1622 cleaning up all windows currently displaying the buffer to be killed. */)
1623 (Lisp_Object buffer_or_name
)
1628 struct Lisp_Marker
*m
;
1630 if (NILP (buffer_or_name
))
1631 buffer
= Fcurrent_buffer ();
1633 buffer
= Fget_buffer (buffer_or_name
);
1635 nsberror (buffer_or_name
);
1637 b
= XBUFFER (buffer
);
1639 /* Avoid trouble for buffer already dead. */
1640 if (!BUFFER_LIVE_P (b
))
1643 /* Run hooks with the buffer to be killed the current buffer. */
1645 ptrdiff_t count
= SPECPDL_INDEX ();
1647 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1648 set_buffer_internal (b
);
1650 /* First run the query functions; if any query is answered no,
1651 don't kill the buffer. */
1652 tem
= CALLN (Frun_hook_with_args_until_failure
,
1653 Qkill_buffer_query_functions
);
1655 return unbind_to (count
, Qnil
);
1657 /* Query if the buffer is still modified. */
1658 if (INTERACTIVE
&& !NILP (BVAR (b
, filename
))
1659 && BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
1661 AUTO_STRING (format
, "Buffer %s modified; kill anyway? ");
1662 tem
= do_yes_or_no_p (CALLN (Fformat
, format
, BVAR (b
, name
)));
1664 return unbind_to (count
, Qnil
);
1667 /* If the hooks have killed the buffer, exit now. */
1668 if (!BUFFER_LIVE_P (b
))
1669 return unbind_to (count
, Qt
);
1671 /* Then run the hooks. */
1672 run_hook (Qkill_buffer_hook
);
1673 unbind_to (count
, Qnil
);
1676 /* If the hooks have killed the buffer, exit now. */
1677 if (!BUFFER_LIVE_P (b
))
1680 /* We have no more questions to ask. Verify that it is valid
1681 to kill the buffer. This must be done after the questions
1682 since anything can happen within do_yes_or_no_p. */
1684 /* Don't kill the minibuffer now current. */
1685 if (EQ (buffer
, XWINDOW (minibuf_window
)->contents
))
1688 /* When we kill an ordinary buffer which shares it's buffer text
1689 with indirect buffer(s), we must kill indirect buffer(s) too.
1690 We do it at this stage so nothing terrible happens if they
1691 ask questions or their hooks get errors. */
1692 if (!b
->base_buffer
&& b
->indirections
> 0)
1694 struct buffer
*other
;
1696 FOR_EACH_BUFFER (other
)
1697 if (other
->base_buffer
== b
)
1700 XSETBUFFER (buf
, other
);
1704 /* Exit if we now have killed the base buffer (Bug#11665). */
1705 if (!BUFFER_LIVE_P (b
))
1709 /* Run replace_buffer_in_windows before making another buffer current
1710 since set-window-buffer-start-and-point will refuse to make another
1711 buffer current if the selected window does not show the current
1712 buffer (bug#10114). */
1713 replace_buffer_in_windows (buffer
);
1715 /* Exit if replacing the buffer in windows has killed our buffer. */
1716 if (!BUFFER_LIVE_P (b
))
1719 /* Make this buffer not be current. Exit if it is the sole visible
1721 if (b
== current_buffer
)
1723 tem
= Fother_buffer (buffer
, Qnil
, Qnil
);
1725 if (b
== current_buffer
)
1729 /* If the buffer now current is shown in the minibuffer and our buffer
1730 is the sole other buffer give up. */
1731 XSETBUFFER (tem
, current_buffer
);
1732 if (EQ (tem
, XWINDOW (minibuf_window
)->contents
)
1733 && EQ (buffer
, Fother_buffer (buffer
, Qnil
, Qnil
)))
1736 /* Now there is no question: we can kill the buffer. */
1738 /* Unlock this buffer's file, if it is locked. */
1741 kill_buffer_processes (buffer
);
1742 kill_buffer_xwidgets (buffer
);
1744 /* Killing buffer processes may run sentinels which may have killed
1746 if (!BUFFER_LIVE_P (b
))
1749 /* These may run Lisp code and into infinite loops (if someone
1750 insisted on circular lists) so allow quitting here. */
1751 frames_discard_buffer (buffer
);
1753 clear_charpos_cache (b
);
1755 tem
= Vinhibit_quit
;
1757 /* Remove the buffer from the list of all buffers. */
1758 Vbuffer_alist
= Fdelq (Frassq (buffer
, Vbuffer_alist
), Vbuffer_alist
);
1759 /* If replace_buffer_in_windows didn't do its job fix that now. */
1760 replace_buffer_in_windows_safely (buffer
);
1761 Vinhibit_quit
= tem
;
1763 /* Delete any auto-save file, if we saved it in this session.
1764 But not if the buffer is modified. */
1765 if (STRINGP (BVAR (b
, auto_save_file_name
))
1766 && BUF_AUTOSAVE_MODIFF (b
) != 0
1767 && BUF_SAVE_MODIFF (b
) < BUF_AUTOSAVE_MODIFF (b
)
1768 && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
)
1769 && NILP (Fsymbol_value (intern ("auto-save-visited-file-name"))))
1772 delete = Fsymbol_value (intern ("delete-auto-save-files"));
1773 if (! NILP (delete))
1774 internal_delete_file (BVAR (b
, auto_save_file_name
));
1777 /* Deleting an auto-save file could have killed our buffer. */
1778 if (!BUFFER_LIVE_P (b
))
1784 /* Unchain all markers that belong to this indirect buffer.
1785 Don't unchain the markers that belong to the base buffer
1786 or its other indirect buffers. */
1787 struct Lisp_Marker
**mp
= &BUF_MARKERS (b
);
1798 /* Intervals should be owned by the base buffer (Bug#16502). */
1799 i
= buffer_intervals (b
);
1803 XSETBUFFER (owner
, b
->base_buffer
);
1804 set_interval_object (i
, owner
);
1809 /* Unchain all markers of this buffer and its indirect buffers.
1810 and leave them pointing nowhere. */
1811 for (m
= BUF_MARKERS (b
); m
; )
1813 struct Lisp_Marker
*next
= m
->next
;
1818 BUF_MARKERS (b
) = NULL
;
1819 set_buffer_intervals (b
, NULL
);
1821 /* Perhaps we should explicitly free the interval tree here... */
1823 /* Since we've unlinked the markers, the overlays can't be here any more
1825 b
->overlays_before
= NULL
;
1826 b
->overlays_after
= NULL
;
1828 /* Reset the local variables, so that this buffer's local values
1829 won't be protected from GC. They would be protected
1830 if they happened to remain cached in their symbols.
1831 This gets rid of them for certain. */
1832 swap_out_buffer_local_variables (b
);
1833 reset_buffer_local_variables (b
, 1);
1835 bset_name (b
, Qnil
);
1840 /* Notify our base buffer that we don't share the text anymore. */
1841 eassert (b
->indirections
== -1);
1842 b
->base_buffer
->indirections
--;
1843 eassert (b
->base_buffer
->indirections
>= 0);
1844 /* Make sure that we wasn't confused. */
1845 eassert (b
->window_count
== -1);
1849 /* Make sure that no one shows us. */
1850 eassert (b
->window_count
== 0);
1851 /* No one shares our buffer text, can free it. */
1852 free_buffer_text (b
);
1855 if (b
->newline_cache
)
1857 free_region_cache (b
->newline_cache
);
1858 b
->newline_cache
= 0;
1860 if (b
->width_run_cache
)
1862 free_region_cache (b
->width_run_cache
);
1863 b
->width_run_cache
= 0;
1865 if (b
->bidi_paragraph_cache
)
1867 free_region_cache (b
->bidi_paragraph_cache
);
1868 b
->bidi_paragraph_cache
= 0;
1870 bset_width_table (b
, Qnil
);
1872 bset_undo_list (b
, Qnil
);
1874 /* Run buffer-list-update-hook. */
1875 if (!NILP (Vrun_hooks
))
1876 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1881 /* Move association for BUFFER to the front of buffer (a)lists. Since
1882 we do this each time BUFFER is selected visibly, the more recently
1883 selected buffers are always closer to the front of those lists. This
1884 means that other_buffer is more likely to choose a relevant buffer.
1886 Note that this moves BUFFER to the front of the buffer lists of the
1887 selected frame even if BUFFER is not shown there. If BUFFER is not
1888 shown in the selected frame, consider the present behavior a feature.
1889 `select-window' gets this right since it shows BUFFER in the selected
1890 window when calling us. */
1893 record_buffer (Lisp_Object buffer
)
1895 Lisp_Object aelt
, aelt_cons
, tem
;
1896 register struct frame
*f
= XFRAME (selected_frame
);
1898 CHECK_BUFFER (buffer
);
1900 /* Update Vbuffer_alist (we know that it has an entry for BUFFER).
1901 Don't allow quitting since this might leave the buffer list in an
1902 inconsistent state. */
1903 tem
= Vinhibit_quit
;
1905 aelt
= Frassq (buffer
, Vbuffer_alist
);
1906 aelt_cons
= Fmemq (aelt
, Vbuffer_alist
);
1907 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
1908 XSETCDR (aelt_cons
, Vbuffer_alist
);
1909 Vbuffer_alist
= aelt_cons
;
1910 Vinhibit_quit
= tem
;
1912 /* Update buffer list of selected frame. */
1913 fset_buffer_list (f
, Fcons (buffer
, Fdelq (buffer
, f
->buffer_list
)));
1914 fset_buried_buffer_list (f
, Fdelq (buffer
, f
->buried_buffer_list
));
1916 /* Run buffer-list-update-hook. */
1917 if (!NILP (Vrun_hooks
))
1918 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1922 /* Move BUFFER to the end of the buffer (a)lists. Do nothing if the
1923 buffer is killed. For the selected frame's buffer list this moves
1924 BUFFER to its end even if it was never shown in that frame. If
1925 this happens we have a feature, hence `bury-buffer-internal' should be
1926 called only when BUFFER was shown in the selected frame. */
1928 DEFUN ("bury-buffer-internal", Fbury_buffer_internal
, Sbury_buffer_internal
,
1930 doc
: /* Move BUFFER to the end of the buffer list. */)
1931 (Lisp_Object buffer
)
1933 Lisp_Object aelt
, aelt_cons
, tem
;
1934 register struct frame
*f
= XFRAME (selected_frame
);
1936 CHECK_BUFFER (buffer
);
1938 /* Update Vbuffer_alist (we know that it has an entry for BUFFER).
1939 Don't allow quitting since this might leave the buffer list in an
1940 inconsistent state. */
1941 tem
= Vinhibit_quit
;
1943 aelt
= Frassq (buffer
, Vbuffer_alist
);
1944 aelt_cons
= Fmemq (aelt
, Vbuffer_alist
);
1945 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
1946 XSETCDR (aelt_cons
, Qnil
);
1947 Vbuffer_alist
= nconc2 (Vbuffer_alist
, aelt_cons
);
1948 Vinhibit_quit
= tem
;
1950 /* Update buffer lists of selected frame. */
1951 fset_buffer_list (f
, Fdelq (buffer
, f
->buffer_list
));
1952 fset_buried_buffer_list
1953 (f
, Fcons (buffer
, Fdelq (buffer
, f
->buried_buffer_list
)));
1955 /* Run buffer-list-update-hook. */
1956 if (!NILP (Vrun_hooks
))
1957 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1962 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode
, Sset_buffer_major_mode
, 1, 1, 0,
1963 doc
: /* Set an appropriate major mode for BUFFER.
1964 For the *scratch* buffer, use `initial-major-mode', otherwise choose a mode
1965 according to the default value of `major-mode'.
1966 Use this function before selecting the buffer, since it may need to inspect
1967 the current buffer's major mode. */)
1968 (Lisp_Object buffer
)
1971 Lisp_Object function
;
1973 CHECK_BUFFER (buffer
);
1975 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
1976 error ("Attempt to set major mode for a dead buffer");
1978 if (strcmp (SSDATA (BVAR (XBUFFER (buffer
), name
)), "*scratch*") == 0)
1979 function
= find_symbol_value (intern ("initial-major-mode"));
1982 function
= BVAR (&buffer_defaults
, major_mode
);
1984 && NILP (Fget (BVAR (current_buffer
, major_mode
), Qmode_class
)))
1985 function
= BVAR (current_buffer
, major_mode
);
1988 if (NILP (function
)) /* If function is `fundamental-mode', allow it to run
1989 so that `run-mode-hooks' and thus
1990 `hack-local-variables' get run. */
1993 count
= SPECPDL_INDEX ();
1995 /* To select a nonfundamental mode,
1996 select the buffer temporarily and then call the mode function. */
1998 record_unwind_current_buffer ();
2000 Fset_buffer (buffer
);
2003 return unbind_to (count
, Qnil
);
2006 DEFUN ("current-buffer", Fcurrent_buffer
, Scurrent_buffer
, 0, 0, 0,
2007 doc
: /* Return the current buffer as a Lisp object. */)
2010 register Lisp_Object buf
;
2011 XSETBUFFER (buf
, current_buffer
);
2015 /* Set the current buffer to B, and do not set windows_or_buffers_changed.
2016 This is used by redisplay. */
2019 set_buffer_internal_1 (register struct buffer
*b
)
2021 register struct buffer
*old_buf
;
2022 register Lisp_Object tail
;
2024 #ifdef USE_MMAP_FOR_BUFFERS
2025 if (b
->text
->beg
== NULL
)
2026 enlarge_buffer_text (b
, 0);
2027 #endif /* USE_MMAP_FOR_BUFFERS */
2029 if (current_buffer
== b
)
2032 BUFFER_CHECK_INDIRECTION (b
);
2034 old_buf
= current_buffer
;
2036 last_known_column_point
= -1; /* Invalidate indentation cache. */
2040 /* Put the undo list back in the base buffer, so that it appears
2041 that an indirect buffer shares the undo list of its base. */
2042 if (old_buf
->base_buffer
)
2043 bset_undo_list (old_buf
->base_buffer
, BVAR (old_buf
, undo_list
));
2045 /* If the old current buffer has markers to record PT, BEGV and ZV
2046 when it is not current, update them now. */
2047 record_buffer_markers (old_buf
);
2050 /* Get the undo list from the base buffer, so that it appears
2051 that an indirect buffer shares the undo list of its base. */
2053 bset_undo_list (b
, BVAR (b
->base_buffer
, undo_list
));
2055 /* If the new current buffer has markers to record PT, BEGV and ZV
2056 when it is not current, fetch them now. */
2057 fetch_buffer_markers (b
);
2059 /* Look down buffer's list of local Lisp variables
2060 to find and update any that forward into C variables. */
2064 for (tail
= BVAR (b
, local_var_alist
); CONSP (tail
); tail
= XCDR (tail
))
2066 Lisp_Object var
= XCAR (XCAR (tail
));
2067 struct Lisp_Symbol
*sym
= XSYMBOL (var
);
2068 if (sym
->redirect
== SYMBOL_LOCALIZED
/* Just to be sure. */
2069 && SYMBOL_BLV (sym
)->fwd
)
2070 /* Just reference the variable
2071 to cause it to become set for this buffer. */
2072 Fsymbol_value (var
);
2075 /* Do the same with any others that were local to the previous buffer */
2076 while (b
!= old_buf
&& (b
= old_buf
, b
));
2079 /* Switch to buffer B temporarily for redisplay purposes.
2080 This avoids certain things that don't need to be done within redisplay. */
2083 set_buffer_temp (struct buffer
*b
)
2085 register struct buffer
*old_buf
;
2087 if (current_buffer
== b
)
2090 old_buf
= current_buffer
;
2093 /* If the old current buffer has markers to record PT, BEGV and ZV
2094 when it is not current, update them now. */
2095 record_buffer_markers (old_buf
);
2097 /* If the new current buffer has markers to record PT, BEGV and ZV
2098 when it is not current, fetch them now. */
2099 fetch_buffer_markers (b
);
2102 DEFUN ("set-buffer", Fset_buffer
, Sset_buffer
, 1, 1, 0,
2103 doc
: /* Make buffer BUFFER-OR-NAME current for editing operations.
2104 BUFFER-OR-NAME may be a buffer or the name of an existing buffer.
2105 See also `with-current-buffer' when you want to make a buffer current
2106 temporarily. This function does not display the buffer, so its effect
2107 ends when the current command terminates. Use `switch-to-buffer' or
2108 `pop-to-buffer' to switch buffers permanently.
2109 The return value is the buffer made current. */)
2110 (register Lisp_Object buffer_or_name
)
2112 register Lisp_Object buffer
;
2113 buffer
= Fget_buffer (buffer_or_name
);
2115 nsberror (buffer_or_name
);
2116 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
2117 error ("Selecting deleted buffer");
2118 set_buffer_internal (XBUFFER (buffer
));
2123 restore_buffer (Lisp_Object buffer_or_name
)
2125 Fset_buffer (buffer_or_name
);
2128 /* Set the current buffer to BUFFER provided if it is alive. */
2131 set_buffer_if_live (Lisp_Object buffer
)
2133 if (BUFFER_LIVE_P (XBUFFER (buffer
)))
2134 set_buffer_internal (XBUFFER (buffer
));
2137 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only
,
2138 Sbarf_if_buffer_read_only
, 0, 1, 0,
2139 doc
: /* Signal a `buffer-read-only' error if the current buffer is read-only.
2140 If the text under POSITION (which defaults to point) has the
2141 `inhibit-read-only' text property set, the error will not be raised. */)
2142 (Lisp_Object position
)
2144 if (NILP (position
))
2145 XSETFASTINT (position
, PT
);
2147 CHECK_NUMBER (position
);
2149 if (!NILP (BVAR (current_buffer
, read_only
))
2150 && NILP (Vinhibit_read_only
)
2151 && NILP (Fget_text_property (position
, Qinhibit_read_only
, Qnil
)))
2152 xsignal1 (Qbuffer_read_only
, Fcurrent_buffer ());
2156 DEFUN ("erase-buffer", Ferase_buffer
, Serase_buffer
, 0, 0, "*",
2157 doc
: /* Delete the entire contents of the current buffer.
2158 Any narrowing restriction in effect (see `narrow-to-region') is removed,
2159 so the buffer is truly empty after this. */)
2166 current_buffer
->last_window_start
= 1;
2167 /* Prevent warnings, or suspension of auto saving, that would happen
2168 if future size is less than past size. Use of erase-buffer
2169 implies that the future text is not really related to the past text. */
2170 XSETFASTINT (BVAR (current_buffer
, save_length
), 0);
2175 validate_region (register Lisp_Object
*b
, register Lisp_Object
*e
)
2177 CHECK_NUMBER_COERCE_MARKER (*b
);
2178 CHECK_NUMBER_COERCE_MARKER (*e
);
2180 if (XINT (*b
) > XINT (*e
))
2183 tem
= *b
; *b
= *e
; *e
= tem
;
2186 if (! (BEGV
<= XINT (*b
) && XINT (*e
) <= ZV
))
2187 args_out_of_range_3 (Fcurrent_buffer (), *b
, *e
);
2190 /* Advance BYTE_POS up to a character boundary
2191 and return the adjusted position. */
2194 advance_to_char_boundary (ptrdiff_t byte_pos
)
2198 if (byte_pos
== BEG
)
2199 /* Beginning of buffer is always a character boundary. */
2202 c
= FETCH_BYTE (byte_pos
);
2203 if (! CHAR_HEAD_P (c
))
2205 /* We should advance BYTE_POS only when C is a constituent of a
2206 multibyte sequence. */
2207 ptrdiff_t orig_byte_pos
= byte_pos
;
2212 c
= FETCH_BYTE (byte_pos
);
2214 while (! CHAR_HEAD_P (c
) && byte_pos
> BEG
);
2216 if (byte_pos
< orig_byte_pos
)
2217 byte_pos
= orig_byte_pos
;
2218 /* If C is a constituent of a multibyte sequence, BYTE_POS was
2219 surely advance to the correct character boundary. If C is
2220 not, BYTE_POS was unchanged. */
2226 DEFUN ("buffer-swap-text", Fbuffer_swap_text
, Sbuffer_swap_text
,
2228 doc
: /* Swap the text between current buffer and BUFFER.
2229 Using this function from `save-excursion' might produce surprising
2230 results, see Info node `(elisp)Swapping Text'. */)
2231 (Lisp_Object buffer
)
2233 struct buffer
*other_buffer
;
2234 CHECK_BUFFER (buffer
);
2235 other_buffer
= XBUFFER (buffer
);
2237 if (!BUFFER_LIVE_P (other_buffer
))
2238 error ("Cannot swap a dead buffer's text");
2240 /* Actually, it probably works just fine.
2241 * if (other_buffer == current_buffer)
2242 * error ("Cannot swap a buffer's text with itself"); */
2244 /* Actually, this may be workable as well, tho probably only if they're
2246 if (other_buffer
->base_buffer
2247 || current_buffer
->base_buffer
)
2248 error ("Cannot swap indirect buffers's text");
2250 { /* This is probably harder to make work. */
2251 struct buffer
*other
;
2252 FOR_EACH_BUFFER (other
)
2253 if (other
->base_buffer
== other_buffer
2254 || other
->base_buffer
== current_buffer
)
2255 error ("One of the buffers to swap has indirect buffers");
2258 #define swapfield(field, type) \
2260 type tmp##field = other_buffer->field; \
2261 other_buffer->field = current_buffer->field; \
2262 current_buffer->field = tmp##field; \
2264 #define swapfield_(field, type) \
2266 type tmp##field = BVAR (other_buffer, field); \
2267 bset_##field (other_buffer, BVAR (current_buffer, field)); \
2268 bset_##field (current_buffer, tmp##field); \
2271 swapfield (own_text
, struct buffer_text
);
2272 eassert (current_buffer
->text
== ¤t_buffer
->own_text
);
2273 eassert (other_buffer
->text
== &other_buffer
->own_text
);
2275 r_alloc_reset_variable ((void **) ¤t_buffer
->own_text
.beg
,
2276 (void **) &other_buffer
->own_text
.beg
);
2277 r_alloc_reset_variable ((void **) &other_buffer
->own_text
.beg
,
2278 (void **) ¤t_buffer
->own_text
.beg
);
2279 #endif /* REL_ALLOC */
2281 swapfield (pt
, ptrdiff_t);
2282 swapfield (pt_byte
, ptrdiff_t);
2283 swapfield (begv
, ptrdiff_t);
2284 swapfield (begv_byte
, ptrdiff_t);
2285 swapfield (zv
, ptrdiff_t);
2286 swapfield (zv_byte
, ptrdiff_t);
2287 eassert (!current_buffer
->base_buffer
);
2288 eassert (!other_buffer
->base_buffer
);
2289 swapfield (indirections
, ptrdiff_t);
2290 current_buffer
->clip_changed
= 1; other_buffer
->clip_changed
= 1;
2291 swapfield (newline_cache
, struct region_cache
*);
2292 swapfield (width_run_cache
, struct region_cache
*);
2293 swapfield (bidi_paragraph_cache
, struct region_cache
*);
2294 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2295 other_buffer
->prevent_redisplay_optimizations_p
= 1;
2296 swapfield (overlays_before
, struct Lisp_Overlay
*);
2297 swapfield (overlays_after
, struct Lisp_Overlay
*);
2298 swapfield (overlay_center
, ptrdiff_t);
2299 swapfield_ (undo_list
, Lisp_Object
);
2300 swapfield_ (mark
, Lisp_Object
);
2301 swapfield_ (enable_multibyte_characters
, Lisp_Object
);
2302 swapfield_ (bidi_display_reordering
, Lisp_Object
);
2303 swapfield_ (bidi_paragraph_direction
, Lisp_Object
);
2304 /* FIXME: Not sure what we should do with these *_marker fields.
2305 Hopefully they're just nil anyway. */
2306 swapfield_ (pt_marker
, Lisp_Object
);
2307 swapfield_ (begv_marker
, Lisp_Object
);
2308 swapfield_ (zv_marker
, Lisp_Object
);
2309 bset_point_before_scroll (current_buffer
, Qnil
);
2310 bset_point_before_scroll (other_buffer
, Qnil
);
2312 current_buffer
->text
->modiff
++; other_buffer
->text
->modiff
++;
2313 current_buffer
->text
->chars_modiff
++; other_buffer
->text
->chars_modiff
++;
2314 current_buffer
->text
->overlay_modiff
++; other_buffer
->text
->overlay_modiff
++;
2315 current_buffer
->text
->beg_unchanged
= current_buffer
->text
->gpt
;
2316 current_buffer
->text
->end_unchanged
= current_buffer
->text
->gpt
;
2317 other_buffer
->text
->beg_unchanged
= other_buffer
->text
->gpt
;
2318 other_buffer
->text
->end_unchanged
= other_buffer
->text
->gpt
;
2320 struct Lisp_Marker
*m
;
2321 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
2322 if (m
->buffer
== other_buffer
)
2323 m
->buffer
= current_buffer
;
2325 /* Since there's no indirect buffer in sight, markers on
2326 BUF_MARKERS(buf) should either be for `buf' or dead. */
2327 eassert (!m
->buffer
);
2328 for (m
= BUF_MARKERS (other_buffer
); m
; m
= m
->next
)
2329 if (m
->buffer
== current_buffer
)
2330 m
->buffer
= other_buffer
;
2332 /* Since there's no indirect buffer in sight, markers on
2333 BUF_MARKERS(buf) should either be for `buf' or dead. */
2334 eassert (!m
->buffer
);
2336 { /* Some of the C code expects that both window markers of a
2337 live window points to that window's buffer. So since we
2338 just swapped the markers between the two buffers, we need
2339 to undo the effect of this swap for window markers. */
2340 Lisp_Object w
= selected_window
, ws
= Qnil
;
2341 Lisp_Object buf1
, buf2
;
2342 XSETBUFFER (buf1
, current_buffer
); XSETBUFFER (buf2
, other_buffer
);
2344 while (NILP (Fmemq (w
, ws
)))
2347 if (MARKERP (XWINDOW (w
)->pointm
)
2348 && (EQ (XWINDOW (w
)->contents
, buf1
)
2349 || EQ (XWINDOW (w
)->contents
, buf2
)))
2350 Fset_marker (XWINDOW (w
)->pointm
,
2352 (BUF_BEGV (XBUFFER (XWINDOW (w
)->contents
))),
2353 XWINDOW (w
)->contents
);
2354 /* Blindly copied from pointm part. */
2355 if (MARKERP (XWINDOW (w
)->old_pointm
)
2356 && (EQ (XWINDOW (w
)->contents
, buf1
)
2357 || EQ (XWINDOW (w
)->contents
, buf2
)))
2358 Fset_marker (XWINDOW (w
)->old_pointm
,
2360 (BUF_BEGV (XBUFFER (XWINDOW (w
)->contents
))),
2361 XWINDOW (w
)->contents
);
2362 if (MARKERP (XWINDOW (w
)->start
)
2363 && (EQ (XWINDOW (w
)->contents
, buf1
)
2364 || EQ (XWINDOW (w
)->contents
, buf2
)))
2365 Fset_marker (XWINDOW (w
)->start
,
2367 (XBUFFER (XWINDOW (w
)->contents
)->last_window_start
),
2368 XWINDOW (w
)->contents
);
2369 w
= Fnext_window (w
, Qt
, Qt
);
2373 if (current_buffer
->text
->intervals
)
2374 (eassert (EQ (current_buffer
->text
->intervals
->up
.obj
, buffer
)),
2375 XSETBUFFER (current_buffer
->text
->intervals
->up
.obj
, current_buffer
));
2376 if (other_buffer
->text
->intervals
)
2377 (eassert (EQ (other_buffer
->text
->intervals
->up
.obj
, Fcurrent_buffer ())),
2378 XSETBUFFER (other_buffer
->text
->intervals
->up
.obj
, other_buffer
));
2383 DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte
, Sset_buffer_multibyte
,
2385 doc
: /* Set the multibyte flag of the current buffer to FLAG.
2386 If FLAG is t, this makes the buffer a multibyte buffer.
2387 If FLAG is nil, this makes the buffer a single-byte buffer.
2388 In these cases, the buffer contents remain unchanged as a sequence of
2389 bytes but the contents viewed as characters do change.
2390 If FLAG is `to', this makes the buffer a multibyte buffer by changing
2391 all eight-bit bytes to eight-bit characters.
2392 If the multibyte flag was really changed, undo information of the
2393 current buffer is cleared. */)
2396 struct Lisp_Marker
*tail
, *markers
;
2397 struct buffer
*other
;
2399 bool narrowed
= (BEG
!= BEGV
|| Z
!= ZV
);
2400 bool modified_p
= !NILP (Fbuffer_modified_p (Qnil
));
2401 Lisp_Object old_undo
= BVAR (current_buffer
, undo_list
);
2403 if (current_buffer
->base_buffer
)
2404 error ("Cannot do `set-buffer-multibyte' on an indirect buffer");
2406 /* Do nothing if nothing actually changes. */
2407 if (NILP (flag
) == NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
2410 /* Don't record these buffer changes. We will put a special undo entry
2412 bset_undo_list (current_buffer
, Qt
);
2414 /* If the cached position is for this buffer, clear it out. */
2415 clear_charpos_cache (current_buffer
);
2418 begv
= BEGV_BYTE
, zv
= ZV_BYTE
;
2420 begv
= BEGV
, zv
= ZV
;
2423 error ("Changing multibyteness in a narrowed buffer");
2425 invalidate_buffer_caches (current_buffer
, BEGV
, ZV
);
2429 ptrdiff_t pos
, stop
;
2432 /* Do this first, so it can use CHAR_TO_BYTE
2433 to calculate the old correspondences. */
2434 set_intervals_multibyte (0);
2436 bset_enable_multibyte_characters (current_buffer
, Qnil
);
2442 TEMP_SET_PT_BOTH (PT_BYTE
, PT_BYTE
);
2445 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
2446 tail
->charpos
= tail
->bytepos
;
2448 /* Convert multibyte form of 8-bit characters to unibyte. */
2463 if (ASCII_CHAR_P (*p
))
2465 else if (CHAR_BYTE8_HEAD_P (*p
))
2467 c
= STRING_CHAR_AND_LENGTH (p
, bytes
);
2468 /* Delete all bytes for this 8-bit character but the
2469 last one, and change the last one to the character
2472 del_range_2 (pos
, pos
, pos
+ bytes
, pos
+ bytes
, 0);
2484 bytes
= BYTES_BY_CHAR_HEAD (*p
);
2485 p
+= bytes
, pos
+= bytes
;
2489 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2494 ptrdiff_t pos
, stop
;
2495 unsigned char *p
, *pend
;
2497 /* Be sure not to have a multibyte sequence striding over the GAP.
2498 Ex: We change this: "...abc\302 _GAP_ \241def..."
2499 to: "...abc _GAP_ \302\241def..." */
2502 && GPT_BYTE
> 1 && GPT_BYTE
< Z_BYTE
2503 && ! CHAR_HEAD_P (*(GAP_END_ADDR
)))
2505 unsigned char *q
= GPT_ADDR
- 1;
2507 while (! CHAR_HEAD_P (*q
) && q
> BEG_ADDR
) q
--;
2508 if (LEADING_CODE_P (*q
))
2510 ptrdiff_t new_gpt
= GPT_BYTE
- (GPT_ADDR
- q
);
2512 move_gap_both (new_gpt
, new_gpt
);
2516 /* Make the buffer contents valid as multibyte by converting
2517 8-bit characters to multibyte form. */
2535 if (ASCII_CHAR_P (*p
))
2537 else if (EQ (flag
, Qt
)
2538 && ! CHAR_BYTE8_HEAD_P (*p
)
2539 && (bytes
= MULTIBYTE_LENGTH (p
, pend
)) > 0)
2540 p
+= bytes
, pos
+= bytes
;
2543 unsigned char tmp
[MAX_MULTIBYTE_LENGTH
];
2546 c
= BYTE8_TO_CHAR (*p
);
2547 bytes
= CHAR_STRING (c
, tmp
);
2549 TEMP_SET_PT_BOTH (pos
+ 1, pos
+ 1);
2551 insert_1_both ((char *) tmp
+ 1, bytes
, bytes
, 1, 0, 0);
2552 /* Now the gap is after the just inserted data. */
2570 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2572 /* Do this first, so that chars_in_text asks the right question.
2573 set_intervals_multibyte needs it too. */
2574 bset_enable_multibyte_characters (current_buffer
, Qt
);
2576 GPT_BYTE
= advance_to_char_boundary (GPT_BYTE
);
2577 GPT
= chars_in_text (BEG_ADDR
, GPT_BYTE
- BEG_BYTE
) + BEG
;
2579 Z
= chars_in_text (GAP_END_ADDR
, Z_BYTE
- GPT_BYTE
) + GPT
;
2581 BEGV_BYTE
= advance_to_char_boundary (BEGV_BYTE
);
2582 if (BEGV_BYTE
> GPT_BYTE
)
2583 BEGV
= chars_in_text (GAP_END_ADDR
, BEGV_BYTE
- GPT_BYTE
) + GPT
;
2585 BEGV
= chars_in_text (BEG_ADDR
, BEGV_BYTE
- BEG_BYTE
) + BEG
;
2587 ZV_BYTE
= advance_to_char_boundary (ZV_BYTE
);
2588 if (ZV_BYTE
> GPT_BYTE
)
2589 ZV
= chars_in_text (GAP_END_ADDR
, ZV_BYTE
- GPT_BYTE
) + GPT
;
2591 ZV
= chars_in_text (BEG_ADDR
, ZV_BYTE
- BEG_BYTE
) + BEG
;
2594 ptrdiff_t byte
= advance_to_char_boundary (PT_BYTE
);
2597 if (byte
> GPT_BYTE
)
2598 position
= chars_in_text (GAP_END_ADDR
, byte
- GPT_BYTE
) + GPT
;
2600 position
= chars_in_text (BEG_ADDR
, byte
- BEG_BYTE
) + BEG
;
2601 TEMP_SET_PT_BOTH (position
, byte
);
2604 tail
= markers
= BUF_MARKERS (current_buffer
);
2606 /* This prevents BYTE_TO_CHAR (that is, buf_bytepos_to_charpos) from
2607 getting confused by the markers that have not yet been updated.
2608 It is also a signal that it should never create a marker. */
2609 BUF_MARKERS (current_buffer
) = NULL
;
2611 for (; tail
; tail
= tail
->next
)
2613 tail
->bytepos
= advance_to_char_boundary (tail
->bytepos
);
2614 tail
->charpos
= BYTE_TO_CHAR (tail
->bytepos
);
2617 /* Make sure no markers were put on the chain
2618 while the chain value was incorrect. */
2619 if (BUF_MARKERS (current_buffer
))
2622 BUF_MARKERS (current_buffer
) = markers
;
2624 /* Do this last, so it can calculate the new correspondences
2625 between chars and bytes. */
2626 set_intervals_multibyte (1);
2629 if (!EQ (old_undo
, Qt
))
2631 /* Represent all the above changes by a special undo entry. */
2632 bset_undo_list (current_buffer
,
2633 Fcons (list3 (Qapply
,
2634 intern ("set-buffer-multibyte"),
2635 NILP (flag
) ? Qt
: Qnil
),
2639 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2641 /* If buffer is shown in a window, let redisplay consider other windows. */
2642 if (buffer_window_count (current_buffer
))
2643 windows_or_buffers_changed
= 10;
2645 /* Copy this buffer's new multibyte status
2646 into all of its indirect buffers. */
2647 FOR_EACH_BUFFER (other
)
2648 if (other
->base_buffer
== current_buffer
&& BUFFER_LIVE_P (other
))
2650 BVAR (other
, enable_multibyte_characters
)
2651 = BVAR (current_buffer
, enable_multibyte_characters
);
2652 other
->prevent_redisplay_optimizations_p
= 1;
2655 /* Restore the modifiedness of the buffer. */
2656 if (!modified_p
&& !NILP (Fbuffer_modified_p (Qnil
)))
2657 Fset_buffer_modified_p (Qnil
);
2659 /* Update coding systems of this buffer's process (if any). */
2661 Lisp_Object process
;
2663 process
= Fget_buffer_process (Fcurrent_buffer ());
2664 if (PROCESSP (process
))
2665 setup_process_coding_systems (process
);
2671 DEFUN ("kill-all-local-variables", Fkill_all_local_variables
,
2672 Skill_all_local_variables
, 0, 0, 0,
2673 doc
: /* Switch to Fundamental mode by killing current buffer's local variables.
2674 Most local variable bindings are eliminated so that the default values
2675 become effective once more. Also, the syntax table is set from
2676 `standard-syntax-table', the local keymap is set to nil,
2677 and the abbrev table from `fundamental-mode-abbrev-table'.
2678 This function also forces redisplay of the mode line.
2680 Every function to select a new major mode starts by
2681 calling this function.
2683 As a special exception, local variables whose names have
2684 a non-nil `permanent-local' property are not eliminated by this function.
2686 The first thing this function does is run
2687 the normal hook `change-major-mode-hook'. */)
2690 run_hook (Qchange_major_mode_hook
);
2692 /* Make sure none of the bindings in local_var_alist
2693 remain swapped in, in their symbols. */
2695 swap_out_buffer_local_variables (current_buffer
);
2697 /* Actually eliminate all local bindings of this buffer. */
2699 reset_buffer_local_variables (current_buffer
, 0);
2701 /* Force mode-line redisplay. Useful here because all major mode
2702 commands call this function. */
2703 update_mode_lines
= 12;
2708 /* Make sure no local variables remain set up with buffer B
2709 for their current values. */
2712 swap_out_buffer_local_variables (struct buffer
*b
)
2714 Lisp_Object oalist
, alist
, buffer
;
2716 XSETBUFFER (buffer
, b
);
2717 oalist
= BVAR (b
, local_var_alist
);
2719 for (alist
= oalist
; CONSP (alist
); alist
= XCDR (alist
))
2721 Lisp_Object sym
= XCAR (XCAR (alist
));
2722 eassert (XSYMBOL (sym
)->redirect
== SYMBOL_LOCALIZED
);
2723 /* Need not do anything if some other buffer's binding is
2725 if (EQ (SYMBOL_BLV (XSYMBOL (sym
))->where
, buffer
))
2727 /* Symbol is set up for this buffer's old local value:
2729 swap_in_global_binding (XSYMBOL (sym
));
2734 /* Find all the overlays in the current buffer that contain position POS.
2735 Return the number found, and store them in a vector in *VEC_PTR.
2736 Store in *LEN_PTR the size allocated for the vector.
2737 Store in *NEXT_PTR the next position after POS where an overlay starts,
2738 or ZV if there are no more overlays between POS and ZV.
2739 Store in *PREV_PTR the previous position before POS where an overlay ends,
2740 or where an overlay starts which ends at or after POS;
2741 or BEGV if there are no such overlays from BEGV to POS.
2742 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2744 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2745 when this function is called.
2747 If EXTEND, make the vector bigger if necessary.
2748 If not, never extend the vector,
2749 and store only as many overlays as will fit.
2750 But still return the total number of overlays.
2752 If CHANGE_REQ, any position written into *PREV_PTR or
2753 *NEXT_PTR is guaranteed to be not equal to POS, unless it is the
2754 default (BEGV or ZV). */
2757 overlays_at (EMACS_INT pos
, bool extend
, Lisp_Object
**vec_ptr
,
2759 ptrdiff_t *next_ptr
, ptrdiff_t *prev_ptr
, bool change_req
)
2761 Lisp_Object overlay
, start
, end
;
2762 struct Lisp_Overlay
*tail
;
2764 ptrdiff_t len
= *len_ptr
;
2765 Lisp_Object
*vec
= *vec_ptr
;
2766 ptrdiff_t next
= ZV
;
2767 ptrdiff_t prev
= BEGV
;
2768 bool inhibit_storing
= 0;
2770 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2772 ptrdiff_t startpos
, endpos
;
2774 XSETMISC (overlay
, tail
);
2776 start
= OVERLAY_START (overlay
);
2777 end
= OVERLAY_END (overlay
);
2778 endpos
= OVERLAY_POSITION (end
);
2785 startpos
= OVERLAY_POSITION (start
);
2786 /* This one ends at or after POS
2787 so its start counts for PREV_PTR if it's before POS. */
2788 if (prev
< startpos
&& startpos
< pos
)
2792 if (startpos
<= pos
)
2796 /* The supplied vector is full.
2797 Either make it bigger, or don't store any more in it. */
2800 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2806 inhibit_storing
= 1;
2809 if (!inhibit_storing
)
2811 /* Keep counting overlays even if we can't return them all. */
2814 else if (startpos
< next
)
2818 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2820 ptrdiff_t startpos
, endpos
;
2822 XSETMISC (overlay
, tail
);
2824 start
= OVERLAY_START (overlay
);
2825 end
= OVERLAY_END (overlay
);
2826 startpos
= OVERLAY_POSITION (start
);
2829 if (startpos
< next
)
2833 endpos
= OVERLAY_POSITION (end
);
2840 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2846 inhibit_storing
= 1;
2849 if (!inhibit_storing
)
2853 if (startpos
< pos
&& startpos
> prev
)
2856 else if (endpos
< pos
&& endpos
> prev
)
2858 else if (endpos
== pos
&& startpos
> prev
2859 && (!change_req
|| startpos
< pos
))
2870 /* Find all the overlays in the current buffer that overlap the range
2871 BEG-END, or are empty at BEG, or are empty at END provided END
2872 denotes the position at the end of the current buffer.
2874 Return the number found, and store them in a vector in *VEC_PTR.
2875 Store in *LEN_PTR the size allocated for the vector.
2876 Store in *NEXT_PTR the next position after POS where an overlay starts,
2877 or ZV if there are no more overlays.
2878 Store in *PREV_PTR the previous position before POS where an overlay ends,
2879 or BEGV if there are no previous overlays.
2880 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2882 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2883 when this function is called.
2885 If EXTEND, make the vector bigger if necessary.
2886 If not, never extend the vector,
2887 and store only as many overlays as will fit.
2888 But still return the total number of overlays. */
2891 overlays_in (EMACS_INT beg
, EMACS_INT end
, bool extend
,
2892 Lisp_Object
**vec_ptr
, ptrdiff_t *len_ptr
,
2893 ptrdiff_t *next_ptr
, ptrdiff_t *prev_ptr
)
2895 Lisp_Object overlay
, ostart
, oend
;
2896 struct Lisp_Overlay
*tail
;
2898 ptrdiff_t len
= *len_ptr
;
2899 Lisp_Object
*vec
= *vec_ptr
;
2900 ptrdiff_t next
= ZV
;
2901 ptrdiff_t prev
= BEGV
;
2902 bool inhibit_storing
= 0;
2903 bool end_is_Z
= end
== Z
;
2905 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2907 ptrdiff_t startpos
, endpos
;
2909 XSETMISC (overlay
, tail
);
2911 ostart
= OVERLAY_START (overlay
);
2912 oend
= OVERLAY_END (overlay
);
2913 endpos
= OVERLAY_POSITION (oend
);
2920 startpos
= OVERLAY_POSITION (ostart
);
2921 /* Count an interval if it overlaps the range, is empty at the
2922 start of the range, or is empty at END provided END denotes the
2923 end of the buffer. */
2924 if ((beg
< endpos
&& startpos
< end
)
2925 || (startpos
== endpos
2926 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
2930 /* The supplied vector is full.
2931 Either make it bigger, or don't store any more in it. */
2934 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2940 inhibit_storing
= 1;
2943 if (!inhibit_storing
)
2945 /* Keep counting overlays even if we can't return them all. */
2948 else if (startpos
< next
)
2952 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2954 ptrdiff_t startpos
, endpos
;
2956 XSETMISC (overlay
, tail
);
2958 ostart
= OVERLAY_START (overlay
);
2959 oend
= OVERLAY_END (overlay
);
2960 startpos
= OVERLAY_POSITION (ostart
);
2963 if (startpos
< next
)
2967 endpos
= OVERLAY_POSITION (oend
);
2968 /* Count an interval if it overlaps the range, is empty at the
2969 start of the range, or is empty at END provided END denotes the
2970 end of the buffer. */
2971 if ((beg
< endpos
&& startpos
< end
)
2972 || (startpos
== endpos
2973 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
2979 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2985 inhibit_storing
= 1;
2988 if (!inhibit_storing
)
2992 else if (endpos
< beg
&& endpos
> prev
)
3004 /* Return true if there exists an overlay with a non-nil
3005 `mouse-face' property overlapping OVERLAY. */
3008 mouse_face_overlay_overlaps (Lisp_Object overlay
)
3010 ptrdiff_t start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3011 ptrdiff_t end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3012 ptrdiff_t n
, i
, size
;
3013 Lisp_Object
*v
, tem
;
3014 Lisp_Object vbuf
[10];
3017 size
= ARRAYELTS (vbuf
);
3019 n
= overlays_in (start
, end
, 0, &v
, &size
, NULL
, NULL
);
3022 SAFE_NALLOCA (v
, 1, n
);
3023 overlays_in (start
, end
, 0, &v
, &n
, NULL
, NULL
);
3026 for (i
= 0; i
< n
; ++i
)
3027 if (!EQ (v
[i
], overlay
)
3028 && (tem
= Foverlay_get (overlay
, Qmouse_face
),
3038 /* Fast function to just test if we're at an overlay boundary. */
3040 overlay_touches_p (ptrdiff_t pos
)
3042 Lisp_Object overlay
;
3043 struct Lisp_Overlay
*tail
;
3045 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
3049 XSETMISC (overlay
,tail
);
3050 eassert (OVERLAYP (overlay
));
3052 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3055 if (endpos
== pos
|| OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
)
3059 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
3063 XSETMISC (overlay
, tail
);
3064 eassert (OVERLAYP (overlay
));
3066 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3069 if (startpos
== pos
|| OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
)
3077 Lisp_Object overlay
;
3080 EMACS_INT spriority
; /* Secondary priority. */
3084 compare_overlays (const void *v1
, const void *v2
)
3086 const struct sortvec
*s1
= v1
;
3087 const struct sortvec
*s2
= v2
;
3088 /* Return 1 if s1 should take precedence, -1 if v2 should take precedence,
3089 and 0 if they're equal. */
3090 if (s1
->priority
!= s2
->priority
)
3091 return s1
->priority
< s2
->priority
? -1 : 1;
3092 /* If the priority is equal, give precedence to the one not covered by the
3093 other. If neither covers the other, obey spriority. */
3094 else if (s1
->beg
< s2
->beg
)
3095 return (s1
->end
< s2
->end
&& s1
->spriority
> s2
->spriority
? 1 : -1);
3096 else if (s1
->beg
> s2
->beg
)
3097 return (s1
->end
> s2
->end
&& s1
->spriority
< s2
->spriority
? -1 : 1);
3098 else if (s1
->end
!= s2
->end
)
3099 return s2
->end
< s1
->end
? -1 : 1;
3100 else if (s1
->spriority
!= s2
->spriority
)
3101 return (s1
->spriority
< s2
->spriority
? -1 : 1);
3102 else if (EQ (s1
->overlay
, s2
->overlay
))
3105 /* Avoid the non-determinism of qsort by choosing an arbitrary ordering
3106 between "equal" overlays. The result can still change between
3107 invocations of Emacs, but it won't change in the middle of
3108 `find_field' (bug#6830). */
3109 return XLI (s1
->overlay
) < XLI (s2
->overlay
) ? -1 : 1;
3112 /* Sort an array of overlays by priority. The array is modified in place.
3113 The return value is the new size; this may be smaller than the original
3114 size if some of the overlays were invalid or were window-specific. */
3116 sort_overlays (Lisp_Object
*overlay_vec
, ptrdiff_t noverlays
, struct window
*w
)
3120 struct sortvec
*sortvec
;
3122 SAFE_NALLOCA (sortvec
, 1, noverlays
);
3124 /* Put the valid and relevant overlays into sortvec. */
3126 for (i
= 0, j
= 0; i
< noverlays
; i
++)
3129 Lisp_Object overlay
;
3131 overlay
= overlay_vec
[i
];
3132 if (OVERLAYP (overlay
)
3133 && OVERLAY_POSITION (OVERLAY_START (overlay
)) > 0
3134 && OVERLAY_POSITION (OVERLAY_END (overlay
)) > 0)
3136 /* If we're interested in a specific window, then ignore
3137 overlays that are limited to some other window. */
3142 window
= Foverlay_get (overlay
, Qwindow
);
3143 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3147 /* This overlay is good and counts: put it into sortvec. */
3148 sortvec
[j
].overlay
= overlay
;
3149 sortvec
[j
].beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3150 sortvec
[j
].end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3151 tem
= Foverlay_get (overlay
, Qpriority
);
3154 sortvec
[j
].priority
= 0;
3155 sortvec
[j
].spriority
= 0;
3157 else if (INTEGERP (tem
))
3159 sortvec
[j
].priority
= XINT (tem
);
3160 sortvec
[j
].spriority
= 0;
3162 else if (CONSP (tem
))
3164 Lisp_Object car
= XCAR (tem
);
3165 Lisp_Object cdr
= XCDR (tem
);
3166 sortvec
[j
].priority
= INTEGERP (car
) ? XINT (car
) : 0;
3167 sortvec
[j
].spriority
= INTEGERP (cdr
) ? XINT (cdr
) : 0;
3174 /* Sort the overlays into the proper order: increasing priority. */
3177 qsort (sortvec
, noverlays
, sizeof (struct sortvec
), compare_overlays
);
3179 for (i
= 0; i
< noverlays
; i
++)
3180 overlay_vec
[i
] = sortvec
[i
].overlay
;
3188 Lisp_Object string
, string2
;
3195 struct sortstr
*buf
; /* An array that expands as needed; never freed. */
3196 ptrdiff_t size
; /* Allocated length of that array. */
3197 ptrdiff_t used
; /* How much of the array is currently in use. */
3198 ptrdiff_t bytes
; /* Total length of the strings in buf. */
3201 /* Buffers for storing information about the overlays touching a given
3202 position. These could be automatic variables in overlay_strings, but
3203 it's more efficient to hold onto the memory instead of repeatedly
3204 allocating and freeing it. */
3205 static struct sortstrlist overlay_heads
, overlay_tails
;
3206 static unsigned char *overlay_str_buf
;
3208 /* Allocated length of overlay_str_buf. */
3209 static ptrdiff_t overlay_str_len
;
3211 /* A comparison function suitable for passing to qsort. */
3213 cmp_for_strings (const void *as1
, const void *as2
)
3215 struct sortstr
const *s1
= as1
;
3216 struct sortstr
const *s2
= as2
;
3217 if (s1
->size
!= s2
->size
)
3218 return s2
->size
< s1
->size
? -1 : 1;
3219 if (s1
->priority
!= s2
->priority
)
3220 return s1
->priority
< s2
->priority
? -1 : 1;
3225 record_overlay_string (struct sortstrlist
*ssl
, Lisp_Object str
,
3226 Lisp_Object str2
, Lisp_Object pri
, ptrdiff_t size
)
3230 if (ssl
->used
== ssl
->size
)
3231 ssl
->buf
= xpalloc (ssl
->buf
, &ssl
->size
, 5, -1, sizeof *ssl
->buf
);
3232 ssl
->buf
[ssl
->used
].string
= str
;
3233 ssl
->buf
[ssl
->used
].string2
= str2
;
3234 ssl
->buf
[ssl
->used
].size
= size
;
3235 ssl
->buf
[ssl
->used
].priority
= (INTEGERP (pri
) ? XINT (pri
) : 0);
3238 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3239 nbytes
= SCHARS (str
);
3240 else if (! STRING_MULTIBYTE (str
))
3241 nbytes
= count_size_as_multibyte (SDATA (str
),
3244 nbytes
= SBYTES (str
);
3246 if (INT_ADD_WRAPV (ssl
->bytes
, nbytes
, &nbytes
))
3247 memory_full (SIZE_MAX
);
3248 ssl
->bytes
= nbytes
;
3252 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3253 nbytes
= SCHARS (str2
);
3254 else if (! STRING_MULTIBYTE (str2
))
3255 nbytes
= count_size_as_multibyte (SDATA (str2
),
3258 nbytes
= SBYTES (str2
);
3260 if (INT_ADD_WRAPV (ssl
->bytes
, nbytes
, &nbytes
))
3261 memory_full (SIZE_MAX
);
3262 ssl
->bytes
= nbytes
;
3266 /* Concatenate the strings associated with overlays that begin or end
3267 at POS, ignoring overlays that are specific to windows other than W.
3268 The strings are concatenated in the appropriate order: shorter
3269 overlays nest inside longer ones, and higher priority inside lower.
3270 Normally all of the after-strings come first, but zero-sized
3271 overlays have their after-strings ride along with the
3272 before-strings because it would look strange to print them
3275 Returns the concatenated string's length, and return the pointer to
3276 that string via PSTR, if that variable is non-NULL. The storage of
3277 the concatenated strings may be overwritten by subsequent calls. */
3280 overlay_strings (ptrdiff_t pos
, struct window
*w
, unsigned char **pstr
)
3282 Lisp_Object overlay
, window
, str
;
3283 struct Lisp_Overlay
*ov
;
3284 ptrdiff_t startpos
, endpos
;
3285 bool multibyte
= ! NILP (BVAR (current_buffer
, enable_multibyte_characters
));
3287 overlay_heads
.used
= overlay_heads
.bytes
= 0;
3288 overlay_tails
.used
= overlay_tails
.bytes
= 0;
3289 for (ov
= current_buffer
->overlays_before
; ov
; ov
= ov
->next
)
3291 XSETMISC (overlay
, ov
);
3292 eassert (OVERLAYP (overlay
));
3294 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3295 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3298 if (endpos
!= pos
&& startpos
!= pos
)
3300 window
= Foverlay_get (overlay
, Qwindow
);
3301 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3304 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3305 record_overlay_string (&overlay_heads
, str
,
3307 ? Foverlay_get (overlay
, Qafter_string
)
3309 Foverlay_get (overlay
, Qpriority
),
3311 else if (endpos
== pos
3312 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3313 record_overlay_string (&overlay_tails
, str
, Qnil
,
3314 Foverlay_get (overlay
, Qpriority
),
3317 for (ov
= current_buffer
->overlays_after
; ov
; ov
= ov
->next
)
3319 XSETMISC (overlay
, ov
);
3320 eassert (OVERLAYP (overlay
));
3322 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3323 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3326 if (endpos
!= pos
&& startpos
!= pos
)
3328 window
= Foverlay_get (overlay
, Qwindow
);
3329 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3332 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3333 record_overlay_string (&overlay_heads
, str
,
3335 ? Foverlay_get (overlay
, Qafter_string
)
3337 Foverlay_get (overlay
, Qpriority
),
3339 else if (endpos
== pos
3340 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3341 record_overlay_string (&overlay_tails
, str
, Qnil
,
3342 Foverlay_get (overlay
, Qpriority
),
3345 if (overlay_tails
.used
> 1)
3346 qsort (overlay_tails
.buf
, overlay_tails
.used
, sizeof (struct sortstr
),
3348 if (overlay_heads
.used
> 1)
3349 qsort (overlay_heads
.buf
, overlay_heads
.used
, sizeof (struct sortstr
),
3351 if (overlay_heads
.bytes
|| overlay_tails
.bytes
)
3358 if (INT_ADD_WRAPV (overlay_heads
.bytes
, overlay_tails
.bytes
, &total
))
3359 memory_full (SIZE_MAX
);
3360 if (total
> overlay_str_len
)
3361 overlay_str_buf
= xpalloc (overlay_str_buf
, &overlay_str_len
,
3362 total
- overlay_str_len
, -1, 1);
3364 p
= overlay_str_buf
;
3365 for (i
= overlay_tails
.used
; --i
>= 0;)
3368 tem
= overlay_tails
.buf
[i
].string
;
3369 nbytes
= copy_text (SDATA (tem
), p
,
3371 STRING_MULTIBYTE (tem
), multibyte
);
3374 for (i
= 0; i
< overlay_heads
.used
; ++i
)
3377 tem
= overlay_heads
.buf
[i
].string
;
3378 nbytes
= copy_text (SDATA (tem
), p
,
3380 STRING_MULTIBYTE (tem
), multibyte
);
3382 tem
= overlay_heads
.buf
[i
].string2
;
3385 nbytes
= copy_text (SDATA (tem
), p
,
3387 STRING_MULTIBYTE (tem
), multibyte
);
3391 if (p
!= overlay_str_buf
+ total
)
3394 *pstr
= overlay_str_buf
;
3400 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
3403 recenter_overlay_lists (struct buffer
*buf
, ptrdiff_t pos
)
3405 Lisp_Object overlay
, beg
, end
;
3406 struct Lisp_Overlay
*prev
, *tail
, *next
;
3408 /* See if anything in overlays_before should move to overlays_after. */
3410 /* We don't strictly need prev in this loop; it should always be nil.
3411 But we use it for symmetry and in case that should cease to be true
3412 with some future change. */
3414 for (tail
= buf
->overlays_before
; tail
; prev
= tail
, tail
= next
)
3417 XSETMISC (overlay
, tail
);
3418 eassert (OVERLAYP (overlay
));
3420 beg
= OVERLAY_START (overlay
);
3421 end
= OVERLAY_END (overlay
);
3423 if (OVERLAY_POSITION (end
) > pos
)
3425 /* OVERLAY needs to be moved. */
3426 ptrdiff_t where
= OVERLAY_POSITION (beg
);
3427 struct Lisp_Overlay
*other
, *other_prev
;
3429 /* Splice the cons cell TAIL out of overlays_before. */
3433 set_buffer_overlays_before (buf
, next
);
3435 /* Search thru overlays_after for where to put it. */
3437 for (other
= buf
->overlays_after
; other
;
3438 other_prev
= other
, other
= other
->next
)
3440 Lisp_Object otherbeg
, otheroverlay
;
3442 XSETMISC (otheroverlay
, other
);
3443 eassert (OVERLAYP (otheroverlay
));
3445 otherbeg
= OVERLAY_START (otheroverlay
);
3446 if (OVERLAY_POSITION (otherbeg
) >= where
)
3450 /* Add TAIL to overlays_after before OTHER. */
3453 other_prev
->next
= tail
;
3455 set_buffer_overlays_after (buf
, tail
);
3459 /* We've reached the things that should stay in overlays_before.
3460 All the rest of overlays_before must end even earlier,
3465 /* See if anything in overlays_after should be in overlays_before. */
3467 for (tail
= buf
->overlays_after
; tail
; prev
= tail
, tail
= next
)
3470 XSETMISC (overlay
, tail
);
3471 eassert (OVERLAYP (overlay
));
3473 beg
= OVERLAY_START (overlay
);
3474 end
= OVERLAY_END (overlay
);
3476 /* Stop looking, when we know that nothing further
3477 can possibly end before POS. */
3478 if (OVERLAY_POSITION (beg
) > pos
)
3481 if (OVERLAY_POSITION (end
) <= pos
)
3483 /* OVERLAY needs to be moved. */
3484 ptrdiff_t where
= OVERLAY_POSITION (end
);
3485 struct Lisp_Overlay
*other
, *other_prev
;
3487 /* Splice the cons cell TAIL out of overlays_after. */
3491 set_buffer_overlays_after (buf
, next
);
3493 /* Search thru overlays_before for where to put it. */
3495 for (other
= buf
->overlays_before
; other
;
3496 other_prev
= other
, other
= other
->next
)
3498 Lisp_Object otherend
, otheroverlay
;
3500 XSETMISC (otheroverlay
, other
);
3501 eassert (OVERLAYP (otheroverlay
));
3503 otherend
= OVERLAY_END (otheroverlay
);
3504 if (OVERLAY_POSITION (otherend
) <= where
)
3508 /* Add TAIL to overlays_before before OTHER. */
3511 other_prev
->next
= tail
;
3513 set_buffer_overlays_before (buf
, tail
);
3518 buf
->overlay_center
= pos
;
3522 adjust_overlays_for_insert (ptrdiff_t pos
, ptrdiff_t length
)
3524 /* After an insertion, the lists are still sorted properly,
3525 but we may need to update the value of the overlay center. */
3526 if (current_buffer
->overlay_center
>= pos
)
3527 current_buffer
->overlay_center
+= length
;
3531 adjust_overlays_for_delete (ptrdiff_t pos
, ptrdiff_t length
)
3533 if (current_buffer
->overlay_center
< pos
)
3534 /* The deletion was to our right. No change needed; the before- and
3535 after-lists are still consistent. */
3537 else if (current_buffer
->overlay_center
- pos
> length
)
3538 /* The deletion was to our left. We need to adjust the center value
3539 to account for the change in position, but the lists are consistent
3540 given the new value. */
3541 current_buffer
->overlay_center
-= length
;
3543 /* We're right in the middle. There might be things on the after-list
3544 that now belong on the before-list. Recentering will move them,
3545 and also update the center point. */
3546 recenter_overlay_lists (current_buffer
, pos
);
3549 /* Fix up overlays that were garbled as a result of permuting markers
3550 in the range START through END. Any overlay with at least one
3551 endpoint in this range will need to be unlinked from the overlay
3552 list and reinserted in its proper place.
3553 Such an overlay might even have negative size at this point.
3554 If so, we'll make the overlay empty. */
3556 fix_start_end_in_overlays (register ptrdiff_t start
, register ptrdiff_t end
)
3558 Lisp_Object overlay
;
3559 struct Lisp_Overlay
*before_list
;
3560 struct Lisp_Overlay
*after_list
;
3561 /* These are either nil, indicating that before_list or after_list
3562 should be assigned, or the cons cell the cdr of which should be
3564 struct Lisp_Overlay
*beforep
= NULL
, *afterp
= NULL
;
3565 /* 'Parent', likewise, indicates a cons cell or
3566 current_buffer->overlays_before or overlays_after, depending
3567 which loop we're in. */
3568 struct Lisp_Overlay
*tail
, *parent
;
3569 ptrdiff_t startpos
, endpos
;
3571 /* This algorithm shifts links around instead of consing and GCing.
3572 The loop invariant is that before_list (resp. after_list) is a
3573 well-formed list except that its last element, the CDR of beforep
3574 (resp. afterp) if beforep (afterp) isn't nil or before_list
3575 (after_list) if it is, is still uninitialized. So it's not a bug
3576 that before_list isn't initialized, although it may look
3578 for (parent
= NULL
, tail
= current_buffer
->overlays_before
; tail
;)
3580 XSETMISC (overlay
, tail
);
3582 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3583 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3585 /* If the overlay is backwards, make it empty. */
3586 if (endpos
< startpos
)
3589 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3597 || (startpos
>= start
&& startpos
< end
))
3599 /* Add it to the end of the wrong list. Later on,
3600 recenter_overlay_lists will move it to the right place. */
3601 if (endpos
< current_buffer
->overlay_center
)
3606 afterp
->next
= tail
;
3614 beforep
->next
= tail
;
3618 set_buffer_overlays_before (current_buffer
, tail
->next
);
3620 parent
->next
= tail
->next
;
3624 parent
= tail
, tail
= parent
->next
;
3626 for (parent
= NULL
, tail
= current_buffer
->overlays_after
; tail
;)
3628 XSETMISC (overlay
, tail
);
3630 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3631 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3633 /* If the overlay is backwards, make it empty. */
3634 if (endpos
< startpos
)
3637 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3641 if (startpos
>= end
)
3644 if (startpos
>= start
3645 || (endpos
>= start
&& endpos
< end
))
3647 if (endpos
< current_buffer
->overlay_center
)
3652 afterp
->next
= tail
;
3660 beforep
->next
= tail
;
3664 set_buffer_overlays_after (current_buffer
, tail
->next
);
3666 parent
->next
= tail
->next
;
3670 parent
= tail
, tail
= parent
->next
;
3673 /* Splice the constructed (wrong) lists into the buffer's lists,
3674 and let the recenter function make it sane again. */
3677 beforep
->next
= current_buffer
->overlays_before
;
3678 set_buffer_overlays_before (current_buffer
, before_list
);
3683 afterp
->next
= current_buffer
->overlays_after
;
3684 set_buffer_overlays_after (current_buffer
, after_list
);
3686 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3689 /* We have two types of overlay: the one whose ending marker is
3690 after-insertion-marker (this is the usual case) and the one whose
3691 ending marker is before-insertion-marker. When `overlays_before'
3692 contains overlays of the latter type and the former type in this
3693 order and both overlays end at inserting position, inserting a text
3694 increases only the ending marker of the latter type, which results
3695 in incorrect ordering of `overlays_before'.
3697 This function fixes ordering of overlays in the slot
3698 `overlays_before' of the buffer *BP. Before the insertion, `point'
3699 was at PREV, and now is at POS. */
3702 fix_overlays_before (struct buffer
*bp
, ptrdiff_t prev
, ptrdiff_t pos
)
3704 /* If parent is nil, replace overlays_before; otherwise, parent->next. */
3705 struct Lisp_Overlay
*tail
= bp
->overlays_before
, *parent
= NULL
, *right_pair
;
3709 /* After the insertion, the several overlays may be in incorrect
3710 order. The possibility is that, in the list `overlays_before',
3711 an overlay which ends at POS appears after an overlay which ends
3712 at PREV. Since POS is greater than PREV, we must fix the
3713 ordering of these overlays, by moving overlays ends at POS before
3714 the overlays ends at PREV. */
3716 /* At first, find a place where disordered overlays should be linked
3717 in. It is where an overlay which end before POS exists. (i.e. an
3718 overlay whose ending marker is after-insertion-marker if disorder
3721 && (XSETMISC (tem
, tail
),
3722 (end
= OVERLAY_POSITION (OVERLAY_END (tem
))) >= pos
))
3728 /* If we don't find such an overlay,
3729 or the found one ends before PREV,
3730 or the found one is the last one in the list,
3731 we don't have to fix anything. */
3732 if (!tail
|| end
< prev
|| !tail
->next
)
3735 right_pair
= parent
;
3739 /* Now, end position of overlays in the list TAIL should be before
3740 or equal to PREV. In the loop, an overlay which ends at POS is
3741 moved ahead to the place indicated by the CDR of RIGHT_PAIR. If
3742 we found an overlay which ends before PREV, the remaining
3743 overlays are in correct order. */
3746 XSETMISC (tem
, tail
);
3747 end
= OVERLAY_POSITION (OVERLAY_END (tem
));
3750 { /* This overlay is disordered. */
3751 struct Lisp_Overlay
*found
= tail
;
3753 /* Unlink the found overlay. */
3755 parent
->next
= tail
;
3756 /* Move an overlay at RIGHT_PLACE to the next of the found one,
3757 and link it into the right place. */
3760 found
->next
= bp
->overlays_before
;
3761 set_buffer_overlays_before (bp
, found
);
3765 found
->next
= right_pair
->next
;
3766 right_pair
->next
= found
;
3769 else if (end
== prev
)
3774 else /* No more disordered overlay. */
3779 DEFUN ("overlayp", Foverlayp
, Soverlayp
, 1, 1, 0,
3780 doc
: /* Return t if OBJECT is an overlay. */)
3781 (Lisp_Object object
)
3783 return (OVERLAYP (object
) ? Qt
: Qnil
);
3786 DEFUN ("make-overlay", Fmake_overlay
, Smake_overlay
, 2, 5, 0,
3787 doc
: /* Create a new overlay with range BEG to END in BUFFER and return it.
3788 If omitted, BUFFER defaults to the current buffer.
3789 BEG and END may be integers or markers.
3790 The fourth arg FRONT-ADVANCE, if non-nil, makes the marker
3791 for the front of the overlay advance when text is inserted there
3792 \(which means the text *is not* included in the overlay).
3793 The fifth arg REAR-ADVANCE, if non-nil, makes the marker
3794 for the rear of the overlay advance when text is inserted there
3795 \(which means the text *is* included in the overlay). */)
3796 (Lisp_Object beg
, Lisp_Object end
, Lisp_Object buffer
,
3797 Lisp_Object front_advance
, Lisp_Object rear_advance
)
3799 Lisp_Object overlay
;
3803 XSETBUFFER (buffer
, current_buffer
);
3805 CHECK_BUFFER (buffer
);
3807 if (MARKERP (beg
) && !EQ (Fmarker_buffer (beg
), buffer
))
3808 signal_error ("Marker points into wrong buffer", beg
);
3809 if (MARKERP (end
) && !EQ (Fmarker_buffer (end
), buffer
))
3810 signal_error ("Marker points into wrong buffer", end
);
3812 CHECK_NUMBER_COERCE_MARKER (beg
);
3813 CHECK_NUMBER_COERCE_MARKER (end
);
3815 if (XINT (beg
) > XINT (end
))
3818 temp
= beg
; beg
= end
; end
= temp
;
3821 b
= XBUFFER (buffer
);
3823 beg
= Fset_marker (Fmake_marker (), beg
, buffer
);
3824 end
= Fset_marker (Fmake_marker (), end
, buffer
);
3826 if (!NILP (front_advance
))
3827 XMARKER (beg
)->insertion_type
= 1;
3828 if (!NILP (rear_advance
))
3829 XMARKER (end
)->insertion_type
= 1;
3831 overlay
= build_overlay (beg
, end
, Qnil
);
3833 /* Put the new overlay on the wrong list. */
3834 end
= OVERLAY_END (overlay
);
3835 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
3837 eassert (b
->overlays_after
|| (XOVERLAY (overlay
)->next
== NULL
));
3838 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3839 set_buffer_overlays_after (b
, XOVERLAY (overlay
));
3843 eassert (b
->overlays_before
|| (XOVERLAY (overlay
)->next
== NULL
));
3844 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3845 set_buffer_overlays_before (b
, XOVERLAY (overlay
));
3847 /* This puts it in the right list, and in the right order. */
3848 recenter_overlay_lists (b
, b
->overlay_center
);
3850 /* We don't need to redisplay the region covered by the overlay, because
3851 the overlay has no properties at the moment. */
3856 /* Mark a section of BUF as needing redisplay because of overlays changes. */
3859 modify_overlay (struct buffer
*buf
, ptrdiff_t start
, ptrdiff_t end
)
3863 ptrdiff_t temp
= start
;
3868 BUF_COMPUTE_UNCHANGED (buf
, start
, end
);
3870 bset_redisplay (buf
);
3872 ++BUF_OVERLAY_MODIFF (buf
);
3875 /* Remove OVERLAY from LIST. */
3877 static struct Lisp_Overlay
*
3878 unchain_overlay (struct Lisp_Overlay
*list
, struct Lisp_Overlay
*overlay
)
3880 register struct Lisp_Overlay
*tail
, **prev
= &list
;
3882 for (tail
= list
; tail
; prev
= &tail
->next
, tail
= *prev
)
3883 if (tail
== overlay
)
3885 *prev
= overlay
->next
;
3886 overlay
->next
= NULL
;
3892 /* Remove OVERLAY from both overlay lists of B. */
3895 unchain_both (struct buffer
*b
, Lisp_Object overlay
)
3897 struct Lisp_Overlay
*ov
= XOVERLAY (overlay
);
3899 set_buffer_overlays_before (b
, unchain_overlay (b
->overlays_before
, ov
));
3900 set_buffer_overlays_after (b
, unchain_overlay (b
->overlays_after
, ov
));
3901 eassert (XOVERLAY (overlay
)->next
== NULL
);
3904 DEFUN ("move-overlay", Fmove_overlay
, Smove_overlay
, 3, 4, 0,
3905 doc
: /* Set the endpoints of OVERLAY to BEG and END in BUFFER.
3906 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.
3907 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current
3909 (Lisp_Object overlay
, Lisp_Object beg
, Lisp_Object end
, Lisp_Object buffer
)
3911 struct buffer
*b
, *ob
= 0;
3912 Lisp_Object obuffer
;
3913 ptrdiff_t count
= SPECPDL_INDEX ();
3914 ptrdiff_t n_beg
, n_end
;
3915 ptrdiff_t o_beg UNINIT
, o_end UNINIT
;
3917 CHECK_OVERLAY (overlay
);
3919 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3921 XSETBUFFER (buffer
, current_buffer
);
3922 CHECK_BUFFER (buffer
);
3924 if (NILP (Fbuffer_live_p (buffer
)))
3925 error ("Attempt to move overlay to a dead buffer");
3927 if (MARKERP (beg
) && !EQ (Fmarker_buffer (beg
), buffer
))
3928 signal_error ("Marker points into wrong buffer", beg
);
3929 if (MARKERP (end
) && !EQ (Fmarker_buffer (end
), buffer
))
3930 signal_error ("Marker points into wrong buffer", end
);
3932 CHECK_NUMBER_COERCE_MARKER (beg
);
3933 CHECK_NUMBER_COERCE_MARKER (end
);
3935 if (XINT (beg
) > XINT (end
))
3938 temp
= beg
; beg
= end
; end
= temp
;
3941 specbind (Qinhibit_quit
, Qt
);
3943 obuffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3944 b
= XBUFFER (buffer
);
3946 if (!NILP (obuffer
))
3948 ob
= XBUFFER (obuffer
);
3950 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3951 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3953 unchain_both (ob
, overlay
);
3956 /* Set the overlay boundaries, which may clip them. */
3957 Fset_marker (OVERLAY_START (overlay
), beg
, buffer
);
3958 Fset_marker (OVERLAY_END (overlay
), end
, buffer
);
3960 n_beg
= marker_position (OVERLAY_START (overlay
));
3961 n_end
= marker_position (OVERLAY_END (overlay
));
3963 /* If the overlay has changed buffers, do a thorough redisplay. */
3964 if (!EQ (buffer
, obuffer
))
3966 /* Redisplay where the overlay was. */
3968 modify_overlay (ob
, o_beg
, o_end
);
3970 /* Redisplay where the overlay is going to be. */
3971 modify_overlay (b
, n_beg
, n_end
);
3974 /* Redisplay the area the overlay has just left, or just enclosed. */
3977 modify_overlay (b
, o_end
, n_end
);
3978 else if (o_end
== n_end
)
3979 modify_overlay (b
, o_beg
, n_beg
);
3981 modify_overlay (b
, min (o_beg
, n_beg
), max (o_end
, n_end
));
3984 /* Delete the overlay if it is empty after clipping and has the
3985 evaporate property. */
3986 if (n_beg
== n_end
&& !NILP (Foverlay_get (overlay
, Qevaporate
)))
3987 return unbind_to (count
, Fdelete_overlay (overlay
));
3989 /* Put the overlay into the new buffer's overlay lists, first on the
3991 if (n_end
< b
->overlay_center
)
3993 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3994 set_buffer_overlays_after (b
, XOVERLAY (overlay
));
3998 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3999 set_buffer_overlays_before (b
, XOVERLAY (overlay
));
4002 /* This puts it in the right list, and in the right order. */
4003 recenter_overlay_lists (b
, b
->overlay_center
);
4005 return unbind_to (count
, overlay
);
4008 DEFUN ("delete-overlay", Fdelete_overlay
, Sdelete_overlay
, 1, 1, 0,
4009 doc
: /* Delete the overlay OVERLAY from its buffer. */)
4010 (Lisp_Object overlay
)
4014 ptrdiff_t count
= SPECPDL_INDEX ();
4016 CHECK_OVERLAY (overlay
);
4018 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4022 b
= XBUFFER (buffer
);
4023 specbind (Qinhibit_quit
, Qt
);
4025 unchain_both (b
, overlay
);
4026 drop_overlay (b
, XOVERLAY (overlay
));
4028 /* When deleting an overlay with before or after strings, turn off
4029 display optimizations for the affected buffer, on the basis that
4030 these strings may contain newlines. This is easier to do than to
4031 check for that situation during redisplay. */
4032 if (!windows_or_buffers_changed
4033 && (!NILP (Foverlay_get (overlay
, Qbefore_string
))
4034 || !NILP (Foverlay_get (overlay
, Qafter_string
))))
4035 b
->prevent_redisplay_optimizations_p
= 1;
4037 return unbind_to (count
, Qnil
);
4040 DEFUN ("delete-all-overlays", Fdelete_all_overlays
, Sdelete_all_overlays
, 0, 1, 0,
4041 doc
: /* Delete all overlays of BUFFER.
4042 BUFFER omitted or nil means delete all overlays of the current
4044 (Lisp_Object buffer
)
4046 delete_all_overlays (decode_buffer (buffer
));
4050 /* Overlay dissection functions. */
4052 DEFUN ("overlay-start", Foverlay_start
, Soverlay_start
, 1, 1, 0,
4053 doc
: /* Return the position at which OVERLAY starts. */)
4054 (Lisp_Object overlay
)
4056 CHECK_OVERLAY (overlay
);
4058 return (Fmarker_position (OVERLAY_START (overlay
)));
4061 DEFUN ("overlay-end", Foverlay_end
, Soverlay_end
, 1, 1, 0,
4062 doc
: /* Return the position at which OVERLAY ends. */)
4063 (Lisp_Object overlay
)
4065 CHECK_OVERLAY (overlay
);
4067 return (Fmarker_position (OVERLAY_END (overlay
)));
4070 DEFUN ("overlay-buffer", Foverlay_buffer
, Soverlay_buffer
, 1, 1, 0,
4071 doc
: /* Return the buffer OVERLAY belongs to.
4072 Return nil if OVERLAY has been deleted. */)
4073 (Lisp_Object overlay
)
4075 CHECK_OVERLAY (overlay
);
4077 return Fmarker_buffer (OVERLAY_START (overlay
));
4080 DEFUN ("overlay-properties", Foverlay_properties
, Soverlay_properties
, 1, 1, 0,
4081 doc
: /* Return a list of the properties on OVERLAY.
4082 This is a copy of OVERLAY's plist; modifying its conses has no effect on
4084 (Lisp_Object overlay
)
4086 CHECK_OVERLAY (overlay
);
4088 return Fcopy_sequence (XOVERLAY (overlay
)->plist
);
4092 DEFUN ("overlays-at", Foverlays_at
, Soverlays_at
, 1, 2, 0,
4093 doc
: /* Return a list of the overlays that contain the character at POS.
4094 If SORTED is non-nil, then sort them by decreasing priority. */)
4095 (Lisp_Object pos
, Lisp_Object sorted
)
4097 ptrdiff_t len
, noverlays
;
4098 Lisp_Object
*overlay_vec
;
4101 CHECK_NUMBER_COERCE_MARKER (pos
);
4103 if (!buffer_has_overlays ())
4107 /* We can't use alloca here because overlays_at can call xrealloc. */
4108 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4110 /* Put all the overlays we want in a vector in overlay_vec.
4111 Store the length in len. */
4112 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4116 noverlays
= sort_overlays (overlay_vec
, noverlays
,
4117 WINDOWP (sorted
) ? XWINDOW (sorted
) : NULL
);
4119 /* Make a list of them all. */
4120 result
= Flist (noverlays
, overlay_vec
);
4122 xfree (overlay_vec
);
4126 DEFUN ("overlays-in", Foverlays_in
, Soverlays_in
, 2, 2, 0,
4127 doc
: /* Return a list of the overlays that overlap the region BEG ... END.
4128 Overlap means that at least one character is contained within the overlay
4129 and also contained within the specified region.
4130 Empty overlays are included in the result if they are located at BEG,
4131 between BEG and END, or at END provided END denotes the position at the
4132 end of the buffer. */)
4133 (Lisp_Object beg
, Lisp_Object end
)
4135 ptrdiff_t len
, noverlays
;
4136 Lisp_Object
*overlay_vec
;
4139 CHECK_NUMBER_COERCE_MARKER (beg
);
4140 CHECK_NUMBER_COERCE_MARKER (end
);
4142 if (!buffer_has_overlays ())
4146 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4148 /* Put all the overlays we want in a vector in overlay_vec.
4149 Store the length in len. */
4150 noverlays
= overlays_in (XINT (beg
), XINT (end
), 1, &overlay_vec
, &len
,
4153 /* Make a list of them all. */
4154 result
= Flist (noverlays
, overlay_vec
);
4156 xfree (overlay_vec
);
4160 DEFUN ("next-overlay-change", Fnext_overlay_change
, Snext_overlay_change
,
4162 doc
: /* Return the next position after POS where an overlay starts or ends.
4163 If there are no overlay boundaries from POS to (point-max),
4164 the value is (point-max). */)
4167 ptrdiff_t i
, len
, noverlays
;
4169 Lisp_Object
*overlay_vec
;
4171 CHECK_NUMBER_COERCE_MARKER (pos
);
4173 if (!buffer_has_overlays ())
4174 return make_number (ZV
);
4177 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4179 /* Put all the overlays we want in a vector in overlay_vec.
4180 Store the length in len.
4181 endpos gets the position where the next overlay starts. */
4182 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4185 /* If any of these overlays ends before endpos,
4186 use its ending point instead. */
4187 for (i
= 0; i
< noverlays
; i
++)
4192 oend
= OVERLAY_END (overlay_vec
[i
]);
4193 oendpos
= OVERLAY_POSITION (oend
);
4194 if (oendpos
< endpos
)
4198 xfree (overlay_vec
);
4199 return make_number (endpos
);
4202 DEFUN ("previous-overlay-change", Fprevious_overlay_change
,
4203 Sprevious_overlay_change
, 1, 1, 0,
4204 doc
: /* Return the previous position before POS where an overlay starts or ends.
4205 If there are no overlay boundaries from (point-min) to POS,
4206 the value is (point-min). */)
4210 Lisp_Object
*overlay_vec
;
4213 CHECK_NUMBER_COERCE_MARKER (pos
);
4215 if (!buffer_has_overlays ())
4216 return make_number (BEGV
);
4218 /* At beginning of buffer, we know the answer;
4219 avoid bug subtracting 1 below. */
4220 if (XINT (pos
) == BEGV
)
4224 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4226 /* Put all the overlays we want in a vector in overlay_vec.
4227 Store the length in len.
4228 prevpos gets the position of the previous change. */
4229 overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4232 xfree (overlay_vec
);
4233 return make_number (prevpos
);
4236 /* These functions are for debugging overlays. */
4238 DEFUN ("overlay-lists", Foverlay_lists
, Soverlay_lists
, 0, 0, 0,
4239 doc
: /* Return a pair of lists giving all the overlays of the current buffer.
4240 The car has all the overlays before the overlay center;
4241 the cdr has all the overlays after the overlay center.
4242 Recentering overlays moves overlays between these lists.
4243 The lists you get are copies, so that changing them has no effect.
4244 However, the overlays you get are the real objects that the buffer uses. */)
4247 struct Lisp_Overlay
*ol
;
4248 Lisp_Object before
= Qnil
, after
= Qnil
, tmp
;
4250 for (ol
= current_buffer
->overlays_before
; ol
; ol
= ol
->next
)
4253 before
= Fcons (tmp
, before
);
4255 for (ol
= current_buffer
->overlays_after
; ol
; ol
= ol
->next
)
4258 after
= Fcons (tmp
, after
);
4261 return Fcons (Fnreverse (before
), Fnreverse (after
));
4264 DEFUN ("overlay-recenter", Foverlay_recenter
, Soverlay_recenter
, 1, 1, 0,
4265 doc
: /* Recenter the overlays of the current buffer around position POS.
4266 That makes overlay lookup faster for positions near POS (but perhaps slower
4267 for positions far away from POS). */)
4271 CHECK_NUMBER_COERCE_MARKER (pos
);
4273 p
= clip_to_bounds (PTRDIFF_MIN
, XINT (pos
), PTRDIFF_MAX
);
4274 recenter_overlay_lists (current_buffer
, p
);
4278 DEFUN ("overlay-get", Foverlay_get
, Soverlay_get
, 2, 2, 0,
4279 doc
: /* Get the property of overlay OVERLAY with property name PROP. */)
4280 (Lisp_Object overlay
, Lisp_Object prop
)
4282 CHECK_OVERLAY (overlay
);
4283 return lookup_char_property (XOVERLAY (overlay
)->plist
, prop
, 0);
4286 DEFUN ("overlay-put", Foverlay_put
, Soverlay_put
, 3, 3, 0,
4287 doc
: /* Set one property of overlay OVERLAY: give property PROP value VALUE.
4288 VALUE will be returned.*/)
4289 (Lisp_Object overlay
, Lisp_Object prop
, Lisp_Object value
)
4291 Lisp_Object tail
, buffer
;
4294 CHECK_OVERLAY (overlay
);
4296 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4298 for (tail
= XOVERLAY (overlay
)->plist
;
4299 CONSP (tail
) && CONSP (XCDR (tail
));
4300 tail
= XCDR (XCDR (tail
)))
4301 if (EQ (XCAR (tail
), prop
))
4303 changed
= !EQ (XCAR (XCDR (tail
)), value
);
4304 XSETCAR (XCDR (tail
), value
);
4307 /* It wasn't in the list, so add it to the front. */
4308 changed
= !NILP (value
);
4310 (overlay
, Fcons (prop
, Fcons (value
, XOVERLAY (overlay
)->plist
)));
4312 if (! NILP (buffer
))
4315 modify_overlay (XBUFFER (buffer
),
4316 marker_position (OVERLAY_START (overlay
)),
4317 marker_position (OVERLAY_END (overlay
)));
4318 if (EQ (prop
, Qevaporate
) && ! NILP (value
)
4319 && (OVERLAY_POSITION (OVERLAY_START (overlay
))
4320 == OVERLAY_POSITION (OVERLAY_END (overlay
))))
4321 Fdelete_overlay (overlay
);
4327 /* Subroutine of report_overlay_modification. */
4329 /* Lisp vector holding overlay hook functions to call.
4330 Vector elements come in pairs.
4331 Each even-index element is a list of hook functions.
4332 The following odd-index element is the overlay they came from.
4334 Before the buffer change, we fill in this vector
4335 as we call overlay hook functions.
4336 After the buffer change, we get the functions to call from this vector.
4337 This way we always call the same functions before and after the change. */
4338 static Lisp_Object last_overlay_modification_hooks
;
4340 /* Number of elements actually used in last_overlay_modification_hooks. */
4341 static ptrdiff_t last_overlay_modification_hooks_used
;
4343 /* Add one functionlist/overlay pair
4344 to the end of last_overlay_modification_hooks. */
4347 add_overlay_mod_hooklist (Lisp_Object functionlist
, Lisp_Object overlay
)
4349 ptrdiff_t oldsize
= ASIZE (last_overlay_modification_hooks
);
4351 if (oldsize
- 1 <= last_overlay_modification_hooks_used
)
4352 last_overlay_modification_hooks
=
4353 larger_vector (last_overlay_modification_hooks
, 2, -1);
4354 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4355 functionlist
); last_overlay_modification_hooks_used
++;
4356 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4357 overlay
); last_overlay_modification_hooks_used
++;
4360 /* Run the modification-hooks of overlays that include
4361 any part of the text in START to END.
4362 If this change is an insertion, also
4363 run the insert-before-hooks of overlay starting at END,
4364 and the insert-after-hooks of overlay ending at START.
4366 This is called both before and after the modification.
4367 AFTER is true when we call after the modification.
4369 ARG1, ARG2, ARG3 are arguments to pass to the hook functions.
4370 When AFTER is nonzero, they are the start position,
4371 the position after the inserted new text,
4372 and the length of deleted or replaced old text. */
4375 report_overlay_modification (Lisp_Object start
, Lisp_Object end
, bool after
,
4376 Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
)
4378 Lisp_Object prop
, overlay
;
4379 struct Lisp_Overlay
*tail
;
4380 /* True if this change is an insertion. */
4381 bool insertion
= (after
? XFASTINT (arg3
) == 0 : EQ (start
, end
));
4386 /* We used to run the functions as soon as we found them and only register
4387 them in last_overlay_modification_hooks for the purpose of the `after'
4388 case. But running elisp code as we traverse the list of overlays is
4389 painful because the list can be modified by the elisp code so we had to
4390 copy at several places. We now simply do a read-only traversal that
4391 only collects the functions to run and we run them afterwards. It's
4392 simpler, especially since all the code was already there. -stef */
4396 /* We are being called before a change.
4397 Scan the overlays to find the functions to call. */
4398 last_overlay_modification_hooks_used
= 0;
4399 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4401 ptrdiff_t startpos
, endpos
;
4402 Lisp_Object ostart
, oend
;
4404 XSETMISC (overlay
, tail
);
4406 ostart
= OVERLAY_START (overlay
);
4407 oend
= OVERLAY_END (overlay
);
4408 endpos
= OVERLAY_POSITION (oend
);
4409 if (XFASTINT (start
) > endpos
)
4411 startpos
= OVERLAY_POSITION (ostart
);
4412 if (insertion
&& (XFASTINT (start
) == startpos
4413 || XFASTINT (end
) == startpos
))
4415 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4417 add_overlay_mod_hooklist (prop
, overlay
);
4419 if (insertion
&& (XFASTINT (start
) == endpos
4420 || XFASTINT (end
) == endpos
))
4422 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4424 add_overlay_mod_hooklist (prop
, overlay
);
4426 /* Test for intersecting intervals. This does the right thing
4427 for both insertion and deletion. */
4428 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4430 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4432 add_overlay_mod_hooklist (prop
, overlay
);
4436 for (tail
= current_buffer
->overlays_after
; 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 startpos
= OVERLAY_POSITION (ostart
);
4446 endpos
= OVERLAY_POSITION (oend
);
4447 if (XFASTINT (end
) < startpos
)
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
);
4475 /* Call the functions recorded in last_overlay_modification_hooks.
4476 First copy the vector contents, in case some of these hooks
4477 do subsequent modification of the buffer. */
4478 ptrdiff_t size
= last_overlay_modification_hooks_used
;
4485 = XVECTOR (last_overlay_modification_hooks
)->contents
[1];
4487 /* If the buffer of the first overlay in the array doesn't
4488 match the current buffer, then these modification hooks
4489 should not be run in this buffer. This could happen when
4490 some code calls some insdel functions, such as del_range_1,
4491 with the PREPARE argument false -- in that case this
4492 function is never called to record the overlay modification
4493 hook functions in the last_overlay_modification_hooks
4494 array, so anything we find there is not ours. */
4495 if (XMARKER (OVERLAY_START (ovl
))->buffer
!= current_buffer
)
4500 SAFE_ALLOCA_LISP (copy
, size
);
4501 memcpy (copy
, XVECTOR (last_overlay_modification_hooks
)->contents
,
4504 for (i
= 0; i
< size
;)
4506 Lisp_Object prop_i
, overlay_i
;
4508 overlay_i
= copy
[i
++];
4509 call_overlay_mod_hooks (prop_i
, overlay_i
, after
, arg1
, arg2
, arg3
);
4517 call_overlay_mod_hooks (Lisp_Object list
, Lisp_Object overlay
, bool after
,
4518 Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
)
4520 while (CONSP (list
))
4523 call4 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
);
4525 call5 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
, arg3
);
4530 /* Delete any zero-sized overlays at position POS, if the `evaporate'
4533 evaporate_overlays (ptrdiff_t pos
)
4535 Lisp_Object overlay
, hit_list
;
4536 struct Lisp_Overlay
*tail
;
4539 if (pos
<= current_buffer
->overlay_center
)
4540 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4543 XSETMISC (overlay
, tail
);
4544 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4547 if (endpos
== pos
&& OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
4548 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4549 hit_list
= Fcons (overlay
, hit_list
);
4552 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4555 XSETMISC (overlay
, tail
);
4556 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4559 if (startpos
== pos
&& OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
4560 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4561 hit_list
= Fcons (overlay
, hit_list
);
4563 for (; CONSP (hit_list
); hit_list
= XCDR (hit_list
))
4564 Fdelete_overlay (XCAR (hit_list
));
4567 /***********************************************************************
4568 Allocation with mmap
4569 ***********************************************************************/
4571 /* Note: WINDOWSNT implements this stuff on w32heap.c. */
4572 #if defined USE_MMAP_FOR_BUFFERS && !defined WINDOWSNT
4574 #include <sys/mman.h>
4577 #ifdef MAP_ANONYMOUS
4578 #define MAP_ANON MAP_ANONYMOUS
4585 #define MAP_FAILED ((void *) -1)
4593 /* Memory is allocated in regions which are mapped using mmap(2).
4594 The current implementation lets the system select mapped
4595 addresses; we're not using MAP_FIXED in general, except when
4596 trying to enlarge regions.
4598 Each mapped region starts with a mmap_region structure, the user
4599 area starts after that structure, aligned to MEM_ALIGN.
4601 +-----------------------+
4602 | struct mmap_info + |
4604 +-----------------------+
4608 +-----------------------+ */
4612 /* User-specified size. */
4613 size_t nbytes_specified
;
4615 /* Number of bytes mapped */
4616 size_t nbytes_mapped
;
4618 /* Pointer to the location holding the address of the memory
4619 allocated with the mmap'd block. The variable actually points
4620 after this structure. */
4623 /* Next and previous in list of all mmap'd regions. */
4624 struct mmap_region
*next
, *prev
;
4627 /* Doubly-linked list of mmap'd regions. */
4629 static struct mmap_region
*mmap_regions
;
4631 /* File descriptor for mmap. If we don't have anonymous mapping,
4632 /dev/zero will be opened on it. */
4636 /* Page size on this system. */
4638 static int mmap_page_size
;
4640 /* 1 means mmap has been initialized. */
4642 static bool mmap_initialized_p
;
4644 /* Value is X rounded up to the next multiple of N. */
4646 #define ROUND(X, N) (((X) + (N) - 1) / (N) * (N))
4648 /* Size of mmap_region structure plus padding. */
4650 #define MMAP_REGION_STRUCT_SIZE \
4651 ROUND (sizeof (struct mmap_region), MEM_ALIGN)
4653 /* Given a pointer P to the start of the user-visible part of a mapped
4654 region, return a pointer to the start of the region. */
4656 #define MMAP_REGION(P) \
4657 ((struct mmap_region *) ((char *) (P) - MMAP_REGION_STRUCT_SIZE))
4659 /* Given a pointer P to the start of a mapped region, return a pointer
4660 to the start of the user-visible part of the region. */
4662 #define MMAP_USER_AREA(P) \
4663 ((void *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
4665 #define MEM_ALIGN sizeof (double)
4667 /* Predicate returning true if part of the address range [START .. END]
4668 is currently mapped. Used to prevent overwriting an existing
4671 Default is to conservatively assume the address range is occupied by
4672 something else. This can be overridden by system configuration
4673 files if system-specific means to determine this exists. */
4675 #ifndef MMAP_ALLOCATED_P
4676 #define MMAP_ALLOCATED_P(start, end) 1
4679 /* Perform necessary initializations for the use of mmap. */
4685 /* The value of mmap_fd is initially 0 in temacs, and -1
4686 in a dumped Emacs. */
4689 /* No anonymous mmap -- we need the file descriptor. */
4690 mmap_fd
= emacs_open ("/dev/zero", O_RDONLY
, 0);
4692 fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno
));
4694 #endif /* MAP_ANON == 0 */
4696 if (mmap_initialized_p
)
4698 mmap_initialized_p
= 1;
4704 mmap_page_size
= getpagesize ();
4707 /* Unmap a region. P is a pointer to the start of the user-araa of
4711 mmap_free_1 (struct mmap_region
*r
)
4714 r
->next
->prev
= r
->prev
;
4716 r
->prev
->next
= r
->next
;
4718 mmap_regions
= r
->next
;
4720 if (munmap (r
, r
->nbytes_mapped
) == -1)
4721 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4725 /* Enlarge region R by NPAGES pages. NPAGES < 0 means shrink R.
4726 Value is true if successful. */
4729 mmap_enlarge (struct mmap_region
*r
, int npages
)
4731 char *region_end
= (char *) r
+ r
->nbytes_mapped
;
4737 /* Unmap pages at the end of the region. */
4738 nbytes
= - npages
* mmap_page_size
;
4739 if (munmap (region_end
- nbytes
, nbytes
) == -1)
4740 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4743 r
->nbytes_mapped
-= nbytes
;
4747 else if (npages
> 0)
4749 nbytes
= npages
* mmap_page_size
;
4751 /* Try to map additional pages at the end of the region. We
4752 cannot do this if the address range is already occupied by
4753 something else because mmap deletes any previous mapping.
4754 I'm not sure this is worth doing, let's see. */
4755 if (!MMAP_ALLOCATED_P (region_end
, region_end
+ nbytes
))
4759 p
= mmap (region_end
, nbytes
, PROT_READ
| PROT_WRITE
,
4760 MAP_ANON
| MAP_PRIVATE
| MAP_FIXED
, mmap_fd
, 0);
4761 if (p
== MAP_FAILED
)
4762 ; /* fprintf (stderr, "mmap: %s\n", emacs_strerror (errno)); */
4763 else if (p
!= region_end
)
4765 /* Kernels are free to choose a different address. In
4766 that case, unmap what we've mapped above; we have
4768 if (munmap (p
, nbytes
) == -1)
4769 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4773 r
->nbytes_mapped
+= nbytes
;
4783 /* Allocate a block of storage large enough to hold NBYTES bytes of
4784 data. A pointer to the data is returned in *VAR. VAR is thus the
4785 address of some variable which will use the data area.
4787 The allocation of 0 bytes is valid.
4789 If we can't allocate the necessary memory, set *VAR to null, and
4793 mmap_alloc (void **var
, size_t nbytes
)
4800 map
= ROUND (nbytes
+ MMAP_REGION_STRUCT_SIZE
, mmap_page_size
);
4801 p
= mmap (NULL
, map
, PROT_READ
| PROT_WRITE
, MAP_ANON
| MAP_PRIVATE
,
4804 if (p
== MAP_FAILED
)
4806 if (errno
!= ENOMEM
)
4807 fprintf (stderr
, "mmap: %s\n", emacs_strerror (errno
));
4812 struct mmap_region
*r
= p
;
4814 r
->nbytes_specified
= nbytes
;
4815 r
->nbytes_mapped
= map
;
4818 r
->next
= mmap_regions
;
4823 p
= MMAP_USER_AREA (p
);
4830 /* Free a block of relocatable storage whose data is pointed to by
4831 PTR. Store 0 in *PTR to show there's no block allocated. */
4834 mmap_free (void **var
)
4840 mmap_free_1 (MMAP_REGION (*var
));
4846 /* Given a pointer at address VAR to data allocated with mmap_alloc,
4847 resize it to size NBYTES. Change *VAR to reflect the new block,
4848 and return this value. If more memory cannot be allocated, then
4849 leave *VAR unchanged, and return null. */
4852 mmap_realloc (void **var
, size_t nbytes
)
4859 result
= mmap_alloc (var
, nbytes
);
4860 else if (nbytes
== 0)
4863 result
= mmap_alloc (var
, nbytes
);
4867 struct mmap_region
*r
= MMAP_REGION (*var
);
4868 size_t room
= r
->nbytes_mapped
- MMAP_REGION_STRUCT_SIZE
;
4873 void *old_ptr
= *var
;
4875 /* Try to map additional pages at the end of the region.
4876 If that fails, allocate a new region, copy data
4877 from the old region, then free it. */
4878 if (mmap_enlarge (r
, (ROUND (nbytes
- room
, mmap_page_size
)
4881 r
->nbytes_specified
= nbytes
;
4882 *var
= result
= old_ptr
;
4884 else if (mmap_alloc (var
, nbytes
))
4886 memcpy (*var
, old_ptr
, r
->nbytes_specified
);
4887 mmap_free_1 (MMAP_REGION (old_ptr
));
4889 r
= MMAP_REGION (result
);
4890 r
->nbytes_specified
= nbytes
;
4898 else if (room
- nbytes
>= mmap_page_size
)
4900 /* Shrinking by at least a page. Let's give some
4901 memory back to the system.
4903 The extra parens are to make the division happens first,
4904 on positive values, so we know it will round towards
4906 mmap_enlarge (r
, - ((room
- nbytes
) / mmap_page_size
));
4908 r
->nbytes_specified
= nbytes
;
4912 /* Leave it alone. */
4914 r
->nbytes_specified
= nbytes
;
4922 #endif /* USE_MMAP_FOR_BUFFERS */
4926 /***********************************************************************
4927 Buffer-text Allocation
4928 ***********************************************************************/
4930 /* Allocate NBYTES bytes for buffer B's text buffer. */
4933 alloc_buffer_text (struct buffer
*b
, ptrdiff_t nbytes
)
4938 #if defined USE_MMAP_FOR_BUFFERS
4939 p
= mmap_alloc ((void **) &b
->text
->beg
, nbytes
);
4940 #elif defined REL_ALLOC
4941 p
= r_alloc ((void **) &b
->text
->beg
, nbytes
);
4943 p
= xmalloc (nbytes
);
4949 memory_full (nbytes
);
4956 /* Enlarge buffer B's text buffer by DELTA bytes. DELTA < 0 means
4960 enlarge_buffer_text (struct buffer
*b
, ptrdiff_t delta
)
4963 ptrdiff_t nbytes
= (BUF_Z_BYTE (b
) - BUF_BEG_BYTE (b
) + BUF_GAP_SIZE (b
) + 1
4966 #if defined USE_MMAP_FOR_BUFFERS
4967 p
= mmap_realloc ((void **) &b
->text
->beg
, nbytes
);
4968 #elif defined REL_ALLOC
4969 p
= r_re_alloc ((void **) &b
->text
->beg
, nbytes
);
4971 p
= xrealloc (b
->text
->beg
, nbytes
);
4977 memory_full (nbytes
);
4980 BUF_BEG_ADDR (b
) = p
;
4985 /* Free buffer B's text buffer. */
4988 free_buffer_text (struct buffer
*b
)
4992 #if defined USE_MMAP_FOR_BUFFERS
4993 mmap_free ((void **) &b
->text
->beg
);
4994 #elif defined REL_ALLOC
4995 r_alloc_free ((void **) &b
->text
->beg
);
4997 xfree (b
->text
->beg
);
5000 BUF_BEG_ADDR (b
) = NULL
;
5006 /***********************************************************************
5008 ***********************************************************************/
5011 init_buffer_once (void)
5015 memset (buffer_permanent_local_flags
, 0, sizeof buffer_permanent_local_flags
);
5017 /* 0 means not a lisp var, -1 means always local, else mask. */
5018 memset (&buffer_local_flags
, 0, sizeof buffer_local_flags
);
5019 bset_filename (&buffer_local_flags
, make_number (-1));
5020 bset_directory (&buffer_local_flags
, make_number (-1));
5021 bset_backed_up (&buffer_local_flags
, make_number (-1));
5022 bset_save_length (&buffer_local_flags
, make_number (-1));
5023 bset_auto_save_file_name (&buffer_local_flags
, make_number (-1));
5024 bset_read_only (&buffer_local_flags
, make_number (-1));
5025 bset_major_mode (&buffer_local_flags
, make_number (-1));
5026 bset_mode_name (&buffer_local_flags
, make_number (-1));
5027 bset_undo_list (&buffer_local_flags
, make_number (-1));
5028 bset_mark_active (&buffer_local_flags
, make_number (-1));
5029 bset_point_before_scroll (&buffer_local_flags
, make_number (-1));
5030 bset_file_truename (&buffer_local_flags
, make_number (-1));
5031 bset_invisibility_spec (&buffer_local_flags
, make_number (-1));
5032 bset_file_format (&buffer_local_flags
, make_number (-1));
5033 bset_auto_save_file_format (&buffer_local_flags
, make_number (-1));
5034 bset_display_count (&buffer_local_flags
, make_number (-1));
5035 bset_display_time (&buffer_local_flags
, make_number (-1));
5036 bset_enable_multibyte_characters (&buffer_local_flags
, make_number (-1));
5038 /* These used to be stuck at 0 by default, but now that the all-zero value
5039 means Qnil, we have to initialize them explicitly. */
5040 bset_name (&buffer_local_flags
, make_number (0));
5041 bset_mark (&buffer_local_flags
, make_number (0));
5042 bset_local_var_alist (&buffer_local_flags
, make_number (0));
5043 bset_keymap (&buffer_local_flags
, make_number (0));
5044 bset_downcase_table (&buffer_local_flags
, make_number (0));
5045 bset_upcase_table (&buffer_local_flags
, make_number (0));
5046 bset_case_canon_table (&buffer_local_flags
, make_number (0));
5047 bset_case_eqv_table (&buffer_local_flags
, make_number (0));
5048 bset_minor_modes (&buffer_local_flags
, make_number (0));
5049 bset_width_table (&buffer_local_flags
, make_number (0));
5050 bset_pt_marker (&buffer_local_flags
, make_number (0));
5051 bset_begv_marker (&buffer_local_flags
, make_number (0));
5052 bset_zv_marker (&buffer_local_flags
, make_number (0));
5053 bset_last_selected_window (&buffer_local_flags
, make_number (0));
5056 XSETFASTINT (BVAR (&buffer_local_flags
, mode_line_format
), idx
); ++idx
;
5057 XSETFASTINT (BVAR (&buffer_local_flags
, abbrev_mode
), idx
); ++idx
;
5058 XSETFASTINT (BVAR (&buffer_local_flags
, overwrite_mode
), idx
); ++idx
;
5059 XSETFASTINT (BVAR (&buffer_local_flags
, case_fold_search
), idx
); ++idx
;
5060 XSETFASTINT (BVAR (&buffer_local_flags
, auto_fill_function
), idx
); ++idx
;
5061 XSETFASTINT (BVAR (&buffer_local_flags
, selective_display
), idx
); ++idx
;
5062 XSETFASTINT (BVAR (&buffer_local_flags
, selective_display_ellipses
), idx
); ++idx
;
5063 XSETFASTINT (BVAR (&buffer_local_flags
, tab_width
), idx
); ++idx
;
5064 XSETFASTINT (BVAR (&buffer_local_flags
, truncate_lines
), idx
); ++idx
;
5065 XSETFASTINT (BVAR (&buffer_local_flags
, word_wrap
), idx
); ++idx
;
5066 XSETFASTINT (BVAR (&buffer_local_flags
, ctl_arrow
), idx
); ++idx
;
5067 XSETFASTINT (BVAR (&buffer_local_flags
, fill_column
), idx
); ++idx
;
5068 XSETFASTINT (BVAR (&buffer_local_flags
, left_margin
), idx
); ++idx
;
5069 XSETFASTINT (BVAR (&buffer_local_flags
, abbrev_table
), idx
); ++idx
;
5070 XSETFASTINT (BVAR (&buffer_local_flags
, display_table
), idx
); ++idx
;
5071 XSETFASTINT (BVAR (&buffer_local_flags
, syntax_table
), idx
); ++idx
;
5072 XSETFASTINT (BVAR (&buffer_local_flags
, cache_long_scans
), idx
); ++idx
;
5073 XSETFASTINT (BVAR (&buffer_local_flags
, category_table
), idx
); ++idx
;
5074 XSETFASTINT (BVAR (&buffer_local_flags
, bidi_display_reordering
), idx
); ++idx
;
5075 XSETFASTINT (BVAR (&buffer_local_flags
, bidi_paragraph_direction
), idx
); ++idx
;
5076 XSETFASTINT (BVAR (&buffer_local_flags
, buffer_file_coding_system
), idx
);
5077 /* Make this one a permanent local. */
5078 buffer_permanent_local_flags
[idx
++] = 1;
5079 XSETFASTINT (BVAR (&buffer_local_flags
, left_margin_cols
), idx
); ++idx
;
5080 XSETFASTINT (BVAR (&buffer_local_flags
, right_margin_cols
), idx
); ++idx
;
5081 XSETFASTINT (BVAR (&buffer_local_flags
, left_fringe_width
), idx
); ++idx
;
5082 XSETFASTINT (BVAR (&buffer_local_flags
, right_fringe_width
), idx
); ++idx
;
5083 XSETFASTINT (BVAR (&buffer_local_flags
, fringes_outside_margins
), idx
); ++idx
;
5084 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_bar_width
), idx
); ++idx
;
5085 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_bar_height
), idx
); ++idx
;
5086 XSETFASTINT (BVAR (&buffer_local_flags
, vertical_scroll_bar_type
), idx
); ++idx
;
5087 XSETFASTINT (BVAR (&buffer_local_flags
, horizontal_scroll_bar_type
), idx
); ++idx
;
5088 XSETFASTINT (BVAR (&buffer_local_flags
, indicate_empty_lines
), idx
); ++idx
;
5089 XSETFASTINT (BVAR (&buffer_local_flags
, indicate_buffer_boundaries
), idx
); ++idx
;
5090 XSETFASTINT (BVAR (&buffer_local_flags
, fringe_indicator_alist
), idx
); ++idx
;
5091 XSETFASTINT (BVAR (&buffer_local_flags
, fringe_cursor_alist
), idx
); ++idx
;
5092 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_up_aggressively
), idx
); ++idx
;
5093 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_down_aggressively
), idx
); ++idx
;
5094 XSETFASTINT (BVAR (&buffer_local_flags
, header_line_format
), idx
); ++idx
;
5095 XSETFASTINT (BVAR (&buffer_local_flags
, cursor_type
), idx
); ++idx
;
5096 XSETFASTINT (BVAR (&buffer_local_flags
, extra_line_spacing
), idx
); ++idx
;
5097 XSETFASTINT (BVAR (&buffer_local_flags
, cursor_in_non_selected_windows
), idx
); ++idx
;
5099 /* Need more room? */
5100 if (idx
>= MAX_PER_BUFFER_VARS
)
5102 last_per_buffer_idx
= idx
;
5104 /* Make sure all markable slots in buffer_defaults
5105 are initialized reasonably, so mark_buffer won't choke. */
5106 reset_buffer (&buffer_defaults
);
5107 eassert (NILP (BVAR (&buffer_defaults
, name
)));
5108 reset_buffer_local_variables (&buffer_defaults
, 1);
5109 eassert (NILP (BVAR (&buffer_local_symbols
, name
)));
5110 reset_buffer (&buffer_local_symbols
);
5111 reset_buffer_local_variables (&buffer_local_symbols
, 1);
5112 /* Prevent GC from getting confused. */
5113 buffer_defaults
.text
= &buffer_defaults
.own_text
;
5114 buffer_local_symbols
.text
= &buffer_local_symbols
.own_text
;
5115 /* No one will share the text with these buffers, but let's play it safe. */
5116 buffer_defaults
.indirections
= 0;
5117 buffer_local_symbols
.indirections
= 0;
5118 /* Likewise no one will display them. */
5119 buffer_defaults
.window_count
= 0;
5120 buffer_local_symbols
.window_count
= 0;
5121 set_buffer_intervals (&buffer_defaults
, NULL
);
5122 set_buffer_intervals (&buffer_local_symbols
, NULL
);
5123 /* This is not strictly necessary, but let's make them initialized. */
5124 bset_name (&buffer_defaults
, build_pure_c_string (" *buffer-defaults*"));
5125 bset_name (&buffer_local_symbols
, build_pure_c_string (" *buffer-local-symbols*"));
5126 BUFFER_PVEC_INIT (&buffer_defaults
);
5127 BUFFER_PVEC_INIT (&buffer_local_symbols
);
5129 /* Set up the default values of various buffer slots. */
5130 /* Must do these before making the first buffer! */
5132 /* real setup is done in bindings.el */
5133 bset_mode_line_format (&buffer_defaults
, build_pure_c_string ("%-"));
5134 bset_header_line_format (&buffer_defaults
, Qnil
);
5135 bset_abbrev_mode (&buffer_defaults
, Qnil
);
5136 bset_overwrite_mode (&buffer_defaults
, Qnil
);
5137 bset_case_fold_search (&buffer_defaults
, Qt
);
5138 bset_auto_fill_function (&buffer_defaults
, Qnil
);
5139 bset_selective_display (&buffer_defaults
, Qnil
);
5140 bset_selective_display_ellipses (&buffer_defaults
, Qt
);
5141 bset_abbrev_table (&buffer_defaults
, Qnil
);
5142 bset_display_table (&buffer_defaults
, Qnil
);
5143 bset_undo_list (&buffer_defaults
, Qnil
);
5144 bset_mark_active (&buffer_defaults
, Qnil
);
5145 bset_file_format (&buffer_defaults
, Qnil
);
5146 bset_auto_save_file_format (&buffer_defaults
, Qt
);
5147 set_buffer_overlays_before (&buffer_defaults
, NULL
);
5148 set_buffer_overlays_after (&buffer_defaults
, NULL
);
5149 buffer_defaults
.overlay_center
= BEG
;
5151 XSETFASTINT (BVAR (&buffer_defaults
, tab_width
), 8);
5152 bset_truncate_lines (&buffer_defaults
, Qnil
);
5153 bset_word_wrap (&buffer_defaults
, Qnil
);
5154 bset_ctl_arrow (&buffer_defaults
, Qt
);
5155 bset_bidi_display_reordering (&buffer_defaults
, Qt
);
5156 bset_bidi_paragraph_direction (&buffer_defaults
, Qnil
);
5157 bset_cursor_type (&buffer_defaults
, Qt
);
5158 bset_extra_line_spacing (&buffer_defaults
, Qnil
);
5159 bset_cursor_in_non_selected_windows (&buffer_defaults
, Qt
);
5161 bset_enable_multibyte_characters (&buffer_defaults
, Qt
);
5162 bset_buffer_file_coding_system (&buffer_defaults
, Qnil
);
5163 XSETFASTINT (BVAR (&buffer_defaults
, fill_column
), 70);
5164 XSETFASTINT (BVAR (&buffer_defaults
, left_margin
), 0);
5165 bset_cache_long_scans (&buffer_defaults
, Qt
);
5166 bset_file_truename (&buffer_defaults
, Qnil
);
5167 XSETFASTINT (BVAR (&buffer_defaults
, display_count
), 0);
5168 XSETFASTINT (BVAR (&buffer_defaults
, left_margin_cols
), 0);
5169 XSETFASTINT (BVAR (&buffer_defaults
, right_margin_cols
), 0);
5170 bset_left_fringe_width (&buffer_defaults
, Qnil
);
5171 bset_right_fringe_width (&buffer_defaults
, Qnil
);
5172 bset_fringes_outside_margins (&buffer_defaults
, Qnil
);
5173 bset_scroll_bar_width (&buffer_defaults
, Qnil
);
5174 bset_scroll_bar_height (&buffer_defaults
, Qnil
);
5175 bset_vertical_scroll_bar_type (&buffer_defaults
, Qt
);
5176 bset_horizontal_scroll_bar_type (&buffer_defaults
, Qt
);
5177 bset_indicate_empty_lines (&buffer_defaults
, Qnil
);
5178 bset_indicate_buffer_boundaries (&buffer_defaults
, Qnil
);
5179 bset_fringe_indicator_alist (&buffer_defaults
, Qnil
);
5180 bset_fringe_cursor_alist (&buffer_defaults
, Qnil
);
5181 bset_scroll_up_aggressively (&buffer_defaults
, Qnil
);
5182 bset_scroll_down_aggressively (&buffer_defaults
, Qnil
);
5183 bset_display_time (&buffer_defaults
, Qnil
);
5185 /* Assign the local-flags to the slots that have default values.
5186 The local flag is a bit that is used in the buffer
5187 to say that it has its own local value for the slot.
5188 The local flag bits are in the local_var_flags slot of the buffer. */
5190 /* Nothing can work if this isn't true. */
5191 { verify (sizeof (EMACS_INT
) == word_size
); }
5193 Vbuffer_alist
= Qnil
;
5197 QSFundamental
= build_pure_c_string ("Fundamental");
5199 DEFSYM (Qfundamental_mode
, "fundamental-mode");
5200 bset_major_mode (&buffer_defaults
, Qfundamental_mode
);
5202 DEFSYM (Qmode_class
, "mode-class");
5203 DEFSYM (Qprotected_field
, "protected-field");
5205 DEFSYM (Qpermanent_local
, "permanent-local");
5206 DEFSYM (Qkill_buffer_hook
, "kill-buffer-hook");
5207 Fput (Qkill_buffer_hook
, Qpermanent_local
, Qt
);
5209 /* Super-magic invisible buffer. */
5210 Vprin1_to_string_buffer
= Fget_buffer_create (build_pure_c_string (" prin1"));
5211 Vbuffer_alist
= Qnil
;
5213 Fset_buffer (Fget_buffer_create (build_pure_c_string ("*scratch*")));
5215 inhibit_modification_hooks
= 0;
5219 init_buffer (int initialized
)
5225 #ifdef USE_MMAP_FOR_BUFFERS
5231 /* These must be reset in the dumped Emacs, to avoid stale
5232 references to mmap'ed memory from before the dump.
5234 WINDOWSNT doesn't need this because it doesn't track mmap'ed
5235 regions by hand (see w32heap.c, which uses system APIs for
5236 that purpose), and thus doesn't use mmap_regions. */
5237 mmap_regions
= NULL
;
5241 /* The dumped buffers reference addresses of buffer text
5242 recorded by temacs, that cannot be used by the dumped Emacs.
5243 We map new memory for their text here.
5245 Implementation note: the buffers we carry from temacs are:
5246 " prin1", "*scratch*", " *Minibuf-0*", "*Messages*", and
5247 " *code-conversion-work*". They are created by
5248 init_buffer_once and init_window_once (which are not called
5249 in the dumped Emacs), and by the first call to coding.c routines. */
5252 b
->text
->beg
= NULL
;
5253 enlarge_buffer_text (b
, 0);
5260 /* Only buffers with allocated buffer text should be present at
5261 this point in temacs. */
5264 eassert (b
->text
->beg
!= NULL
);
5267 #else /* not USE_MMAP_FOR_BUFFERS */
5268 /* Avoid compiler warnings. */
5270 #endif /* USE_MMAP_FOR_BUFFERS */
5272 AUTO_STRING (scratch
, "*scratch*");
5273 Fset_buffer (Fget_buffer_create (scratch
));
5274 if (NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
)))
5275 Fset_buffer_multibyte (Qnil
);
5277 pwd
= emacs_get_current_dir_name ();
5281 fprintf (stderr
, "Error getting directory: %s\n",
5282 emacs_strerror (errno
));
5283 bset_directory (current_buffer
, Qnil
);
5287 /* Maybe this should really use some standard subroutine
5288 whose definition is filename syntax dependent. */
5290 if (!(IS_DIRECTORY_SEP (pwd
[len
- 1])))
5292 /* Grow buffer to add directory separator and '\0'. */
5293 pwd
= realloc (pwd
, len
+ 2);
5295 fatal ("get_current_dir_name: %s\n", strerror (errno
));
5296 pwd
[len
] = DIRECTORY_SEP
;
5297 pwd
[len
+ 1] = '\0';
5301 /* At this moment, we still don't know how to decode the directory
5302 name. So, we keep the bytes in unibyte form so that file I/O
5303 routines correctly get the original bytes. */
5304 bset_directory (current_buffer
, make_unibyte_string (pwd
, len
));
5306 /* Add /: to the front of the name
5307 if it would otherwise be treated as magic. */
5308 temp
= Ffind_file_name_handler (BVAR (current_buffer
, directory
), Qt
);
5310 /* If the default dir is just /, TEMP is non-nil
5311 because of the ange-ftp completion handler.
5312 However, it is not necessary to turn / into /:/.
5313 So avoid doing that. */
5314 && strcmp ("/", SSDATA (BVAR (current_buffer
, directory
))))
5316 AUTO_STRING (slash_colon
, "/:");
5317 bset_directory (current_buffer
,
5318 concat2 (slash_colon
,
5319 BVAR (current_buffer
, directory
)));
5323 temp
= get_minibuffer (0);
5324 bset_directory (XBUFFER (temp
), BVAR (current_buffer
, directory
));
5329 /* Similar to defvar_lisp but define a variable whose value is the
5330 Lisp_Object stored in the current buffer. LNAME is the Lisp-level
5331 variable name. VNAME is the name of the buffer slot. PREDICATE
5332 is nil for a general Lisp variable. If PREDICATE is non-nil, then
5333 only Lisp values that satisfies the PREDICATE are allowed (except
5334 that nil is allowed too). DOC is a dummy where you write the doc
5335 string as a comment. */
5337 #define DEFVAR_PER_BUFFER(lname, vname, predicate, doc) \
5339 static struct Lisp_Buffer_Objfwd bo_fwd; \
5340 defvar_per_buffer (&bo_fwd, lname, vname, predicate); \
5344 defvar_per_buffer (struct Lisp_Buffer_Objfwd
*bo_fwd
, const char *namestring
,
5345 Lisp_Object
*address
, Lisp_Object predicate
)
5347 struct Lisp_Symbol
*sym
;
5350 sym
= XSYMBOL (intern (namestring
));
5351 offset
= (char *)address
- (char *)current_buffer
;
5353 bo_fwd
->type
= Lisp_Fwd_Buffer_Obj
;
5354 bo_fwd
->offset
= offset
;
5355 bo_fwd
->predicate
= predicate
;
5356 sym
->declared_special
= 1;
5357 sym
->redirect
= SYMBOL_FORWARDED
;
5358 SET_SYMBOL_FWD (sym
, (union Lisp_Fwd
*) bo_fwd
);
5359 XSETSYMBOL (PER_BUFFER_SYMBOL (offset
), sym
);
5361 if (PER_BUFFER_IDX (offset
) == 0)
5362 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
5363 slot of buffer_local_flags. */
5368 /* Initialize the buffer routines. */
5370 syms_of_buffer (void)
5372 staticpro (&last_overlay_modification_hooks
);
5373 last_overlay_modification_hooks
5374 = Fmake_vector (make_number (10), Qnil
);
5376 staticpro (&QSFundamental
);
5377 staticpro (&Vbuffer_alist
);
5379 DEFSYM (Qchoice
, "choice");
5380 DEFSYM (Qleft
, "left");
5381 DEFSYM (Qright
, "right");
5382 DEFSYM (Qrange
, "range");
5384 DEFSYM (Qpermanent_local_hook
, "permanent-local-hook");
5385 DEFSYM (Qoverlayp
, "overlayp");
5386 DEFSYM (Qevaporate
, "evaporate");
5387 DEFSYM (Qmodification_hooks
, "modification-hooks");
5388 DEFSYM (Qinsert_in_front_hooks
, "insert-in-front-hooks");
5389 DEFSYM (Qinsert_behind_hooks
, "insert-behind-hooks");
5390 DEFSYM (Qget_file_buffer
, "get-file-buffer");
5391 DEFSYM (Qpriority
, "priority");
5392 DEFSYM (Qbefore_string
, "before-string");
5393 DEFSYM (Qafter_string
, "after-string");
5394 DEFSYM (Qfirst_change_hook
, "first-change-hook");
5395 DEFSYM (Qbefore_change_functions
, "before-change-functions");
5396 DEFSYM (Qafter_change_functions
, "after-change-functions");
5397 DEFSYM (Qkill_buffer_query_functions
, "kill-buffer-query-functions");
5399 DEFSYM (Qvertical_scroll_bar
, "vertical-scroll-bar");
5400 Fput (Qvertical_scroll_bar
, Qchoice
, list4 (Qnil
, Qt
, Qleft
, Qright
));
5401 DEFSYM (Qhorizontal_scroll_bar
, "horizontal-scroll-bar");
5403 DEFSYM (Qfraction
, "fraction");
5404 Fput (Qfraction
, Qrange
, Fcons (make_float (0.0), make_float (1.0)));
5406 DEFSYM (Qoverwrite_mode
, "overwrite-mode");
5407 Fput (Qoverwrite_mode
, Qchoice
,
5408 list3 (Qnil
, intern ("overwrite-mode-textual"),
5409 Qoverwrite_mode_binary
));
5411 Fput (Qprotected_field
, Qerror_conditions
,
5412 listn (CONSTYPE_PURE
, 2, Qprotected_field
, Qerror
));
5413 Fput (Qprotected_field
, Qerror_message
,
5414 build_pure_c_string ("Attempt to modify a protected field"));
5416 DEFVAR_BUFFER_DEFAULTS ("default-mode-line-format",
5418 doc
: /* Default value of `mode-line-format' for buffers that don't override it.
5419 This is the same as (default-value \\='mode-line-format). */);
5421 DEFVAR_BUFFER_DEFAULTS ("default-header-line-format",
5423 doc
: /* Default value of `header-line-format' for buffers that don't override it.
5424 This is the same as (default-value \\='header-line-format). */);
5426 DEFVAR_BUFFER_DEFAULTS ("default-cursor-type", cursor_type
,
5427 doc
: /* Default value of `cursor-type' for buffers that don't override it.
5428 This is the same as (default-value \\='cursor-type). */);
5430 DEFVAR_BUFFER_DEFAULTS ("default-line-spacing",
5432 doc
: /* Default value of `line-spacing' for buffers that don't override it.
5433 This is the same as (default-value \\='line-spacing). */);
5435 DEFVAR_BUFFER_DEFAULTS ("default-cursor-in-non-selected-windows",
5436 cursor_in_non_selected_windows
,
5437 doc
: /* Default value of `cursor-in-non-selected-windows'.
5438 This is the same as (default-value \\='cursor-in-non-selected-windows). */);
5440 DEFVAR_BUFFER_DEFAULTS ("default-abbrev-mode",
5442 doc
: /* Default value of `abbrev-mode' for buffers that do not override it.
5443 This is the same as (default-value \\='abbrev-mode). */);
5445 DEFVAR_BUFFER_DEFAULTS ("default-ctl-arrow",
5447 doc
: /* Default value of `ctl-arrow' for buffers that do not override it.
5448 This is the same as (default-value \\='ctl-arrow). */);
5450 DEFVAR_BUFFER_DEFAULTS ("default-enable-multibyte-characters",
5451 enable_multibyte_characters
,
5452 doc
: /* Default value of `enable-multibyte-characters' for buffers not overriding it.
5453 This is the same as (default-value \\='enable-multibyte-characters). */);
5455 DEFVAR_BUFFER_DEFAULTS ("default-buffer-file-coding-system",
5456 buffer_file_coding_system
,
5457 doc
: /* Default value of `buffer-file-coding-system' for buffers not overriding it.
5458 This is the same as (default-value \\='buffer-file-coding-system). */);
5460 DEFVAR_BUFFER_DEFAULTS ("default-truncate-lines",
5462 doc
: /* Default value of `truncate-lines' for buffers that do not override it.
5463 This is the same as (default-value \\='truncate-lines). */);
5465 DEFVAR_BUFFER_DEFAULTS ("default-fill-column",
5467 doc
: /* Default value of `fill-column' for buffers that do not override it.
5468 This is the same as (default-value \\='fill-column). */);
5470 DEFVAR_BUFFER_DEFAULTS ("default-left-margin",
5472 doc
: /* Default value of `left-margin' for buffers that do not override it.
5473 This is the same as (default-value \\='left-margin). */);
5475 DEFVAR_BUFFER_DEFAULTS ("default-tab-width",
5477 doc
: /* Default value of `tab-width' for buffers that do not override it.
5478 NOTE: This controls the display width of a TAB character, and not
5479 the size of an indentation step.
5480 This is the same as (default-value \\='tab-width). */);
5482 DEFVAR_BUFFER_DEFAULTS ("default-case-fold-search",
5484 doc
: /* Default value of `case-fold-search' for buffers that don't override it.
5485 This is the same as (default-value \\='case-fold-search). */);
5487 DEFVAR_BUFFER_DEFAULTS ("default-left-margin-width",
5489 doc
: /* Default value of `left-margin-width' for buffers that don't override it.
5490 This is the same as (default-value \\='left-margin-width). */);
5492 DEFVAR_BUFFER_DEFAULTS ("default-right-margin-width",
5494 doc
: /* Default value of `right-margin-width' for buffers that don't override it.
5495 This is the same as (default-value \\='right-margin-width). */);
5497 DEFVAR_BUFFER_DEFAULTS ("default-left-fringe-width",
5499 doc
: /* Default value of `left-fringe-width' for buffers that don't override it.
5500 This is the same as (default-value \\='left-fringe-width). */);
5502 DEFVAR_BUFFER_DEFAULTS ("default-right-fringe-width",
5504 doc
: /* Default value of `right-fringe-width' for buffers that don't override it.
5505 This is the same as (default-value \\='right-fringe-width). */);
5507 DEFVAR_BUFFER_DEFAULTS ("default-fringes-outside-margins",
5508 fringes_outside_margins
,
5509 doc
: /* Default value of `fringes-outside-margins' for buffers that don't override it.
5510 This is the same as (default-value \\='fringes-outside-margins). */);
5512 DEFVAR_BUFFER_DEFAULTS ("default-scroll-bar-width",
5514 doc
: /* Default value of `scroll-bar-width' for buffers that don't override it.
5515 This is the same as (default-value \\='scroll-bar-width). */);
5517 DEFVAR_BUFFER_DEFAULTS ("default-vertical-scroll-bar",
5518 vertical_scroll_bar_type
,
5519 doc
: /* Default value of `vertical-scroll-bar' for buffers that don't override it.
5520 This is the same as (default-value \\='vertical-scroll-bar). */);
5522 DEFVAR_BUFFER_DEFAULTS ("default-indicate-empty-lines",
5523 indicate_empty_lines
,
5524 doc
: /* Default value of `indicate-empty-lines' for buffers that don't override it.
5525 This is the same as (default-value \\='indicate-empty-lines). */);
5527 DEFVAR_BUFFER_DEFAULTS ("default-indicate-buffer-boundaries",
5528 indicate_buffer_boundaries
,
5529 doc
: /* Default value of `indicate-buffer-boundaries' for buffers that don't override it.
5530 This is the same as (default-value \\='indicate-buffer-boundaries). */);
5532 DEFVAR_BUFFER_DEFAULTS ("default-fringe-indicator-alist",
5533 fringe_indicator_alist
,
5534 doc
: /* Default value of `fringe-indicator-alist' for buffers that don't override it.
5535 This is the same as (default-value \\='fringe-indicator-alist). */);
5537 DEFVAR_BUFFER_DEFAULTS ("default-fringe-cursor-alist",
5538 fringe_cursor_alist
,
5539 doc
: /* Default value of `fringe-cursor-alist' for buffers that don't override it.
5540 This is the same as (default-value \\='fringe-cursor-alist). */);
5542 DEFVAR_BUFFER_DEFAULTS ("default-scroll-up-aggressively",
5543 scroll_up_aggressively
,
5544 doc
: /* Default value of `scroll-up-aggressively'.
5545 This value applies in buffers that don't have their own local values.
5546 This is the same as (default-value \\='scroll-up-aggressively). */);
5548 DEFVAR_BUFFER_DEFAULTS ("default-scroll-down-aggressively",
5549 scroll_down_aggressively
,
5550 doc
: /* Default value of `scroll-down-aggressively'.
5551 This value applies in buffers that don't have their own local values.
5552 This is the same as (default-value \\='scroll-down-aggressively). */);
5554 DEFVAR_PER_BUFFER ("header-line-format",
5555 &BVAR (current_buffer
, header_line_format
),
5557 doc
: /* Analogous to `mode-line-format', but controls the header line.
5558 The header line appears, optionally, at the top of a window;
5559 the mode line appears at the bottom. */);
5561 DEFVAR_PER_BUFFER ("mode-line-format", &BVAR (current_buffer
, mode_line_format
),
5563 doc
: /* Template for displaying mode line for current buffer.
5565 The value may be nil, a string, a symbol or a list.
5567 A value of nil means don't display a mode line.
5569 For any symbol other than t or nil, the symbol's value is processed as
5570 a mode line construct. As a special exception, if that value is a
5571 string, the string is processed verbatim, without handling any
5572 %-constructs (see below). Also, unless the symbol has a non-nil
5573 `risky-local-variable' property, all properties in any strings, as
5574 well as all :eval and :propertize forms in the value, are ignored.
5576 A list whose car is a string or list is processed by processing each
5577 of the list elements recursively, as separate mode line constructs,
5578 and concatenating the results.
5580 A list of the form `(:eval FORM)' is processed by evaluating FORM and
5581 using the result as a mode line construct. Be careful--FORM should
5582 not load any files, because that can cause an infinite recursion.
5584 A list of the form `(:propertize ELT PROPS...)' is processed by
5585 processing ELT as the mode line construct, and adding the text
5586 properties PROPS to the result.
5588 A list whose car is a symbol is processed by examining the symbol's
5589 value, and, if that value is non-nil, processing the cadr of the list
5590 recursively; and if that value is nil, processing the caddr of the
5593 A list whose car is an integer is processed by processing the cadr of
5594 the list, and padding (if the number is positive) or truncating (if
5595 negative) to the width specified by that number.
5597 A string is printed verbatim in the mode line except for %-constructs:
5598 %b -- print buffer name. %f -- print visited file name.
5599 %F -- print frame name.
5600 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
5601 %& is like %*, but ignore read-only-ness.
5602 % means buffer is read-only and * means it is modified.
5603 For a modified read-only buffer, %* gives % and %+ gives *.
5604 %s -- print process status. %l -- print the current line number.
5605 %c -- print the current column number (this makes editing slower).
5606 To make the column number update correctly in all cases,
5607 `column-number-mode' must be non-nil.
5608 %i -- print the size of the buffer.
5609 %I -- like %i, but use k, M, G, etc., to abbreviate.
5610 %p -- print percent of buffer above top of window, or Top, Bot or All.
5611 %P -- print percent of buffer above bottom of window, perhaps plus Top,
5612 or print Bottom or All.
5613 %n -- print Narrow if appropriate.
5614 %t -- visited file is text or binary (if OS supports this distinction).
5615 %z -- print mnemonics of keyboard, terminal, and buffer coding systems.
5616 %Z -- like %z, but including the end-of-line format.
5617 %e -- print error message about full memory.
5618 %@ -- print @ or hyphen. @ means that default-directory is on a
5620 %[ -- print one [ for each recursive editing level. %] similar.
5621 %% -- print %. %- -- print infinitely many dashes.
5622 Decimal digits after the % specify field width to which to pad. */);
5624 DEFVAR_BUFFER_DEFAULTS ("default-major-mode", major_mode
,
5625 doc
: /* Value of `major-mode' for new buffers. */);
5627 DEFVAR_PER_BUFFER ("major-mode", &BVAR (current_buffer
, major_mode
),
5629 doc
: /* Symbol for current buffer's major mode.
5630 The default value (normally `fundamental-mode') affects new buffers.
5631 A value of nil means to use the current buffer's major mode, provided
5632 it is not marked as "special". */);
5634 DEFVAR_PER_BUFFER ("mode-name", &BVAR (current_buffer
, mode_name
),
5636 doc
: /* Pretty name of current buffer's major mode.
5637 Usually a string, but can use any of the constructs for `mode-line-format',
5639 Format with `format-mode-line' to produce a string value. */);
5641 DEFVAR_PER_BUFFER ("local-abbrev-table", &BVAR (current_buffer
, abbrev_table
), Qnil
,
5642 doc
: /* Local (mode-specific) abbrev table of current buffer. */);
5644 DEFVAR_PER_BUFFER ("abbrev-mode", &BVAR (current_buffer
, abbrev_mode
), Qnil
,
5645 doc
: /* Non-nil if Abbrev mode is enabled.
5646 Use the command `abbrev-mode' to change this variable. */);
5648 DEFVAR_PER_BUFFER ("case-fold-search", &BVAR (current_buffer
, case_fold_search
),
5650 doc
: /* Non-nil if searches and matches should ignore case. */);
5652 DEFVAR_PER_BUFFER ("fill-column", &BVAR (current_buffer
, fill_column
),
5654 doc
: /* Column beyond which automatic line-wrapping should happen.
5655 Interactively, you can set the buffer local value using \\[set-fill-column]. */);
5657 DEFVAR_PER_BUFFER ("left-margin", &BVAR (current_buffer
, left_margin
),
5659 doc
: /* Column for the default `indent-line-function' to indent to.
5660 Linefeed indents to this column in Fundamental mode. */);
5662 DEFVAR_PER_BUFFER ("tab-width", &BVAR (current_buffer
, tab_width
),
5664 doc
: /* Distance between tab stops (for display of tab characters), in columns.
5665 NOTE: This controls the display width of a TAB character, and not
5666 the size of an indentation step.
5667 This should be an integer greater than zero. */);
5669 DEFVAR_PER_BUFFER ("ctl-arrow", &BVAR (current_buffer
, ctl_arrow
), Qnil
,
5670 doc
: /* Non-nil means display control chars with uparrow.
5671 A value of nil means use backslash and octal digits.
5672 This variable does not apply to characters whose display is specified
5673 in the current display table (if there is one). */);
5675 DEFVAR_PER_BUFFER ("enable-multibyte-characters",
5676 &BVAR (current_buffer
, enable_multibyte_characters
),
5678 doc
: /* Non-nil means the buffer contents are regarded as multi-byte characters.
5679 Otherwise they are regarded as unibyte. This affects the display,
5680 file I/O and the behavior of various editing commands.
5682 This variable is buffer-local but you cannot set it directly;
5683 use the function `set-buffer-multibyte' to change a buffer's representation.
5684 See also Info node `(elisp)Text Representations'. */);
5685 XSYMBOL (intern_c_string ("enable-multibyte-characters"))->constant
= 1;
5687 DEFVAR_PER_BUFFER ("buffer-file-coding-system",
5688 &BVAR (current_buffer
, buffer_file_coding_system
), Qnil
,
5689 doc
: /* Coding system to be used for encoding the buffer contents on saving.
5690 This variable applies to saving the buffer, and also to `write-region'
5691 and other functions that use `write-region'.
5692 It does not apply to sending output to subprocesses, however.
5694 If this is nil, the buffer is saved without any code conversion
5695 unless some coding system is specified in `file-coding-system-alist'
5696 for the buffer file.
5698 If the text to be saved cannot be encoded as specified by this variable,
5699 an alternative encoding is selected by `select-safe-coding-system', which see.
5701 The variable `coding-system-for-write', if non-nil, overrides this variable.
5703 This variable is never applied to a way of decoding a file while reading it. */);
5705 DEFVAR_PER_BUFFER ("bidi-display-reordering",
5706 &BVAR (current_buffer
, bidi_display_reordering
), Qnil
,
5707 doc
: /* Non-nil means reorder bidirectional text for display in the visual order. */);
5709 DEFVAR_PER_BUFFER ("bidi-paragraph-direction",
5710 &BVAR (current_buffer
, bidi_paragraph_direction
), Qnil
,
5711 doc
: /* If non-nil, forces directionality of text paragraphs in the buffer.
5713 If this is nil (the default), the direction of each paragraph is
5714 determined by the first strong directional character of its text.
5715 The values of `right-to-left' and `left-to-right' override that.
5716 Any other value is treated as nil.
5718 This variable has no effect unless the buffer's value of
5719 `bidi-display-reordering' is non-nil. */);
5721 DEFVAR_PER_BUFFER ("truncate-lines", &BVAR (current_buffer
, truncate_lines
), Qnil
,
5722 doc
: /* Non-nil means do not display continuation lines.
5723 Instead, give each line of text just one screen line.
5725 Note that this is overridden by the variable
5726 `truncate-partial-width-windows' if that variable is non-nil
5727 and this buffer is not full-frame width.
5729 Minibuffers set this variable to nil. */);
5731 DEFVAR_PER_BUFFER ("word-wrap", &BVAR (current_buffer
, word_wrap
), Qnil
,
5732 doc
: /* Non-nil means to use word-wrapping for continuation lines.
5733 When word-wrapping is on, continuation lines are wrapped at the space
5734 or tab character nearest to the right window edge.
5735 If nil, continuation lines are wrapped at the right screen edge.
5737 This variable has no effect if long lines are truncated (see
5738 `truncate-lines' and `truncate-partial-width-windows'). If you use
5739 word-wrapping, you might want to reduce the value of
5740 `truncate-partial-width-windows', since wrapping can make text readable
5741 in narrower windows.
5743 Instead of setting this variable directly, most users should use
5744 Visual Line mode . Visual Line mode, when enabled, sets `word-wrap'
5745 to t, and additionally redefines simple editing commands to act on
5746 visual lines rather than logical lines. See the documentation of
5747 `visual-line-mode'. */);
5749 DEFVAR_PER_BUFFER ("default-directory", &BVAR (current_buffer
, directory
),
5751 doc
: /* Name of default directory of current buffer.
5752 To interactively change the default directory, use command `cd'. */);
5754 DEFVAR_PER_BUFFER ("auto-fill-function", &BVAR (current_buffer
, auto_fill_function
),
5756 doc
: /* Function called (if non-nil) to perform auto-fill.
5757 It is called after self-inserting any character specified in
5758 the `auto-fill-chars' table.
5759 NOTE: This variable is not a hook;
5760 its value may not be a list of functions. */);
5762 DEFVAR_PER_BUFFER ("buffer-file-name", &BVAR (current_buffer
, filename
),
5764 doc
: /* Name of file visited in current buffer, or nil if not visiting a file.
5765 This should be an absolute file name. */);
5767 DEFVAR_PER_BUFFER ("buffer-file-truename", &BVAR (current_buffer
, file_truename
),
5769 doc
: /* Abbreviated truename of file visited in current buffer, or nil if none.
5770 The truename of a file is calculated by `file-truename'
5771 and then abbreviated with `abbreviate-file-name'. */);
5773 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
5774 &BVAR (current_buffer
, auto_save_file_name
),
5776 doc
: /* Name of file for auto-saving current buffer.
5777 If it is nil, that means don't auto-save this buffer. */);
5779 DEFVAR_PER_BUFFER ("buffer-read-only", &BVAR (current_buffer
, read_only
), Qnil
,
5780 doc
: /* Non-nil if this buffer is read-only. */);
5782 DEFVAR_PER_BUFFER ("buffer-backed-up", &BVAR (current_buffer
, backed_up
), Qnil
,
5783 doc
: /* Non-nil if this buffer's file has been backed up.
5784 Backing up is done before the first time the file is saved. */);
5786 DEFVAR_PER_BUFFER ("buffer-saved-size", &BVAR (current_buffer
, save_length
),
5788 doc
: /* Length of current buffer when last read in, saved or auto-saved.
5790 -1 means auto-saving turned off until next real save.
5792 If you set this to -2, that means don't turn off auto-saving in this buffer
5793 if its text size shrinks. If you use `buffer-swap-text' on a buffer,
5794 you probably should set this to -2 in that buffer. */);
5796 DEFVAR_PER_BUFFER ("selective-display", &BVAR (current_buffer
, selective_display
),
5798 doc
: /* Non-nil enables selective display.
5800 An integer N as value means display only lines
5801 that start with less than N columns of space.
5803 A value of t means that the character ^M makes itself and
5804 all the rest of the line invisible; also, when saving the buffer
5805 in a file, save the ^M as a newline. This usage is obsolete; use
5806 overlays or text properties instead. */);
5808 DEFVAR_PER_BUFFER ("selective-display-ellipses",
5809 &BVAR (current_buffer
, selective_display_ellipses
),
5811 doc
: /* Non-nil means display ... on previous line when a line is invisible. */);
5813 DEFVAR_PER_BUFFER ("overwrite-mode", &BVAR (current_buffer
, overwrite_mode
),
5815 doc
: /* Non-nil if self-insertion should replace existing text.
5816 The value should be one of `overwrite-mode-textual',
5817 `overwrite-mode-binary', or nil.
5818 If it is `overwrite-mode-textual', self-insertion still
5819 inserts at the end of a line, and inserts when point is before a tab,
5820 until the tab is filled in.
5821 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too. */);
5823 DEFVAR_PER_BUFFER ("buffer-display-table", &BVAR (current_buffer
, display_table
),
5825 doc
: /* Display table that controls display of the contents of current buffer.
5827 If this variable is nil, the value of `standard-display-table' is used.
5828 Each window can have its own, overriding display table, see
5829 `set-window-display-table' and `window-display-table'.
5831 The display table is a char-table created with `make-display-table'.
5832 A char-table is an array indexed by character codes. Normal array
5833 primitives `aref' and `aset' can be used to access elements of a char-table.
5835 Each of the char-table elements control how to display the corresponding
5836 text character: the element at index C in the table says how to display
5837 the character whose code is C. Each element should be a vector of
5838 characters or nil. The value nil means display the character in the
5839 default fashion; otherwise, the characters from the vector are delivered
5840 to the screen instead of the original character.
5842 For example, (aset buffer-display-table ?X [?Y]) tells Emacs
5843 to display a capital Y instead of each X character.
5845 In addition, a char-table has six extra slots to control the display of:
5847 the end of a truncated screen line (extra-slot 0, a single character);
5848 the end of a continued line (extra-slot 1, a single character);
5849 the escape character used to display character codes in octal
5850 (extra-slot 2, a single character);
5851 the character used as an arrow for control characters (extra-slot 3,
5852 a single character);
5853 the decoration indicating the presence of invisible lines (extra-slot 4,
5854 a vector of characters);
5855 the character used to draw the border between side-by-side windows
5856 (extra-slot 5, a single character).
5858 See also the functions `display-table-slot' and `set-display-table-slot'. */);
5860 DEFVAR_PER_BUFFER ("left-margin-width", &BVAR (current_buffer
, left_margin_cols
),
5862 doc
: /* Width in columns of left marginal area for display of a buffer.
5863 A value of nil means no marginal area.
5865 Setting this variable does not take effect until a new buffer is displayed
5866 in a window. To make the change take effect, call `set-window-buffer'. */);
5868 DEFVAR_PER_BUFFER ("right-margin-width", &BVAR (current_buffer
, right_margin_cols
),
5870 doc
: /* Width in columns of right marginal area for display of a buffer.
5871 A value of nil means no marginal area.
5873 Setting this variable does not take effect until a new buffer is displayed
5874 in a window. To make the change take effect, call `set-window-buffer'. */);
5876 DEFVAR_PER_BUFFER ("left-fringe-width", &BVAR (current_buffer
, left_fringe_width
),
5878 doc
: /* Width of this buffer's left fringe (in pixels).
5879 A value of 0 means no left fringe is shown in this buffer's window.
5880 A value of nil means to use the left fringe width from the window's frame.
5882 Setting this variable does not take effect until a new buffer is displayed
5883 in a window. To make the change take effect, call `set-window-buffer'. */);
5885 DEFVAR_PER_BUFFER ("right-fringe-width", &BVAR (current_buffer
, right_fringe_width
),
5887 doc
: /* Width of this buffer's right fringe (in pixels).
5888 A value of 0 means no right fringe is shown in this buffer's window.
5889 A value of nil means to use the right fringe width from the window's frame.
5891 Setting this variable does not take effect until a new buffer is displayed
5892 in a window. To make the change take effect, call `set-window-buffer'. */);
5894 DEFVAR_PER_BUFFER ("fringes-outside-margins", &BVAR (current_buffer
, fringes_outside_margins
),
5896 doc
: /* Non-nil means to display fringes outside display margins.
5897 A value of nil means to display fringes between margins and buffer text.
5899 Setting this variable does not take effect until a new buffer is displayed
5900 in a window. To make the change take effect, call `set-window-buffer'. */);
5902 DEFVAR_PER_BUFFER ("scroll-bar-width", &BVAR (current_buffer
, scroll_bar_width
),
5904 doc
: /* Width of this buffer's vertical scroll bars in pixels.
5905 A value of nil means to use the scroll bar width from the window's frame. */);
5907 DEFVAR_PER_BUFFER ("scroll-bar-height", &BVAR (current_buffer
, scroll_bar_height
),
5909 doc
: /* Height of this buffer's horizontal scroll bars in pixels.
5910 A value of nil means to use the scroll bar height from the window's frame. */);
5912 DEFVAR_PER_BUFFER ("vertical-scroll-bar", &BVAR (current_buffer
, vertical_scroll_bar_type
),
5913 Qvertical_scroll_bar
,
5914 doc
: /* Position of this buffer's vertical scroll bar.
5915 The value takes effect whenever you tell a window to display this buffer;
5916 for instance, with `set-window-buffer' or when `display-buffer' displays it.
5918 A value of `left' or `right' means put the vertical scroll bar at that side
5919 of the window; a value of nil means don't show any vertical scroll bars.
5920 A value of t (the default) means do whatever the window's frame specifies. */);
5922 DEFVAR_PER_BUFFER ("horizontal-scroll-bar", &BVAR (current_buffer
, horizontal_scroll_bar_type
),
5924 doc
: /* Position of this buffer's horizontal scroll bar.
5925 The value takes effect whenever you tell a window to display this buffer;
5926 for instance, with `set-window-buffer' or when `display-buffer' displays it.
5928 A value of `bottom' means put the horizontal scroll bar at the bottom of
5929 the window; a value of nil means don't show any horizontal scroll bars.
5930 A value of t (the default) means do whatever the window's frame
5933 DEFVAR_PER_BUFFER ("indicate-empty-lines",
5934 &BVAR (current_buffer
, indicate_empty_lines
), Qnil
,
5935 doc
: /* Visually indicate empty lines after the buffer end.
5936 If non-nil, a bitmap is displayed in the left fringe of a window on
5937 window-systems. */);
5939 DEFVAR_PER_BUFFER ("indicate-buffer-boundaries",
5940 &BVAR (current_buffer
, indicate_buffer_boundaries
), Qnil
,
5941 doc
: /* Visually indicate buffer boundaries and scrolling.
5942 If non-nil, the first and last line of the buffer are marked in the fringe
5943 of a window on window-systems with angle bitmaps, or if the window can be
5944 scrolled, the top and bottom line of the window are marked with up and down
5947 If value is a symbol `left' or `right', both angle and arrow bitmaps
5948 are displayed in the left or right fringe, resp. Any other value
5949 that doesn't look like an alist means display the angle bitmaps in
5950 the left fringe but no arrows.
5952 You can exercise more precise control by using an alist as the
5953 value. Each alist element (INDICATOR . POSITION) specifies
5954 where to show one of the indicators. INDICATOR is one of `top',
5955 `bottom', `up', `down', or t, which specifies the default position,
5956 and POSITION is one of `left', `right', or nil, meaning do not show
5959 For example, ((top . left) (t . right)) places the top angle bitmap in
5960 left fringe, the bottom angle bitmap in right fringe, and both arrow
5961 bitmaps in right fringe. To show just the angle bitmaps in the left
5962 fringe, but no arrow bitmaps, use ((top . left) (bottom . left)). */);
5964 DEFVAR_PER_BUFFER ("fringe-indicator-alist",
5965 &BVAR (current_buffer
, fringe_indicator_alist
), Qnil
,
5966 doc
: /* Mapping from logical to physical fringe indicator bitmaps.
5967 The value is an alist where each element (INDICATOR . BITMAPS)
5968 specifies the fringe bitmaps used to display a specific logical
5971 INDICATOR specifies the logical indicator type which is one of the
5972 following symbols: `truncation' , `continuation', `overlay-arrow',
5973 `top', `bottom', `top-bottom', `up', `down', empty-line', or `unknown'.
5975 BITMAPS is a list of symbols (LEFT RIGHT [LEFT1 RIGHT1]) which specifies
5976 the actual bitmap shown in the left or right fringe for the logical
5977 indicator. LEFT and RIGHT are the bitmaps shown in the left and/or
5978 right fringe for the specific indicator. The LEFT1 or RIGHT1 bitmaps
5979 are used only for the `bottom' and `top-bottom' indicators when the
5980 last (only) line has no final newline. BITMAPS may also be a single
5981 symbol which is used in both left and right fringes. */);
5983 DEFVAR_PER_BUFFER ("fringe-cursor-alist",
5984 &BVAR (current_buffer
, fringe_cursor_alist
), Qnil
,
5985 doc
: /* Mapping from logical to physical fringe cursor bitmaps.
5986 The value is an alist where each element (CURSOR . BITMAP)
5987 specifies the fringe bitmaps used to display a specific logical
5988 cursor type in the fringe.
5990 CURSOR specifies the logical cursor type which is one of the following
5991 symbols: `box' , `hollow', `bar', `hbar', or `hollow-small'. The last
5992 one is used to show a hollow cursor on narrow lines display lines
5993 where the normal hollow cursor will not fit.
5995 BITMAP is the corresponding fringe bitmap shown for the logical
5998 DEFVAR_PER_BUFFER ("scroll-up-aggressively",
5999 &BVAR (current_buffer
, scroll_up_aggressively
), Qfraction
,
6000 doc
: /* How far to scroll windows upward.
6001 If you move point off the bottom, the window scrolls automatically.
6002 This variable controls how far it scrolls. The value nil, the default,
6003 means scroll to center point. A fraction means scroll to put point
6004 that fraction of the window's height from the bottom of the window.
6005 When the value is 0.0, point goes at the bottom line, which in the
6006 simple case that you moved off with C-f means scrolling just one line.
6007 1.0 means point goes at the top, so that in that simple case, the
6008 window scrolls by a full window height. Meaningful values are
6009 between 0.0 and 1.0, inclusive. */);
6011 DEFVAR_PER_BUFFER ("scroll-down-aggressively",
6012 &BVAR (current_buffer
, scroll_down_aggressively
), Qfraction
,
6013 doc
: /* How far to scroll windows downward.
6014 If you move point off the top, the window scrolls automatically.
6015 This variable controls how far it scrolls. The value nil, the default,
6016 means scroll to center point. A fraction means scroll to put point
6017 that fraction of the window's height from the top of the window.
6018 When the value is 0.0, point goes at the top line, which in the
6019 simple case that you moved off with C-b means scrolling just one line.
6020 1.0 means point goes at the bottom, so that in that simple case, the
6021 window scrolls by a full window height. Meaningful values are
6022 between 0.0 and 1.0, inclusive. */);
6024 DEFVAR_LISP ("before-change-functions", Vbefore_change_functions
,
6025 doc
: /* List of functions to call before each text change.
6026 Two arguments are passed to each function: the positions of
6027 the beginning and end of the range of old text to be changed.
6028 \(For an insertion, the beginning and end are at the same place.)
6029 No information is given about the length of the text after the change.
6031 Buffer changes made while executing the `before-change-functions'
6032 don't call any before-change or after-change functions.
6033 That's because `inhibit-modification-hooks' is temporarily set non-nil.
6035 If an unhandled error happens in running these functions,
6036 the variable's value remains nil. That prevents the error
6037 from happening repeatedly and making Emacs nonfunctional. */);
6038 Vbefore_change_functions
= Qnil
;
6040 DEFVAR_LISP ("after-change-functions", Vafter_change_functions
,
6041 doc
: /* List of functions to call after each text change.
6042 Three arguments are passed to each function: the positions of
6043 the beginning and end of the range of changed text,
6044 and the length in chars of the pre-change text replaced by that range.
6045 \(For an insertion, the pre-change length is zero;
6046 for a deletion, that length is the number of chars deleted,
6047 and the post-change beginning and end are at the same place.)
6049 Buffer changes made while executing the `after-change-functions'
6050 don't call any before-change or after-change functions.
6051 That's because `inhibit-modification-hooks' is temporarily set non-nil.
6053 If an unhandled error happens in running these functions,
6054 the variable's value remains nil. That prevents the error
6055 from happening repeatedly and making Emacs nonfunctional. */);
6056 Vafter_change_functions
= Qnil
;
6058 DEFVAR_LISP ("first-change-hook", Vfirst_change_hook
,
6059 doc
: /* A list of functions to call before changing a buffer which is unmodified.
6060 The functions are run using the `run-hooks' function. */);
6061 Vfirst_change_hook
= Qnil
;
6063 DEFVAR_PER_BUFFER ("buffer-undo-list", &BVAR (current_buffer
, undo_list
), Qnil
,
6064 doc
: /* List of undo entries in current buffer.
6065 Recent changes come first; older changes follow newer.
6067 An entry (BEG . END) represents an insertion which begins at
6068 position BEG and ends at position END.
6070 An entry (TEXT . POSITION) represents the deletion of the string TEXT
6071 from (abs POSITION). If POSITION is positive, point was at the front
6072 of the text being deleted; if negative, point was at the end.
6074 An entry (t HIGH LOW USEC PSEC) indicates that the buffer was previously
6075 unmodified; (HIGH LOW USEC PSEC) is in the same style as (current-time)
6076 and is the visited file's modification time, as of that time. If the
6077 modification time of the most recent save is different, this entry is
6080 An entry (t . 0) means means the buffer was previously unmodified but
6081 its time stamp was unknown because it was not associated with a file.
6082 An entry (t . -1) is similar, except that it means the buffer's visited
6085 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
6086 was modified between BEG and END. PROPERTY is the property name,
6087 and VALUE is the old value.
6089 An entry (apply FUN-NAME . ARGS) means undo the change with
6090 \(apply FUN-NAME ARGS).
6092 An entry (apply DELTA BEG END FUN-NAME . ARGS) supports selective undo
6093 in the active region. BEG and END is the range affected by this entry
6094 and DELTA is the number of characters added or deleted in that range by
6097 An entry (MARKER . DISTANCE) indicates that the marker MARKER
6098 was adjusted in position by the offset DISTANCE (an integer).
6100 An entry of the form POSITION indicates that point was at the buffer
6101 location given by the integer. Undoing an entry of this form places
6104 Entries with value nil mark undo boundaries. The undo command treats
6105 the changes between two undo boundaries as a single step to be undone.
6107 If the value of the variable is t, undo information is not recorded. */);
6109 DEFVAR_PER_BUFFER ("mark-active", &BVAR (current_buffer
, mark_active
), Qnil
,
6110 doc
: /* Non-nil means the mark and region are currently active in this buffer. */);
6112 DEFVAR_PER_BUFFER ("cache-long-scans", &BVAR (current_buffer
, cache_long_scans
), Qnil
,
6113 doc
: /* Non-nil means that Emacs should use caches in attempt to speedup buffer scans.
6115 There is no reason to set this to nil except for debugging purposes.
6117 Normally, the line-motion functions work by scanning the buffer for
6118 newlines. Columnar operations (like `move-to-column' and
6119 `compute-motion') also work by scanning the buffer, summing character
6120 widths as they go. This works well for ordinary text, but if the
6121 buffer's lines are very long (say, more than 500 characters), these
6122 motion functions will take longer to execute. Emacs may also take
6123 longer to update the display.
6125 If `cache-long-scans' is non-nil, these motion functions cache the
6126 results of their scans, and consult the cache to avoid rescanning
6127 regions of the buffer until the text is modified. The caches are most
6128 beneficial when they prevent the most searching---that is, when the
6129 buffer contains long lines and large regions of characters with the
6130 same, fixed screen width.
6132 When `cache-long-scans' is non-nil, processing short lines will
6133 become slightly slower (because of the overhead of consulting the
6134 cache), and the caches will use memory roughly proportional to the
6135 number of newlines and characters whose screen width varies.
6137 Bidirectional editing also requires buffer scans to find paragraph
6138 separators. If you have large paragraphs or no paragraph separators
6139 at all, these scans may be slow. If `cache-long-scans' is non-nil,
6140 results of these scans are cached. This doesn't help too much if
6141 paragraphs are of the reasonable (few thousands of characters) size.
6143 The caches require no explicit maintenance; their accuracy is
6144 maintained internally by the Emacs primitives. Enabling or disabling
6145 the cache should not affect the behavior of any of the motion
6146 functions; it should only affect their performance. */);
6148 DEFVAR_PER_BUFFER ("point-before-scroll", &BVAR (current_buffer
, point_before_scroll
), Qnil
,
6149 doc
: /* Value of point before the last series of scroll operations, or nil. */);
6151 DEFVAR_PER_BUFFER ("buffer-file-format", &BVAR (current_buffer
, file_format
), Qnil
,
6152 doc
: /* List of formats to use when saving this buffer.
6153 Formats are defined by `format-alist'. This variable is
6154 set when a file is visited. */);
6156 DEFVAR_PER_BUFFER ("buffer-auto-save-file-format",
6157 &BVAR (current_buffer
, auto_save_file_format
), Qnil
,
6158 doc
: /* Format in which to write auto-save files.
6159 Should be a list of symbols naming formats that are defined in `format-alist'.
6160 If it is t, which is the default, auto-save files are written in the
6161 same format as a regular save would use. */);
6163 DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
6164 &BVAR (current_buffer
, invisibility_spec
), Qnil
,
6165 doc
: /* Invisibility spec of this buffer.
6166 The default is t, which means that text is invisible if it has a non-nil
6167 `invisible' property.
6168 This variable can also be a list. The list can have two kinds of elements:
6169 `ATOM' and `(ATOM . ELLIPSIS)'. A text character is invisible if its
6170 `invisible' property is `ATOM', or has an `invisible' property that is a list
6171 that contains `ATOM'.
6172 If the `(ATOM . ELLIPSIS)' form is used, and `ELLIPSIS' is non-nil, an
6173 ellipsis will be displayed after the invisible characters.
6174 Setting this variable is very fast, much faster than scanning all the text in
6175 the buffer looking for properties to change. */);
6177 DEFVAR_PER_BUFFER ("buffer-display-count",
6178 &BVAR (current_buffer
, display_count
), Qintegerp
,
6179 doc
: /* A number incremented each time this buffer is displayed in a window.
6180 The function `set-window-buffer' increments it. */);
6182 DEFVAR_PER_BUFFER ("buffer-display-time",
6183 &BVAR (current_buffer
, display_time
), Qnil
,
6184 doc
: /* Time stamp updated each time this buffer is displayed in a window.
6185 The function `set-window-buffer' updates this variable
6186 to the value obtained by calling `current-time'.
6187 If the buffer has never been shown in a window, the value is nil. */);
6189 DEFVAR_LISP ("transient-mark-mode", Vtransient_mark_mode
,
6190 doc
: /* Non-nil if Transient Mark mode is enabled.
6191 See the command `transient-mark-mode' for a description of this minor mode.
6193 Non-nil also enables highlighting of the region whenever the mark is active.
6194 The region is highlighted with the `region' face.
6195 The variable `highlight-nonselected-windows' controls whether to highlight
6196 all windows or just the selected window.
6198 Lisp programs may give this variable certain special values:
6200 - The symbol `lambda' enables Transient Mark mode temporarily.
6201 The mode is disabled again after any subsequent action that would
6202 normally deactivate the mark (e.g. buffer modification).
6204 - The pair (only . OLDVAL) enables Transient Mark mode
6205 temporarily. After any subsequent point motion command that is
6206 not shift-translated, or any other action that would normally
6207 deactivate the mark (e.g. buffer modification), the value of
6208 `transient-mark-mode' is set to OLDVAL. */);
6209 Vtransient_mark_mode
= Qnil
;
6211 DEFVAR_LISP ("inhibit-read-only", Vinhibit_read_only
,
6212 doc
: /* Non-nil means disregard read-only status of buffers or characters.
6213 If the value is t, disregard `buffer-read-only' and all `read-only'
6214 text properties. If the value is a list, disregard `buffer-read-only'
6215 and disregard a `read-only' text property if the property value
6216 is a member of the list. */);
6217 Vinhibit_read_only
= Qnil
;
6219 DEFVAR_PER_BUFFER ("cursor-type", &BVAR (current_buffer
, cursor_type
), Qnil
,
6220 doc
: /* Cursor to use when this buffer is in the selected window.
6221 Values are interpreted as follows:
6223 t use the cursor specified for the frame
6224 nil don't display a cursor
6225 box display a filled box cursor
6226 hollow display a hollow box cursor
6227 bar display a vertical bar cursor with default width
6228 (bar . WIDTH) display a vertical bar cursor with width WIDTH
6229 hbar display a horizontal bar cursor with default height
6230 (hbar . HEIGHT) display a horizontal bar cursor with height HEIGHT
6231 ANYTHING ELSE display a hollow box cursor
6233 WIDTH and HEIGHT can't exceed the frame's canonical character size.
6235 When the buffer is displayed in a non-selected window, the
6236 cursor's appearance is instead controlled by the variable
6237 `cursor-in-non-selected-windows'. */);
6239 DEFVAR_PER_BUFFER ("line-spacing",
6240 &BVAR (current_buffer
, extra_line_spacing
), Qnumberp
,
6241 doc
: /* Additional space to put between lines when displaying a buffer.
6242 The space is measured in pixels, and put below lines on graphic displays,
6243 see `display-graphic-p'.
6244 If value is a floating point number, it specifies the spacing relative
6245 to the default frame line height. A value of nil means add no extra space. */);
6247 DEFVAR_PER_BUFFER ("cursor-in-non-selected-windows",
6248 &BVAR (current_buffer
, cursor_in_non_selected_windows
), Qnil
,
6249 doc
: /* Non-nil means show a cursor in non-selected windows.
6250 If nil, only shows a cursor in the selected window.
6251 If t, displays a cursor related to the usual cursor type
6252 \(a solid box becomes hollow, a bar becomes a narrower bar).
6253 You can also specify the cursor type as in the `cursor-type' variable.
6254 Use Custom to set this variable and update the display. */);
6256 DEFVAR_LISP ("kill-buffer-query-functions", Vkill_buffer_query_functions
,
6257 doc
: /* List of functions called with no args to query before killing a buffer.
6258 The buffer being killed will be current while the functions are running.
6260 If any of them returns nil, the buffer is not killed. Functions run by
6261 this hook are supposed to not change the current buffer. */);
6262 Vkill_buffer_query_functions
= Qnil
;
6264 DEFVAR_LISP ("change-major-mode-hook", Vchange_major_mode_hook
,
6265 doc
: /* Normal hook run before changing the major mode of a buffer.
6266 The function `kill-all-local-variables' runs this before doing anything else. */);
6267 Vchange_major_mode_hook
= Qnil
;
6268 DEFSYM (Qchange_major_mode_hook
, "change-major-mode-hook");
6270 DEFVAR_LISP ("buffer-list-update-hook", Vbuffer_list_update_hook
,
6271 doc
: /* Hook run when the buffer list changes.
6272 Functions running this hook are, `get-buffer-create',
6273 `make-indirect-buffer', `rename-buffer', `kill-buffer',
6274 `bury-buffer-internal' and `select-window'. */);
6275 Vbuffer_list_update_hook
= Qnil
;
6276 DEFSYM (Qbuffer_list_update_hook
, "buffer-list-update-hook");
6278 defsubr (&Sbuffer_live_p
);
6279 defsubr (&Sbuffer_list
);
6280 defsubr (&Sget_buffer
);
6281 defsubr (&Sget_file_buffer
);
6282 defsubr (&Sget_buffer_create
);
6283 defsubr (&Smake_indirect_buffer
);
6284 defsubr (&Sgenerate_new_buffer_name
);
6285 defsubr (&Sbuffer_name
);
6286 defsubr (&Sbuffer_file_name
);
6287 defsubr (&Sbuffer_base_buffer
);
6288 defsubr (&Sbuffer_local_value
);
6289 defsubr (&Sbuffer_local_variables
);
6290 defsubr (&Sbuffer_modified_p
);
6291 defsubr (&Sforce_mode_line_update
);
6292 defsubr (&Sset_buffer_modified_p
);
6293 defsubr (&Sbuffer_modified_tick
);
6294 defsubr (&Sbuffer_chars_modified_tick
);
6295 defsubr (&Srename_buffer
);
6296 defsubr (&Sother_buffer
);
6297 defsubr (&Sbuffer_enable_undo
);
6298 defsubr (&Skill_buffer
);
6299 defsubr (&Sbury_buffer_internal
);
6300 defsubr (&Sset_buffer_major_mode
);
6301 defsubr (&Scurrent_buffer
);
6302 defsubr (&Sset_buffer
);
6303 defsubr (&Sbarf_if_buffer_read_only
);
6304 defsubr (&Serase_buffer
);
6305 defsubr (&Sbuffer_swap_text
);
6306 defsubr (&Sset_buffer_multibyte
);
6307 defsubr (&Skill_all_local_variables
);
6309 defsubr (&Soverlayp
);
6310 defsubr (&Smake_overlay
);
6311 defsubr (&Sdelete_overlay
);
6312 defsubr (&Sdelete_all_overlays
);
6313 defsubr (&Smove_overlay
);
6314 defsubr (&Soverlay_start
);
6315 defsubr (&Soverlay_end
);
6316 defsubr (&Soverlay_buffer
);
6317 defsubr (&Soverlay_properties
);
6318 defsubr (&Soverlays_at
);
6319 defsubr (&Soverlays_in
);
6320 defsubr (&Snext_overlay_change
);
6321 defsubr (&Sprevious_overlay_change
);
6322 defsubr (&Soverlay_recenter
);
6323 defsubr (&Soverlay_lists
);
6324 defsubr (&Soverlay_get
);
6325 defsubr (&Soverlay_put
);
6326 defsubr (&Srestore_buffer_modified_p
);
6328 Fput (intern_c_string ("erase-buffer"), Qdisabled
, Qt
);
6332 keys_of_buffer (void)
6334 initial_define_key (control_x_map
, 'b', "switch-to-buffer");
6335 initial_define_key (control_x_map
, 'k', "kill-buffer");