1 /* Buffer manipulation primitives for GNU Emacs.
3 Copyright (C) 1985-1989, 1993-1995, 1997-2014 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
22 #include <sys/types.h>
24 #include <sys/param.h>
32 #include "intervals.h"
35 #include "character.h"
37 #include "region-cache.h"
39 #include "blockinput.h"
45 #include "w32heap.h" /* for mmap_* */
48 struct buffer
*current_buffer
; /* The current buffer. */
50 /* First buffer in chain of all buffers (in reverse order of creation).
51 Threaded through ->header.next.buffer. */
53 struct buffer
*all_buffers
;
55 /* This structure holds the default values of the buffer-local variables
56 defined with DEFVAR_PER_BUFFER, that have special slots in each buffer.
57 The default value occupies the same slot in this structure
58 as an individual buffer's value occupies in that buffer.
59 Setting the default value also goes through the alist of buffers
60 and stores into each buffer that does not say it has a local value. */
62 struct buffer
alignas (GCALIGNMENT
) buffer_defaults
;
64 /* This structure marks which slots in a buffer have corresponding
65 default values in buffer_defaults.
66 Each such slot has a nonzero value in this structure.
67 The value has only one nonzero bit.
69 When a buffer has its own local value for a slot,
70 the entry for that slot (found in the same slot in this structure)
71 is turned on in the buffer's local_flags array.
73 If a slot in this structure is -1, then even though there may
74 be a DEFVAR_PER_BUFFER for the slot, there is no default value for it;
75 and the corresponding slot in buffer_defaults is not used.
77 If a slot in this structure corresponding to a DEFVAR_PER_BUFFER is
78 zero, that is a bug. */
80 struct buffer buffer_local_flags
;
82 /* This structure holds the names of symbols whose values may be
83 buffer-local. It is indexed and accessed in the same way as the above. */
85 struct buffer
alignas (GCALIGNMENT
) buffer_local_symbols
;
87 /* Return the symbol of the per-buffer variable at offset OFFSET in
88 the buffer structure. */
90 #define PER_BUFFER_SYMBOL(OFFSET) \
91 (*(Lisp_Object *)((OFFSET) + (char *) &buffer_local_symbols))
93 /* Maximum length of an overlay vector. */
94 #define OVERLAY_COUNT_MAX \
95 ((ptrdiff_t) min (MOST_POSITIVE_FIXNUM, \
96 min (PTRDIFF_MAX, SIZE_MAX) / word_size))
98 /* Flags indicating which built-in buffer-local variables
99 are permanent locals. */
100 static char buffer_permanent_local_flags
[MAX_PER_BUFFER_VARS
];
102 /* Number of per-buffer variables used. */
104 int last_per_buffer_idx
;
106 static void call_overlay_mod_hooks (Lisp_Object list
, Lisp_Object overlay
,
107 bool after
, Lisp_Object arg1
,
108 Lisp_Object arg2
, Lisp_Object arg3
);
109 static void swap_out_buffer_local_variables (struct buffer
*b
);
110 static void reset_buffer_local_variables (struct buffer
*, bool);
112 /* Alist of all buffer names vs the buffers. This used to be
113 a Lisp-visible variable, but is no longer, to prevent lossage
114 due to user rplac'ing this alist or its elements. */
115 Lisp_Object Vbuffer_alist
;
117 static Lisp_Object Qkill_buffer_query_functions
;
119 /* Hook run before changing a major mode. */
120 static Lisp_Object Qchange_major_mode_hook
;
122 Lisp_Object Qfirst_change_hook
;
123 Lisp_Object Qbefore_change_functions
;
124 Lisp_Object Qafter_change_functions
;
126 static Lisp_Object Qfundamental_mode
, Qmode_class
, Qpermanent_local
;
127 static Lisp_Object Qpermanent_local_hook
;
129 static Lisp_Object Qprotected_field
;
131 static Lisp_Object QSFundamental
; /* A string "Fundamental". */
133 static Lisp_Object Qkill_buffer_hook
;
134 static Lisp_Object Qbuffer_list_update_hook
;
136 static Lisp_Object Qget_file_buffer
;
138 static Lisp_Object Qoverlayp
;
140 Lisp_Object Qpriority
, Qbefore_string
, Qafter_string
;
142 static Lisp_Object Qevaporate
;
144 Lisp_Object Qmodification_hooks
;
145 Lisp_Object Qinsert_in_front_hooks
;
146 Lisp_Object Qinsert_behind_hooks
;
148 Lisp_Object Qchoice
, Qrange
, Qleft
, Qright
;
149 Lisp_Object Qvertical_scroll_bar
, Qhorizontal_scroll_bar
;
150 static Lisp_Object Qoverwrite_mode
, Qfraction
;
152 static void alloc_buffer_text (struct buffer
*, ptrdiff_t);
153 static void free_buffer_text (struct buffer
*b
);
154 static struct Lisp_Overlay
* copy_overlays (struct buffer
*, struct Lisp_Overlay
*);
155 static void modify_overlay (struct buffer
*, ptrdiff_t, ptrdiff_t);
156 static Lisp_Object
buffer_lisp_local_variables (struct buffer
*, bool);
159 CHECK_OVERLAY (Lisp_Object x
)
161 CHECK_TYPE (OVERLAYP (x
), Qoverlayp
, x
);
164 /* These setters are used only in this file, so they can be private.
165 The public setters are inline functions defined in buffer.h. */
167 bset_abbrev_mode (struct buffer
*b
, Lisp_Object val
)
169 b
->INTERNAL_FIELD (abbrev_mode
) = val
;
172 bset_abbrev_table (struct buffer
*b
, Lisp_Object val
)
174 b
->INTERNAL_FIELD (abbrev_table
) = val
;
177 bset_auto_fill_function (struct buffer
*b
, Lisp_Object val
)
179 b
->INTERNAL_FIELD (auto_fill_function
) = val
;
182 bset_auto_save_file_format (struct buffer
*b
, Lisp_Object val
)
184 b
->INTERNAL_FIELD (auto_save_file_format
) = val
;
187 bset_auto_save_file_name (struct buffer
*b
, Lisp_Object val
)
189 b
->INTERNAL_FIELD (auto_save_file_name
) = val
;
192 bset_backed_up (struct buffer
*b
, Lisp_Object val
)
194 b
->INTERNAL_FIELD (backed_up
) = val
;
197 bset_begv_marker (struct buffer
*b
, Lisp_Object val
)
199 b
->INTERNAL_FIELD (begv_marker
) = val
;
202 bset_bidi_display_reordering (struct buffer
*b
, Lisp_Object val
)
204 b
->INTERNAL_FIELD (bidi_display_reordering
) = val
;
207 bset_buffer_file_coding_system (struct buffer
*b
, Lisp_Object val
)
209 b
->INTERNAL_FIELD (buffer_file_coding_system
) = val
;
212 bset_case_fold_search (struct buffer
*b
, Lisp_Object val
)
214 b
->INTERNAL_FIELD (case_fold_search
) = val
;
217 bset_ctl_arrow (struct buffer
*b
, Lisp_Object val
)
219 b
->INTERNAL_FIELD (ctl_arrow
) = val
;
222 bset_cursor_in_non_selected_windows (struct buffer
*b
, Lisp_Object val
)
224 b
->INTERNAL_FIELD (cursor_in_non_selected_windows
) = val
;
227 bset_cursor_type (struct buffer
*b
, Lisp_Object val
)
229 b
->INTERNAL_FIELD (cursor_type
) = val
;
232 bset_display_table (struct buffer
*b
, Lisp_Object val
)
234 b
->INTERNAL_FIELD (display_table
) = val
;
237 bset_extra_line_spacing (struct buffer
*b
, Lisp_Object val
)
239 b
->INTERNAL_FIELD (extra_line_spacing
) = val
;
242 bset_file_format (struct buffer
*b
, Lisp_Object val
)
244 b
->INTERNAL_FIELD (file_format
) = val
;
247 bset_file_truename (struct buffer
*b
, Lisp_Object val
)
249 b
->INTERNAL_FIELD (file_truename
) = val
;
252 bset_fringe_cursor_alist (struct buffer
*b
, Lisp_Object val
)
254 b
->INTERNAL_FIELD (fringe_cursor_alist
) = val
;
257 bset_fringe_indicator_alist (struct buffer
*b
, Lisp_Object val
)
259 b
->INTERNAL_FIELD (fringe_indicator_alist
) = val
;
262 bset_fringes_outside_margins (struct buffer
*b
, Lisp_Object val
)
264 b
->INTERNAL_FIELD (fringes_outside_margins
) = val
;
267 bset_header_line_format (struct buffer
*b
, Lisp_Object val
)
269 b
->INTERNAL_FIELD (header_line_format
) = val
;
272 bset_indicate_buffer_boundaries (struct buffer
*b
, Lisp_Object val
)
274 b
->INTERNAL_FIELD (indicate_buffer_boundaries
) = val
;
277 bset_indicate_empty_lines (struct buffer
*b
, Lisp_Object val
)
279 b
->INTERNAL_FIELD (indicate_empty_lines
) = val
;
282 bset_invisibility_spec (struct buffer
*b
, Lisp_Object val
)
284 b
->INTERNAL_FIELD (invisibility_spec
) = val
;
287 bset_left_fringe_width (struct buffer
*b
, Lisp_Object val
)
289 b
->INTERNAL_FIELD (left_fringe_width
) = val
;
292 bset_major_mode (struct buffer
*b
, Lisp_Object val
)
294 b
->INTERNAL_FIELD (major_mode
) = val
;
297 bset_mark (struct buffer
*b
, Lisp_Object val
)
299 b
->INTERNAL_FIELD (mark
) = val
;
302 bset_minor_modes (struct buffer
*b
, Lisp_Object val
)
304 b
->INTERNAL_FIELD (minor_modes
) = val
;
307 bset_mode_line_format (struct buffer
*b
, Lisp_Object val
)
309 b
->INTERNAL_FIELD (mode_line_format
) = val
;
312 bset_mode_name (struct buffer
*b
, Lisp_Object val
)
314 b
->INTERNAL_FIELD (mode_name
) = val
;
317 bset_name (struct buffer
*b
, Lisp_Object val
)
319 b
->INTERNAL_FIELD (name
) = val
;
322 bset_overwrite_mode (struct buffer
*b
, Lisp_Object val
)
324 b
->INTERNAL_FIELD (overwrite_mode
) = val
;
327 bset_pt_marker (struct buffer
*b
, Lisp_Object val
)
329 b
->INTERNAL_FIELD (pt_marker
) = val
;
332 bset_right_fringe_width (struct buffer
*b
, Lisp_Object val
)
334 b
->INTERNAL_FIELD (right_fringe_width
) = val
;
337 bset_save_length (struct buffer
*b
, Lisp_Object val
)
339 b
->INTERNAL_FIELD (save_length
) = val
;
342 bset_scroll_bar_width (struct buffer
*b
, Lisp_Object val
)
344 b
->INTERNAL_FIELD (scroll_bar_width
) = val
;
347 bset_scroll_bar_height (struct buffer
*b
, Lisp_Object val
)
349 b
->INTERNAL_FIELD (scroll_bar_height
) = val
;
352 bset_scroll_down_aggressively (struct buffer
*b
, Lisp_Object val
)
354 b
->INTERNAL_FIELD (scroll_down_aggressively
) = val
;
357 bset_scroll_up_aggressively (struct buffer
*b
, Lisp_Object val
)
359 b
->INTERNAL_FIELD (scroll_up_aggressively
) = val
;
362 bset_selective_display (struct buffer
*b
, Lisp_Object val
)
364 b
->INTERNAL_FIELD (selective_display
) = val
;
367 bset_selective_display_ellipses (struct buffer
*b
, Lisp_Object val
)
369 b
->INTERNAL_FIELD (selective_display_ellipses
) = val
;
372 bset_vertical_scroll_bar_type (struct buffer
*b
, Lisp_Object val
)
374 b
->INTERNAL_FIELD (vertical_scroll_bar_type
) = val
;
377 bset_horizontal_scroll_bar_type (struct buffer
*b
, Lisp_Object val
)
379 b
->INTERNAL_FIELD (horizontal_scroll_bar_type
) = val
;
382 bset_word_wrap (struct buffer
*b
, Lisp_Object val
)
384 b
->INTERNAL_FIELD (word_wrap
) = val
;
387 bset_zv_marker (struct buffer
*b
, Lisp_Object val
)
389 b
->INTERNAL_FIELD (zv_marker
) = val
;
393 nsberror (Lisp_Object spec
)
396 error ("No buffer named %s", SDATA (spec
));
397 error ("Invalid buffer argument");
400 DEFUN ("buffer-live-p", Fbuffer_live_p
, Sbuffer_live_p
, 1, 1, 0,
401 doc
: /* Return non-nil if OBJECT is a buffer which has not been killed.
402 Value is nil if OBJECT is not a buffer or if it has been killed. */)
405 return ((BUFFERP (object
) && BUFFER_LIVE_P (XBUFFER (object
)))
409 DEFUN ("buffer-list", Fbuffer_list
, Sbuffer_list
, 0, 1, 0,
410 doc
: /* Return a list of all existing live buffers.
411 If the optional arg FRAME is a frame, we return the buffer list in the
412 proper order for that frame: the buffers show in FRAME come first,
413 followed by the rest of the buffers. */)
417 general
= Fmapcar (Qcdr
, Vbuffer_alist
);
421 Lisp_Object framelist
, prevlist
, tail
;
424 framelist
= Fcopy_sequence (XFRAME (frame
)->buffer_list
);
425 prevlist
= Fnreverse (Fcopy_sequence
426 (XFRAME (frame
)->buried_buffer_list
));
428 /* Remove from GENERAL any buffer that duplicates one in
429 FRAMELIST or PREVLIST. */
433 general
= Fdelq (XCAR (tail
), general
);
439 general
= Fdelq (XCAR (tail
), general
);
446 return Fnconc (3, args
);
452 /* Like Fassoc, but use Fstring_equal to compare
453 (which ignores text properties),
454 and don't ever QUIT. */
457 assoc_ignore_text_properties (register Lisp_Object key
, Lisp_Object list
)
459 register Lisp_Object tail
;
460 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
462 register Lisp_Object elt
, tem
;
464 tem
= Fstring_equal (Fcar (elt
), key
);
471 DEFUN ("get-buffer", Fget_buffer
, Sget_buffer
, 1, 1, 0,
472 doc
: /* Return the buffer named BUFFER-OR-NAME.
473 BUFFER-OR-NAME must be either a string or a buffer. If BUFFER-OR-NAME
474 is a string and there is no buffer with that name, return nil. If
475 BUFFER-OR-NAME is a buffer, return it as given. */)
476 (register Lisp_Object buffer_or_name
)
478 if (BUFFERP (buffer_or_name
))
479 return buffer_or_name
;
480 CHECK_STRING (buffer_or_name
);
482 return Fcdr (assoc_ignore_text_properties (buffer_or_name
, Vbuffer_alist
));
485 DEFUN ("get-file-buffer", Fget_file_buffer
, Sget_file_buffer
, 1, 1, 0,
486 doc
: /* Return the buffer visiting file FILENAME (a string).
487 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
488 If there is no such live buffer, return nil.
489 See also `find-buffer-visiting'. */)
490 (register Lisp_Object filename
)
492 register Lisp_Object tail
, buf
, handler
;
494 CHECK_STRING (filename
);
495 filename
= Fexpand_file_name (filename
, Qnil
);
497 /* If the file name has special constructs in it,
498 call the corresponding file handler. */
499 handler
= Ffind_file_name_handler (filename
, Qget_file_buffer
);
502 Lisp_Object handled_buf
= call2 (handler
, Qget_file_buffer
,
504 return BUFFERP (handled_buf
) ? handled_buf
: Qnil
;
507 FOR_EACH_LIVE_BUFFER (tail
, buf
)
509 if (!STRINGP (BVAR (XBUFFER (buf
), filename
))) continue;
510 if (!NILP (Fstring_equal (BVAR (XBUFFER (buf
), filename
), filename
)))
517 get_truename_buffer (register Lisp_Object filename
)
519 register Lisp_Object tail
, buf
;
521 FOR_EACH_LIVE_BUFFER (tail
, buf
)
523 if (!STRINGP (BVAR (XBUFFER (buf
), file_truename
))) continue;
524 if (!NILP (Fstring_equal (BVAR (XBUFFER (buf
), file_truename
), filename
)))
530 DEFUN ("get-buffer-create", Fget_buffer_create
, Sget_buffer_create
, 1, 1, 0,
531 doc
: /* Return the buffer specified by BUFFER-OR-NAME, creating a new one if needed.
532 If BUFFER-OR-NAME is a string and a live buffer with that name exists,
533 return that buffer. If no such buffer exists, create a new buffer with
534 that name and return it. If BUFFER-OR-NAME starts with a space, the new
535 buffer does not keep undo information.
537 If BUFFER-OR-NAME is a buffer instead of a string, return it as given,
538 even if it is dead. The return value is never nil. */)
539 (register Lisp_Object buffer_or_name
)
541 register Lisp_Object buffer
, name
;
542 register struct buffer
*b
;
544 buffer
= Fget_buffer (buffer_or_name
);
548 if (SCHARS (buffer_or_name
) == 0)
549 error ("Empty string for buffer name is not allowed");
551 b
= allocate_buffer ();
553 /* An ordinary buffer uses its own struct buffer_text. */
554 b
->text
= &b
->own_text
;
555 b
->base_buffer
= NULL
;
556 /* No one shares the text with us now. */
558 /* No one shows us now. */
561 BUF_GAP_SIZE (b
) = 20;
563 /* We allocate extra 1-byte at the tail and keep it always '\0' for
564 anchoring a search. */
565 alloc_buffer_text (b
, BUF_GAP_SIZE (b
) + 1);
567 if (! BUF_BEG_ADDR (b
))
568 buffer_memory_full (BUF_GAP_SIZE (b
) + 1);
573 b
->pt_byte
= BEG_BYTE
;
574 b
->begv_byte
= BEG_BYTE
;
575 b
->zv_byte
= BEG_BYTE
;
578 BUF_GPT_BYTE (b
) = BEG_BYTE
;
581 BUF_Z_BYTE (b
) = BEG_BYTE
;
583 BUF_CHARS_MODIFF (b
) = 1;
584 BUF_OVERLAY_MODIFF (b
) = 1;
585 BUF_SAVE_MODIFF (b
) = 1;
587 set_buffer_intervals (b
, NULL
);
588 BUF_UNCHANGED_MODIFIED (b
) = 1;
589 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = 1;
590 BUF_END_UNCHANGED (b
) = 0;
591 BUF_BEG_UNCHANGED (b
) = 0;
592 *(BUF_GPT_ADDR (b
)) = *(BUF_Z_ADDR (b
)) = 0; /* Put an anchor '\0'. */
593 b
->text
->inhibit_shrinking
= false;
594 b
->text
->redisplay
= false;
596 b
->newline_cache
= 0;
597 b
->width_run_cache
= 0;
598 b
->bidi_paragraph_cache
= 0;
599 bset_width_table (b
, Qnil
);
600 b
->prevent_redisplay_optimizations_p
= 1;
602 /* An ordinary buffer normally doesn't need markers
603 to handle BEGV and ZV. */
604 bset_pt_marker (b
, Qnil
);
605 bset_begv_marker (b
, Qnil
);
606 bset_zv_marker (b
, Qnil
);
608 name
= Fcopy_sequence (buffer_or_name
);
609 set_string_intervals (name
, NULL
);
612 bset_undo_list (b
, SREF (name
, 0) != ' ' ? Qnil
: Qt
);
615 reset_buffer_local_variables (b
, 1);
617 bset_mark (b
, Fmake_marker ());
618 BUF_MARKERS (b
) = NULL
;
620 /* Put this in the alist of all live buffers. */
621 XSETBUFFER (buffer
, b
);
622 Vbuffer_alist
= nconc2 (Vbuffer_alist
, list1 (Fcons (name
, buffer
)));
623 /* And run buffer-list-update-hook. */
624 if (!NILP (Vrun_hooks
))
625 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
631 /* Return a list of overlays which is a copy of the overlay list
632 LIST, but for buffer B. */
634 static struct Lisp_Overlay
*
635 copy_overlays (struct buffer
*b
, struct Lisp_Overlay
*list
)
637 struct Lisp_Overlay
*result
= NULL
, *tail
= NULL
;
639 for (; list
; list
= list
->next
)
641 Lisp_Object overlay
, start
, end
;
642 struct Lisp_Marker
*m
;
644 eassert (MARKERP (list
->start
));
645 m
= XMARKER (list
->start
);
646 start
= build_marker (b
, m
->charpos
, m
->bytepos
);
647 XMARKER (start
)->insertion_type
= m
->insertion_type
;
649 eassert (MARKERP (list
->end
));
650 m
= XMARKER (list
->end
);
651 end
= build_marker (b
, m
->charpos
, m
->bytepos
);
652 XMARKER (end
)->insertion_type
= m
->insertion_type
;
654 overlay
= build_overlay (start
, end
, Fcopy_sequence (list
->plist
));
656 tail
= tail
->next
= XOVERLAY (overlay
);
658 result
= tail
= XOVERLAY (overlay
);
664 /* Set an appropriate overlay of B. */
667 set_buffer_overlays_before (struct buffer
*b
, struct Lisp_Overlay
*o
)
669 b
->overlays_before
= o
;
673 set_buffer_overlays_after (struct buffer
*b
, struct Lisp_Overlay
*o
)
675 b
->overlays_after
= o
;
678 /* Clone per-buffer values of buffer FROM.
680 Buffer TO gets the same per-buffer values as FROM, with the
681 following exceptions: (1) TO's name is left untouched, (2) markers
682 are copied and made to refer to TO, and (3) overlay lists are
686 clone_per_buffer_values (struct buffer
*from
, struct buffer
*to
)
690 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
694 /* Don't touch the `name' which should be unique for every buffer. */
695 if (offset
== PER_BUFFER_VAR_OFFSET (name
))
698 obj
= per_buffer_value (from
, offset
);
699 if (MARKERP (obj
) && XMARKER (obj
)->buffer
== from
)
701 struct Lisp_Marker
*m
= XMARKER (obj
);
703 obj
= build_marker (to
, m
->charpos
, m
->bytepos
);
704 XMARKER (obj
)->insertion_type
= m
->insertion_type
;
707 set_per_buffer_value (to
, offset
, obj
);
710 memcpy (to
->local_flags
, from
->local_flags
, sizeof to
->local_flags
);
712 set_buffer_overlays_before (to
, copy_overlays (to
, from
->overlays_before
));
713 set_buffer_overlays_after (to
, copy_overlays (to
, from
->overlays_after
));
715 /* Get (a copy of) the alist of Lisp-level local variables of FROM
716 and install that in TO. */
717 bset_local_var_alist (to
, buffer_lisp_local_variables (from
, 1));
721 /* If buffer B has markers to record PT, BEGV and ZV when it is not
722 current, update these markers. */
725 record_buffer_markers (struct buffer
*b
)
727 if (! NILP (BVAR (b
, pt_marker
)))
731 eassert (!NILP (BVAR (b
, begv_marker
)));
732 eassert (!NILP (BVAR (b
, zv_marker
)));
734 XSETBUFFER (buffer
, b
);
735 set_marker_both (BVAR (b
, pt_marker
), buffer
, b
->pt
, b
->pt_byte
);
736 set_marker_both (BVAR (b
, begv_marker
), buffer
, b
->begv
, b
->begv_byte
);
737 set_marker_both (BVAR (b
, zv_marker
), buffer
, b
->zv
, b
->zv_byte
);
742 /* If buffer B has markers to record PT, BEGV and ZV when it is not
743 current, fetch these values into B->begv etc. */
746 fetch_buffer_markers (struct buffer
*b
)
748 if (! NILP (BVAR (b
, pt_marker
)))
752 eassert (!NILP (BVAR (b
, begv_marker
)));
753 eassert (!NILP (BVAR (b
, zv_marker
)));
755 m
= BVAR (b
, pt_marker
);
756 SET_BUF_PT_BOTH (b
, marker_position (m
), marker_byte_position (m
));
758 m
= BVAR (b
, begv_marker
);
759 SET_BUF_BEGV_BOTH (b
, marker_position (m
), marker_byte_position (m
));
761 m
= BVAR (b
, zv_marker
);
762 SET_BUF_ZV_BOTH (b
, marker_position (m
), marker_byte_position (m
));
767 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer
, Smake_indirect_buffer
,
769 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ",
770 doc
: /* Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.
771 BASE-BUFFER should be a live buffer, or the name of an existing buffer.
772 NAME should be a string which is not the name of an existing buffer.
773 Optional argument CLONE non-nil means preserve BASE-BUFFER's state,
774 such as major and minor modes, in the indirect buffer.
775 CLONE nil means the indirect buffer's state is reset to default values. */)
776 (Lisp_Object base_buffer
, Lisp_Object name
, Lisp_Object clone
)
778 Lisp_Object buf
, tem
;
782 buf
= Fget_buffer (name
);
784 error ("Buffer name `%s' is in use", SDATA (name
));
787 base_buffer
= Fget_buffer (base_buffer
);
788 if (NILP (base_buffer
))
789 error ("No such buffer: `%s'", SDATA (tem
));
790 if (!BUFFER_LIVE_P (XBUFFER (base_buffer
)))
791 error ("Base buffer has been killed");
793 if (SCHARS (name
) == 0)
794 error ("Empty string for buffer name is not allowed");
796 b
= allocate_buffer ();
798 /* No double indirection - if base buffer is indirect,
799 new buffer becomes an indirect to base's base. */
800 b
->base_buffer
= (XBUFFER (base_buffer
)->base_buffer
801 ? XBUFFER (base_buffer
)->base_buffer
802 : XBUFFER (base_buffer
));
804 /* Use the base buffer's text object. */
805 b
->text
= b
->base_buffer
->text
;
806 /* We have no own text. */
807 b
->indirections
= -1;
808 /* Notify base buffer that we share the text now. */
809 b
->base_buffer
->indirections
++;
810 /* Always -1 for an indirect buffer. */
811 b
->window_count
= -1;
813 b
->pt
= b
->base_buffer
->pt
;
814 b
->begv
= b
->base_buffer
->begv
;
815 b
->zv
= b
->base_buffer
->zv
;
816 b
->pt_byte
= b
->base_buffer
->pt_byte
;
817 b
->begv_byte
= b
->base_buffer
->begv_byte
;
818 b
->zv_byte
= b
->base_buffer
->zv_byte
;
820 b
->newline_cache
= 0;
821 b
->width_run_cache
= 0;
822 b
->bidi_paragraph_cache
= 0;
823 bset_width_table (b
, Qnil
);
825 name
= Fcopy_sequence (name
);
826 set_string_intervals (name
, NULL
);
829 /* An indirect buffer shares undo list of its base (Bug#18180). */
830 bset_undo_list (b
, BVAR (b
->base_buffer
, undo_list
));
833 reset_buffer_local_variables (b
, 1);
835 /* Put this in the alist of all live buffers. */
837 Vbuffer_alist
= nconc2 (Vbuffer_alist
, list1 (Fcons (name
, buf
)));
839 bset_mark (b
, Fmake_marker ());
841 /* The multibyte status belongs to the base buffer. */
842 bset_enable_multibyte_characters
843 (b
, BVAR (b
->base_buffer
, enable_multibyte_characters
));
845 /* Make sure the base buffer has markers for its narrowing. */
846 if (NILP (BVAR (b
->base_buffer
, pt_marker
)))
848 eassert (NILP (BVAR (b
->base_buffer
, begv_marker
)));
849 eassert (NILP (BVAR (b
->base_buffer
, zv_marker
)));
851 bset_pt_marker (b
->base_buffer
,
852 build_marker (b
->base_buffer
, b
->base_buffer
->pt
,
853 b
->base_buffer
->pt_byte
));
855 bset_begv_marker (b
->base_buffer
,
856 build_marker (b
->base_buffer
, b
->base_buffer
->begv
,
857 b
->base_buffer
->begv_byte
));
859 bset_zv_marker (b
->base_buffer
,
860 build_marker (b
->base_buffer
, b
->base_buffer
->zv
,
861 b
->base_buffer
->zv_byte
));
863 XMARKER (BVAR (b
->base_buffer
, zv_marker
))->insertion_type
= 1;
868 /* Give the indirect buffer markers for its narrowing. */
869 bset_pt_marker (b
, build_marker (b
, b
->pt
, b
->pt_byte
));
870 bset_begv_marker (b
, build_marker (b
, b
->begv
, b
->begv_byte
));
871 bset_zv_marker (b
, build_marker (b
, b
->zv
, b
->zv_byte
));
872 XMARKER (BVAR (b
, zv_marker
))->insertion_type
= 1;
876 struct buffer
*old_b
= current_buffer
;
878 clone_per_buffer_values (b
->base_buffer
, b
);
879 bset_filename (b
, Qnil
);
880 bset_file_truename (b
, Qnil
);
881 bset_display_count (b
, make_number (0));
882 bset_backed_up (b
, Qnil
);
883 bset_auto_save_file_name (b
, Qnil
);
884 set_buffer_internal_1 (b
);
885 Fset (intern ("buffer-save-without-query"), Qnil
);
886 Fset (intern ("buffer-file-number"), Qnil
);
887 Fset (intern ("buffer-stale-function"), Qnil
);
888 set_buffer_internal_1 (old_b
);
891 /* Run buffer-list-update-hook. */
892 if (!NILP (Vrun_hooks
))
893 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
898 /* Mark OV as no longer associated with B. */
901 drop_overlay (struct buffer
*b
, struct Lisp_Overlay
*ov
)
903 eassert (b
== XBUFFER (Fmarker_buffer (ov
->start
)));
904 modify_overlay (b
, marker_position (ov
->start
),
905 marker_position (ov
->end
));
906 unchain_marker (XMARKER (ov
->start
));
907 unchain_marker (XMARKER (ov
->end
));
911 /* Delete all overlays of B and reset it's overlay lists. */
914 delete_all_overlays (struct buffer
*b
)
916 struct Lisp_Overlay
*ov
, *next
;
918 /* FIXME: Since each drop_overlay will scan BUF_MARKERS to unlink its
919 markers, we have an unneeded O(N^2) behavior here. */
920 for (ov
= b
->overlays_before
; ov
; ov
= next
)
922 drop_overlay (b
, ov
);
927 for (ov
= b
->overlays_after
; ov
; ov
= next
)
929 drop_overlay (b
, ov
);
934 set_buffer_overlays_before (b
, NULL
);
935 set_buffer_overlays_after (b
, NULL
);
938 /* Reinitialize everything about a buffer except its name and contents
940 If called on an already-initialized buffer, the list of overlays
941 should be deleted before calling this function, otherwise we end up
942 with overlays that claim to belong to the buffer but the buffer
943 claims it doesn't belong to it. */
946 reset_buffer (register struct buffer
*b
)
948 bset_filename (b
, Qnil
);
949 bset_file_truename (b
, Qnil
);
950 bset_directory (b
, current_buffer
? BVAR (current_buffer
, directory
) : Qnil
);
951 b
->modtime
= make_timespec (0, UNKNOWN_MODTIME_NSECS
);
952 b
->modtime_size
= -1;
953 XSETFASTINT (BVAR (b
, save_length
), 0);
954 b
->last_window_start
= 1;
955 /* It is more conservative to start out "changed" than "unchanged". */
957 b
->prevent_redisplay_optimizations_p
= 1;
958 bset_backed_up (b
, Qnil
);
959 BUF_AUTOSAVE_MODIFF (b
) = 0;
960 b
->auto_save_failure_time
= 0;
961 bset_auto_save_file_name (b
, Qnil
);
962 bset_read_only (b
, Qnil
);
963 set_buffer_overlays_before (b
, NULL
);
964 set_buffer_overlays_after (b
, NULL
);
965 b
->overlay_center
= BEG
;
966 bset_mark_active (b
, Qnil
);
967 bset_point_before_scroll (b
, Qnil
);
968 bset_file_format (b
, Qnil
);
969 bset_auto_save_file_format (b
, Qt
);
970 bset_last_selected_window (b
, Qnil
);
971 bset_display_count (b
, make_number (0));
972 bset_display_time (b
, Qnil
);
973 bset_enable_multibyte_characters
974 (b
, BVAR (&buffer_defaults
, enable_multibyte_characters
));
975 bset_cursor_type (b
, BVAR (&buffer_defaults
, cursor_type
));
976 bset_extra_line_spacing (b
, BVAR (&buffer_defaults
, extra_line_spacing
));
978 b
->display_error_modiff
= 0;
981 /* Reset buffer B's local variables info.
982 Don't use this on a buffer that has already been in use;
983 it does not treat permanent locals consistently.
984 Instead, use Fkill_all_local_variables.
986 If PERMANENT_TOO, reset permanent buffer-local variables.
987 If not, preserve those. */
990 reset_buffer_local_variables (struct buffer
*b
, bool permanent_too
)
994 /* Reset the major mode to Fundamental, together with all the
995 things that depend on the major mode.
996 default-major-mode is handled at a higher level.
997 We ignore it here. */
998 bset_major_mode (b
, Qfundamental_mode
);
999 bset_keymap (b
, Qnil
);
1000 bset_mode_name (b
, QSFundamental
);
1001 bset_minor_modes (b
, Qnil
);
1003 /* If the standard case table has been altered and invalidated,
1004 fix up its insides first. */
1005 if (! (CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[0])
1006 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[1])
1007 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[2])))
1008 Fset_standard_case_table (Vascii_downcase_table
);
1010 bset_downcase_table (b
, Vascii_downcase_table
);
1011 bset_upcase_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[0]);
1012 bset_case_canon_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[1]);
1013 bset_case_eqv_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[2]);
1014 bset_invisibility_spec (b
, Qt
);
1016 /* Reset all (or most) per-buffer variables to their defaults. */
1018 bset_local_var_alist (b
, Qnil
);
1021 Lisp_Object tmp
, prop
, last
= Qnil
;
1022 for (tmp
= BVAR (b
, local_var_alist
); CONSP (tmp
); tmp
= XCDR (tmp
))
1023 if (!NILP (prop
= Fget (XCAR (XCAR (tmp
)), Qpermanent_local
)))
1025 /* If permanent-local, keep it. */
1027 if (EQ (prop
, Qpermanent_local_hook
))
1029 /* This is a partially permanent hook variable.
1030 Preserve only the elements that want to be preserved. */
1031 Lisp_Object list
, newlist
;
1032 list
= XCDR (XCAR (tmp
));
1036 for (newlist
= Qnil
; CONSP (list
); list
= XCDR (list
))
1038 Lisp_Object elt
= XCAR (list
);
1039 /* Preserve element ELT if it's t,
1040 if it is a function with a `permanent-local-hook' property,
1041 or if it's not a symbol. */
1044 || !NILP (Fget (elt
, Qpermanent_local_hook
)))
1045 newlist
= Fcons (elt
, newlist
);
1047 XSETCDR (XCAR (tmp
), Fnreverse (newlist
));
1050 /* Delete this local variable. */
1051 else if (NILP (last
))
1052 bset_local_var_alist (b
, XCDR (tmp
));
1054 XSETCDR (last
, XCDR (tmp
));
1057 for (i
= 0; i
< last_per_buffer_idx
; ++i
)
1058 if (permanent_too
|| buffer_permanent_local_flags
[i
] == 0)
1059 SET_PER_BUFFER_VALUE_P (b
, i
, 0);
1061 /* For each slot that has a default value, copy that into the slot. */
1062 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
1064 int idx
= PER_BUFFER_IDX (offset
);
1067 || buffer_permanent_local_flags
[idx
] == 0)))
1068 set_per_buffer_value (b
, offset
, per_buffer_default (offset
));
1072 /* We split this away from generate-new-buffer, because rename-buffer
1073 and set-visited-file-name ought to be able to use this to really
1074 rename the buffer properly. */
1076 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name
,
1077 Sgenerate_new_buffer_name
, 1, 2, 0,
1078 doc
: /* Return a string that is the name of no existing buffer based on NAME.
1079 If there is no live buffer named NAME, then return NAME.
1080 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
1081 \(starting at 2) until an unused name is found, and then return that name.
1082 Optional second argument IGNORE specifies a name that is okay to use (if
1083 it is in the sequence to be tried) even if a buffer with that name exists.
1085 If NAME begins with a space (i.e., a buffer that is not normally
1086 visible to users), then if buffer NAME already exists a random number
1087 is first appended to NAME, to speed up finding a non-existent buffer. */)
1088 (register Lisp_Object name
, Lisp_Object ignore
)
1090 register Lisp_Object gentemp
, tem
, tem2
;
1092 char number
[INT_BUFSIZE_BOUND (ptrdiff_t) + sizeof "<>"];
1094 CHECK_STRING (name
);
1096 tem
= Fstring_equal (name
, ignore
);
1099 tem
= Fget_buffer (name
);
1103 if (!strncmp (SSDATA (name
), " ", 1)) /* see bug#1229 */
1105 /* Note fileio.c:make_temp_name does random differently. */
1106 tem2
= concat2 (name
, make_formatted_string
1108 XFASTINT (Frandom (make_number (999999)))));
1109 tem
= Fget_buffer (tem2
);
1119 gentemp
= concat2 (tem2
, make_formatted_string
1120 (number
, "<%"pD
"d>", ++count
));
1121 tem
= Fstring_equal (gentemp
, ignore
);
1124 tem
= Fget_buffer (gentemp
);
1131 DEFUN ("buffer-name", Fbuffer_name
, Sbuffer_name
, 0, 1, 0,
1132 doc
: /* Return the name of BUFFER, as a string.
1133 BUFFER defaults to the current buffer.
1134 Return nil if BUFFER has been killed. */)
1135 (register Lisp_Object buffer
)
1137 return BVAR (decode_buffer (buffer
), name
);
1140 DEFUN ("buffer-file-name", Fbuffer_file_name
, Sbuffer_file_name
, 0, 1, 0,
1141 doc
: /* Return name of file BUFFER is visiting, or nil if none.
1142 No argument or nil as argument means use the current buffer. */)
1143 (register Lisp_Object buffer
)
1145 return BVAR (decode_buffer (buffer
), filename
);
1148 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer
, Sbuffer_base_buffer
,
1150 doc
: /* Return the base buffer of indirect buffer BUFFER.
1151 If BUFFER is not indirect, return nil.
1152 BUFFER defaults to the current buffer. */)
1153 (register Lisp_Object buffer
)
1155 struct buffer
*base
= decode_buffer (buffer
)->base_buffer
;
1156 return base
? (XSETBUFFER (buffer
, base
), buffer
) : Qnil
;
1159 DEFUN ("buffer-local-value", Fbuffer_local_value
,
1160 Sbuffer_local_value
, 2, 2, 0,
1161 doc
: /* Return the value of VARIABLE in BUFFER.
1162 If VARIABLE does not have a buffer-local binding in BUFFER, the value
1163 is the default binding of the variable. */)
1164 (register Lisp_Object variable
, register Lisp_Object buffer
)
1166 register Lisp_Object result
= buffer_local_value (variable
, buffer
);
1168 if (EQ (result
, Qunbound
))
1169 xsignal1 (Qvoid_variable
, variable
);
1175 /* Like Fbuffer_local_value, but return Qunbound if the variable is
1179 buffer_local_value (Lisp_Object variable
, Lisp_Object buffer
)
1181 register struct buffer
*buf
;
1182 register Lisp_Object result
;
1183 struct Lisp_Symbol
*sym
;
1185 CHECK_SYMBOL (variable
);
1186 CHECK_BUFFER (buffer
);
1187 buf
= XBUFFER (buffer
);
1188 sym
= XSYMBOL (variable
);
1191 switch (sym
->redirect
)
1193 case SYMBOL_VARALIAS
: sym
= indirect_variable (sym
); goto start
;
1194 case SYMBOL_PLAINVAL
: result
= SYMBOL_VAL (sym
); break;
1195 case SYMBOL_LOCALIZED
:
1196 { /* Look in local_var_alist. */
1197 struct Lisp_Buffer_Local_Value
*blv
= SYMBOL_BLV (sym
);
1198 XSETSYMBOL (variable
, sym
); /* Update In case of aliasing. */
1199 result
= Fassoc (variable
, BVAR (buf
, local_var_alist
));
1203 { /* What binding is loaded right now? */
1204 Lisp_Object current_alist_element
= blv
->valcell
;
1206 /* The value of the currently loaded binding is not
1207 stored in it, but rather in the realvalue slot.
1208 Store that value into the binding it belongs to
1209 in case that is the one we are about to use. */
1211 XSETCDR (current_alist_element
,
1212 do_symval_forwarding (blv
->fwd
));
1214 /* Now get the (perhaps updated) value out of the binding. */
1215 result
= XCDR (result
);
1218 result
= Fdefault_value (variable
);
1221 case SYMBOL_FORWARDED
:
1223 union Lisp_Fwd
*fwd
= SYMBOL_FWD (sym
);
1224 if (BUFFER_OBJFWDP (fwd
))
1225 result
= per_buffer_value (buf
, XBUFFER_OBJFWD (fwd
)->offset
);
1227 result
= Fdefault_value (variable
);
1230 default: emacs_abort ();
1236 /* Return an alist of the Lisp-level buffer-local bindings of
1237 buffer BUF. That is, don't include the variables maintained
1238 in special slots in the buffer object.
1239 If not CLONE, replace elements of the form (VAR . unbound)
1243 buffer_lisp_local_variables (struct buffer
*buf
, bool clone
)
1245 Lisp_Object result
= Qnil
;
1247 for (tail
= BVAR (buf
, local_var_alist
); CONSP (tail
); tail
= XCDR (tail
))
1249 Lisp_Object val
, elt
;
1253 /* Reference each variable in the alist in buf.
1254 If inquiring about the current buffer, this gets the current values,
1255 so store them into the alist so the alist is up to date.
1256 If inquiring about some other buffer, this swaps out any values
1257 for that buffer, making the alist up to date automatically. */
1258 val
= find_symbol_value (XCAR (elt
));
1259 /* Use the current buffer value only if buf is the current buffer. */
1260 if (buf
!= current_buffer
)
1263 result
= Fcons (!clone
&& EQ (val
, Qunbound
)
1265 : Fcons (XCAR (elt
), val
),
1272 DEFUN ("buffer-local-variables", Fbuffer_local_variables
,
1273 Sbuffer_local_variables
, 0, 1, 0,
1274 doc
: /* Return an alist of variables that are buffer-local in BUFFER.
1275 Most elements look like (SYMBOL . VALUE), describing one variable.
1276 For a symbol that is locally unbound, just the symbol appears in the value.
1277 Note that storing new VALUEs in these elements doesn't change the variables.
1278 No argument or nil as argument means use current buffer as BUFFER. */)
1279 (Lisp_Object buffer
)
1281 struct buffer
*buf
= decode_buffer (buffer
);
1282 Lisp_Object result
= buffer_lisp_local_variables (buf
, 0);
1284 /* Add on all the variables stored in special slots. */
1288 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
1290 idx
= PER_BUFFER_IDX (offset
);
1291 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
1292 && SYMBOLP (PER_BUFFER_SYMBOL (offset
)))
1294 Lisp_Object sym
= PER_BUFFER_SYMBOL (offset
);
1295 Lisp_Object val
= per_buffer_value (buf
, offset
);
1296 result
= Fcons (EQ (val
, Qunbound
) ? sym
: Fcons (sym
, val
),
1305 DEFUN ("buffer-modified-p", Fbuffer_modified_p
, Sbuffer_modified_p
,
1307 doc
: /* Return t if BUFFER was modified since its file was last read or saved.
1308 No argument or nil as argument means use current buffer as BUFFER. */)
1309 (Lisp_Object buffer
)
1311 struct buffer
*buf
= decode_buffer (buffer
);
1312 return BUF_SAVE_MODIFF (buf
) < BUF_MODIFF (buf
) ? Qt
: Qnil
;
1315 DEFUN ("force-mode-line-update", Fforce_mode_line_update
,
1316 Sforce_mode_line_update
, 0, 1, 0,
1317 doc
: /* Force redisplay of the current buffer's mode line and header line.
1318 With optional non-nil ALL, force redisplay of all mode lines and
1319 header lines. This function also forces recomputation of the
1320 menu bar menus and the frame title. */)
1325 update_mode_lines
= 10;
1326 /* FIXME: This can't be right. */
1327 current_buffer
->prevent_redisplay_optimizations_p
= true;
1329 else if (buffer_window_count (current_buffer
))
1331 bset_update_mode_line (current_buffer
);
1332 current_buffer
->prevent_redisplay_optimizations_p
= true;
1337 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p
, Sset_buffer_modified_p
,
1339 doc
: /* Mark current buffer as modified or unmodified according to FLAG.
1340 A non-nil FLAG means mark the buffer modified. */)
1343 Frestore_buffer_modified_p (flag
);
1345 /* Set update_mode_lines only if buffer is displayed in some window.
1346 Packages like jit-lock or lazy-lock preserve a buffer's modified
1347 state by recording/restoring the state around blocks of code.
1348 Setting update_mode_lines makes redisplay consider all windows
1349 (on all frames). Stealth fontification of buffers not displayed
1350 would incur additional redisplay costs if we'd set
1351 update_modes_lines unconditionally.
1353 Ideally, I think there should be another mechanism for fontifying
1354 buffers without "modifying" buffers, or redisplay should be
1355 smarter about updating the `*' in mode lines. --gerd */
1356 return Fforce_mode_line_update (Qnil
);
1359 DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p
,
1360 Srestore_buffer_modified_p
, 1, 1, 0,
1361 doc
: /* Like `set-buffer-modified-p', with a difference concerning redisplay.
1362 It is not ensured that mode lines will be updated to show the modified
1363 state of the current buffer. Use with care. */)
1368 /* If buffer becoming modified, lock the file.
1369 If buffer becoming unmodified, unlock the file. */
1371 struct buffer
*b
= current_buffer
->base_buffer
1372 ? current_buffer
->base_buffer
1375 fn
= BVAR (b
, file_truename
);
1376 /* Test buffer-file-name so that binding it to nil is effective. */
1377 if (!NILP (fn
) && ! NILP (BVAR (b
, filename
)))
1379 bool already
= SAVE_MODIFF
< MODIFF
;
1380 if (!already
&& !NILP (flag
))
1382 else if (already
&& NILP (flag
))
1386 /* Here we have a problem. SAVE_MODIFF is used here to encode
1387 buffer-modified-p (as SAVE_MODIFF<MODIFF) as well as
1388 recent-auto-save-p (as SAVE_MODIFF<auto_save_modified). So if we
1389 modify SAVE_MODIFF to affect one, we may affect the other
1391 E.g. if FLAG is nil we need to set SAVE_MODIFF to MODIFF, but
1392 if SAVE_MODIFF<auto_save_modified that means we risk changing
1393 recent-auto-save-p from t to nil.
1394 Vice versa, if FLAG is non-nil and SAVE_MODIFF>=auto_save_modified
1395 we risk changing recent-auto-save-p from nil to t. */
1396 SAVE_MODIFF
= (NILP (flag
)
1397 /* FIXME: This unavoidably sets recent-auto-save-p to nil. */
1399 /* Let's try to preserve recent-auto-save-p. */
1400 : SAVE_MODIFF
< MODIFF
? SAVE_MODIFF
1401 /* If SAVE_MODIFF == auto_save_modified == MODIFF,
1402 we can either decrease SAVE_MODIFF and auto_save_modified
1403 or increase MODIFF. */
1409 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick
, Sbuffer_modified_tick
,
1411 doc
: /* Return BUFFER's tick counter, incremented for each change in text.
1412 Each buffer has a tick counter which is incremented each time the
1413 text in that buffer is changed. It wraps around occasionally.
1414 No argument or nil as argument means use current buffer as BUFFER. */)
1415 (register Lisp_Object buffer
)
1417 return make_number (BUF_MODIFF (decode_buffer (buffer
)));
1420 DEFUN ("buffer-chars-modified-tick", Fbuffer_chars_modified_tick
,
1421 Sbuffer_chars_modified_tick
, 0, 1, 0,
1422 doc
: /* Return BUFFER's character-change tick counter.
1423 Each buffer has a character-change tick counter, which is set to the
1424 value of the buffer's tick counter \(see `buffer-modified-tick'), each
1425 time text in that buffer is inserted or deleted. By comparing the
1426 values returned by two individual calls of `buffer-chars-modified-tick',
1427 you can tell whether a character change occurred in that buffer in
1428 between these calls. No argument or nil as argument means use current
1429 buffer as BUFFER. */)
1430 (register Lisp_Object buffer
)
1432 return make_number (BUF_CHARS_MODIFF (decode_buffer (buffer
)));
1435 DEFUN ("rename-buffer", Frename_buffer
, Srename_buffer
, 1, 2,
1436 "(list (read-string \"Rename buffer (to new name): \" \
1437 nil 'buffer-name-history (buffer-name (current-buffer))) \
1438 current-prefix-arg)",
1439 doc
: /* Change current buffer's name to NEWNAME (a string).
1440 If second arg UNIQUE is nil or omitted, it is an error if a
1441 buffer named NEWNAME already exists.
1442 If UNIQUE is non-nil, come up with a new name using
1443 `generate-new-buffer-name'.
1444 Interactively, you can set UNIQUE with a prefix argument.
1445 We return the name we actually gave the buffer.
1446 This does not change the name of the visited file (if any). */)
1447 (register Lisp_Object newname
, Lisp_Object unique
)
1449 register Lisp_Object tem
, buf
;
1451 CHECK_STRING (newname
);
1453 if (SCHARS (newname
) == 0)
1454 error ("Empty string is invalid as a buffer name");
1456 tem
= Fget_buffer (newname
);
1459 /* Don't short-circuit if UNIQUE is t. That is a useful way to
1460 rename the buffer automatically so you can create another
1461 with the original name. It makes UNIQUE equivalent to
1462 (rename-buffer (generate-new-buffer-name NEWNAME)). */
1463 if (NILP (unique
) && XBUFFER (tem
) == current_buffer
)
1464 return BVAR (current_buffer
, name
);
1466 newname
= Fgenerate_new_buffer_name (newname
, BVAR (current_buffer
, name
));
1468 error ("Buffer name `%s' is in use", SDATA (newname
));
1471 bset_name (current_buffer
, newname
);
1473 /* Catch redisplay's attention. Unless we do this, the mode lines for
1474 any windows displaying current_buffer will stay unchanged. */
1475 update_mode_lines
= 11;
1477 XSETBUFFER (buf
, current_buffer
);
1478 Fsetcar (Frassq (buf
, Vbuffer_alist
), newname
);
1479 if (NILP (BVAR (current_buffer
, filename
))
1480 && !NILP (BVAR (current_buffer
, auto_save_file_name
)))
1481 call0 (intern ("rename-auto-save-file"));
1483 /* Run buffer-list-update-hook. */
1484 if (!NILP (Vrun_hooks
))
1485 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1487 /* Refetch since that last call may have done GC. */
1488 return BVAR (current_buffer
, name
);
1491 /* True if B can be used as 'other-than-BUFFER' buffer. */
1494 candidate_buffer (Lisp_Object b
, Lisp_Object buffer
)
1496 return (BUFFERP (b
) && !EQ (b
, buffer
)
1497 && BUFFER_LIVE_P (XBUFFER (b
))
1498 && !BUFFER_HIDDEN_P (XBUFFER (b
)));
1501 DEFUN ("other-buffer", Fother_buffer
, Sother_buffer
, 0, 3, 0,
1502 doc
: /* Return most recently selected buffer other than BUFFER.
1503 Buffers not visible in windows are preferred to visible buffers, unless
1504 optional second argument VISIBLE-OK is non-nil. Ignore the argument
1505 BUFFER unless it denotes a live buffer. If the optional third argument
1506 FRAME is non-nil, use that frame's buffer list instead of the selected
1507 frame's buffer list.
1509 The buffer is found by scanning the selected or specified frame's buffer
1510 list first, followed by the list of all buffers. If no other buffer
1511 exists, return the buffer `*scratch*' (creating it if necessary). */)
1512 (Lisp_Object buffer
, Lisp_Object visible_ok
, Lisp_Object frame
)
1515 struct frame
*f
= decode_any_frame (frame
);
1516 Lisp_Object tail
= f
->buffer_list
, pred
= f
->buffer_predicate
;
1517 Lisp_Object buf
, notsogood
= Qnil
;
1519 /* Consider buffers that have been seen in the frame first. */
1520 for (; CONSP (tail
); tail
= XCDR (tail
))
1523 if (candidate_buffer (buf
, buffer
)
1524 /* If the frame has a buffer_predicate, disregard buffers that
1525 don't fit the predicate. */
1526 && (NILP (pred
) || !NILP (call1 (pred
, buf
))))
1528 if (!NILP (visible_ok
)
1529 || NILP (Fget_buffer_window (buf
, Qvisible
)))
1531 else if (NILP (notsogood
))
1536 /* Consider alist of all buffers next. */
1537 FOR_EACH_LIVE_BUFFER (tail
, buf
)
1539 if (candidate_buffer (buf
, buffer
)
1540 /* If the frame has a buffer_predicate, disregard buffers that
1541 don't fit the predicate. */
1542 && (NILP (pred
) || !NILP (call1 (pred
, buf
))))
1544 if (!NILP (visible_ok
)
1545 || NILP (Fget_buffer_window (buf
, Qvisible
)))
1547 else if (NILP (notsogood
))
1552 if (!NILP (notsogood
))
1556 buf
= Fget_buffer (build_local_string ("*scratch*"));
1559 buf
= Fget_buffer_create (build_local_string ("*scratch*"));
1560 Fset_buffer_major_mode (buf
);
1566 /* The following function is a safe variant of Fother_buffer: It doesn't
1567 pay attention to any frame-local buffer lists, doesn't care about
1568 visibility of buffers, and doesn't evaluate any frame predicates. */
1571 other_buffer_safely (Lisp_Object buffer
)
1574 Lisp_Object tail
, buf
;
1576 FOR_EACH_LIVE_BUFFER (tail
, buf
)
1577 if (candidate_buffer (buf
, buffer
))
1580 buf
= Fget_buffer (build_local_string ("*scratch*"));
1583 buf
= Fget_buffer_create (build_local_string ("*scratch*"));
1584 Fset_buffer_major_mode (buf
);
1590 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo
, Sbuffer_enable_undo
,
1592 doc
: /* Start keeping undo information for buffer BUFFER.
1593 No argument or nil as argument means do this for the current buffer. */)
1594 (register Lisp_Object buffer
)
1596 Lisp_Object real_buffer
;
1599 XSETBUFFER (real_buffer
, current_buffer
);
1602 real_buffer
= Fget_buffer (buffer
);
1603 if (NILP (real_buffer
))
1607 if (EQ (BVAR (XBUFFER (real_buffer
), undo_list
), Qt
))
1608 bset_undo_list (XBUFFER (real_buffer
), Qnil
);
1613 /* Truncate undo list and shrink the gap of BUFFER. */
1616 compact_buffer (struct buffer
*buffer
)
1618 BUFFER_CHECK_INDIRECTION (buffer
);
1620 /* Skip dead buffers, indirect buffers and buffers
1621 which aren't changed since last compaction. */
1622 if (BUFFER_LIVE_P (buffer
)
1623 && (buffer
->base_buffer
== NULL
)
1624 && (BUF_COMPACT (buffer
) != BUF_MODIFF (buffer
)))
1626 /* If a buffer's undo list is Qt, that means that undo is
1627 turned off in that buffer. Calling truncate_undo_list on
1628 Qt tends to return NULL, which effectively turns undo back on.
1629 So don't call truncate_undo_list if undo_list is Qt. */
1630 if (!EQ (buffer
->INTERNAL_FIELD (undo_list
), Qt
))
1631 truncate_undo_list (buffer
);
1633 /* Shrink buffer gaps. */
1634 if (!buffer
->text
->inhibit_shrinking
)
1636 /* If a buffer's gap size is more than 10% of the buffer
1637 size, or larger than GAP_BYTES_DFL bytes, then shrink it
1638 accordingly. Keep a minimum size of GAP_BYTES_MIN bytes. */
1639 ptrdiff_t size
= clip_to_bounds (GAP_BYTES_MIN
,
1640 BUF_Z_BYTE (buffer
) / 10,
1642 if (BUF_GAP_SIZE (buffer
) > size
)
1643 make_gap_1 (buffer
, -(BUF_GAP_SIZE (buffer
) - size
));
1645 BUF_COMPACT (buffer
) = BUF_MODIFF (buffer
);
1649 DEFUN ("kill-buffer", Fkill_buffer
, Skill_buffer
, 0, 1, "bKill buffer: ",
1650 doc
: /* Kill the buffer specified by BUFFER-OR-NAME.
1651 The argument may be a buffer or the name of an existing buffer.
1652 Argument nil or omitted means kill the current buffer. Return t if the
1653 buffer is actually killed, nil otherwise.
1655 The functions in `kill-buffer-query-functions' are called with the
1656 buffer to be killed as the current buffer. If any of them returns nil,
1657 the buffer is not killed. The hook `kill-buffer-hook' is run before the
1658 buffer is actually killed. The buffer being killed will be current
1659 while the hook is running. Functions called by any of these hooks are
1660 supposed to not change the current buffer.
1662 Any processes that have this buffer as the `process-buffer' are killed
1663 with SIGHUP. This function calls `replace-buffer-in-windows' for
1664 cleaning up all windows currently displaying the buffer to be killed. */)
1665 (Lisp_Object buffer_or_name
)
1668 register struct buffer
*b
;
1669 register Lisp_Object tem
;
1670 register struct Lisp_Marker
*m
;
1671 struct gcpro gcpro1
;
1673 if (NILP (buffer_or_name
))
1674 buffer
= Fcurrent_buffer ();
1676 buffer
= Fget_buffer (buffer_or_name
);
1678 nsberror (buffer_or_name
);
1680 b
= XBUFFER (buffer
);
1682 /* Avoid trouble for buffer already dead. */
1683 if (!BUFFER_LIVE_P (b
))
1686 /* Run hooks with the buffer to be killed the current buffer. */
1688 ptrdiff_t count
= SPECPDL_INDEX ();
1689 Lisp_Object arglist
[1];
1691 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1692 set_buffer_internal (b
);
1694 /* First run the query functions; if any query is answered no,
1695 don't kill the buffer. */
1696 arglist
[0] = Qkill_buffer_query_functions
;
1697 tem
= Frun_hook_with_args_until_failure (1, arglist
);
1699 return unbind_to (count
, Qnil
);
1701 /* Query if the buffer is still modified. */
1702 if (INTERACTIVE
&& !NILP (BVAR (b
, filename
))
1703 && BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
1706 tem
= do_yes_or_no_p (format2 ("Buffer %s modified; kill anyway? ",
1707 BVAR (b
, name
), make_number (0)));
1710 return unbind_to (count
, Qnil
);
1713 /* If the hooks have killed the buffer, exit now. */
1714 if (!BUFFER_LIVE_P (b
))
1715 return unbind_to (count
, Qt
);
1717 /* Then run the hooks. */
1718 Frun_hooks (1, &Qkill_buffer_hook
);
1719 unbind_to (count
, Qnil
);
1722 /* If the hooks have killed the buffer, exit now. */
1723 if (!BUFFER_LIVE_P (b
))
1726 /* We have no more questions to ask. Verify that it is valid
1727 to kill the buffer. This must be done after the questions
1728 since anything can happen within do_yes_or_no_p. */
1730 /* Don't kill the minibuffer now current. */
1731 if (EQ (buffer
, XWINDOW (minibuf_window
)->contents
))
1734 /* When we kill an ordinary buffer which shares it's buffer text
1735 with indirect buffer(s), we must kill indirect buffer(s) too.
1736 We do it at this stage so nothing terrible happens if they
1737 ask questions or their hooks get errors. */
1738 if (!b
->base_buffer
&& b
->indirections
> 0)
1740 struct buffer
*other
;
1744 FOR_EACH_BUFFER (other
)
1745 if (other
->base_buffer
== b
)
1748 XSETBUFFER (buf
, other
);
1754 /* Exit if we now have killed the base buffer (Bug#11665). */
1755 if (!BUFFER_LIVE_P (b
))
1759 /* Run replace_buffer_in_windows before making another buffer current
1760 since set-window-buffer-start-and-point will refuse to make another
1761 buffer current if the selected window does not show the current
1762 buffer (bug#10114). */
1763 replace_buffer_in_windows (buffer
);
1765 /* Exit if replacing the buffer in windows has killed our buffer. */
1766 if (!BUFFER_LIVE_P (b
))
1769 /* Make this buffer not be current. Exit if it is the sole visible
1771 if (b
== current_buffer
)
1773 tem
= Fother_buffer (buffer
, Qnil
, Qnil
);
1775 if (b
== current_buffer
)
1779 /* If the buffer now current is shown in the minibuffer and our buffer
1780 is the sole other buffer give up. */
1781 XSETBUFFER (tem
, current_buffer
);
1782 if (EQ (tem
, XWINDOW (minibuf_window
)->contents
)
1783 && EQ (buffer
, Fother_buffer (buffer
, Qnil
, Qnil
)))
1786 /* Now there is no question: we can kill the buffer. */
1788 /* Unlock this buffer's file, if it is locked. */
1792 kill_buffer_processes (buffer
);
1795 /* Killing buffer processes may run sentinels which may have killed
1797 if (!BUFFER_LIVE_P (b
))
1800 /* These may run Lisp code and into infinite loops (if someone
1801 insisted on circular lists) so allow quitting here. */
1802 frames_discard_buffer (buffer
);
1804 clear_charpos_cache (b
);
1806 tem
= Vinhibit_quit
;
1808 /* Remove the buffer from the list of all buffers. */
1809 Vbuffer_alist
= Fdelq (Frassq (buffer
, Vbuffer_alist
), Vbuffer_alist
);
1810 /* If replace_buffer_in_windows didn't do its job fix that now. */
1811 replace_buffer_in_windows_safely (buffer
);
1812 Vinhibit_quit
= tem
;
1814 /* Delete any auto-save file, if we saved it in this session.
1815 But not if the buffer is modified. */
1816 if (STRINGP (BVAR (b
, auto_save_file_name
))
1817 && BUF_AUTOSAVE_MODIFF (b
) != 0
1818 && BUF_SAVE_MODIFF (b
) < BUF_AUTOSAVE_MODIFF (b
)
1819 && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
)
1820 && NILP (Fsymbol_value (intern ("auto-save-visited-file-name"))))
1823 delete = Fsymbol_value (intern ("delete-auto-save-files"));
1824 if (! NILP (delete))
1825 internal_delete_file (BVAR (b
, auto_save_file_name
));
1828 /* Deleting an auto-save file could have killed our buffer. */
1829 if (!BUFFER_LIVE_P (b
))
1835 /* Unchain all markers that belong to this indirect buffer.
1836 Don't unchain the markers that belong to the base buffer
1837 or its other indirect buffers. */
1838 struct Lisp_Marker
**mp
= &BUF_MARKERS (b
);
1849 /* Intervals should be owned by the base buffer (Bug#16502). */
1850 i
= buffer_intervals (b
);
1854 XSETBUFFER (owner
, b
->base_buffer
);
1855 set_interval_object (i
, owner
);
1860 /* Unchain all markers of this buffer and its indirect buffers.
1861 and leave them pointing nowhere. */
1862 for (m
= BUF_MARKERS (b
); m
; )
1864 struct Lisp_Marker
*next
= m
->next
;
1869 BUF_MARKERS (b
) = NULL
;
1870 set_buffer_intervals (b
, NULL
);
1872 /* Perhaps we should explicitly free the interval tree here... */
1874 /* Since we've unlinked the markers, the overlays can't be here any more
1876 b
->overlays_before
= NULL
;
1877 b
->overlays_after
= NULL
;
1879 /* Reset the local variables, so that this buffer's local values
1880 won't be protected from GC. They would be protected
1881 if they happened to remain cached in their symbols.
1882 This gets rid of them for certain. */
1883 swap_out_buffer_local_variables (b
);
1884 reset_buffer_local_variables (b
, 1);
1886 bset_name (b
, Qnil
);
1891 /* Notify our base buffer that we don't share the text anymore. */
1892 eassert (b
->indirections
== -1);
1893 b
->base_buffer
->indirections
--;
1894 eassert (b
->base_buffer
->indirections
>= 0);
1895 /* Make sure that we wasn't confused. */
1896 eassert (b
->window_count
== -1);
1900 /* Make sure that no one shows us. */
1901 eassert (b
->window_count
== 0);
1902 /* No one shares our buffer text, can free it. */
1903 free_buffer_text (b
);
1906 if (b
->newline_cache
)
1908 free_region_cache (b
->newline_cache
);
1909 b
->newline_cache
= 0;
1911 if (b
->width_run_cache
)
1913 free_region_cache (b
->width_run_cache
);
1914 b
->width_run_cache
= 0;
1916 if (b
->bidi_paragraph_cache
)
1918 free_region_cache (b
->bidi_paragraph_cache
);
1919 b
->bidi_paragraph_cache
= 0;
1921 bset_width_table (b
, Qnil
);
1923 bset_undo_list (b
, Qnil
);
1925 /* Run buffer-list-update-hook. */
1926 if (!NILP (Vrun_hooks
))
1927 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1932 /* Move association for BUFFER to the front of buffer (a)lists. Since
1933 we do this each time BUFFER is selected visibly, the more recently
1934 selected buffers are always closer to the front of those lists. This
1935 means that other_buffer is more likely to choose a relevant buffer.
1937 Note that this moves BUFFER to the front of the buffer lists of the
1938 selected frame even if BUFFER is not shown there. If BUFFER is not
1939 shown in the selected frame, consider the present behavior a feature.
1940 `select-window' gets this right since it shows BUFFER in the selected
1941 window when calling us. */
1944 record_buffer (Lisp_Object buffer
)
1946 Lisp_Object aelt
, aelt_cons
, tem
;
1947 register struct frame
*f
= XFRAME (selected_frame
);
1949 CHECK_BUFFER (buffer
);
1951 /* Update Vbuffer_alist (we know that it has an entry for BUFFER).
1952 Don't allow quitting since this might leave the buffer list in an
1953 inconsistent state. */
1954 tem
= Vinhibit_quit
;
1956 aelt
= Frassq (buffer
, Vbuffer_alist
);
1957 aelt_cons
= Fmemq (aelt
, Vbuffer_alist
);
1958 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
1959 XSETCDR (aelt_cons
, Vbuffer_alist
);
1960 Vbuffer_alist
= aelt_cons
;
1961 Vinhibit_quit
= tem
;
1963 /* Update buffer list of selected frame. */
1964 fset_buffer_list (f
, Fcons (buffer
, Fdelq (buffer
, f
->buffer_list
)));
1965 fset_buried_buffer_list (f
, Fdelq (buffer
, f
->buried_buffer_list
));
1967 /* Run buffer-list-update-hook. */
1968 if (!NILP (Vrun_hooks
))
1969 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1973 /* Move BUFFER to the end of the buffer (a)lists. Do nothing if the
1974 buffer is killed. For the selected frame's buffer list this moves
1975 BUFFER to its end even if it was never shown in that frame. If
1976 this happens we have a feature, hence `bury-buffer-internal' should be
1977 called only when BUFFER was shown in the selected frame. */
1979 DEFUN ("bury-buffer-internal", Fbury_buffer_internal
, Sbury_buffer_internal
,
1981 doc
: /* Move BUFFER to the end of the buffer list. */)
1982 (Lisp_Object buffer
)
1984 Lisp_Object aelt
, aelt_cons
, tem
;
1985 register struct frame
*f
= XFRAME (selected_frame
);
1987 CHECK_BUFFER (buffer
);
1989 /* Update Vbuffer_alist (we know that it has an entry for BUFFER).
1990 Don't allow quitting since this might leave the buffer list in an
1991 inconsistent state. */
1992 tem
= Vinhibit_quit
;
1994 aelt
= Frassq (buffer
, Vbuffer_alist
);
1995 aelt_cons
= Fmemq (aelt
, Vbuffer_alist
);
1996 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
1997 XSETCDR (aelt_cons
, Qnil
);
1998 Vbuffer_alist
= nconc2 (Vbuffer_alist
, aelt_cons
);
1999 Vinhibit_quit
= tem
;
2001 /* Update buffer lists of selected frame. */
2002 fset_buffer_list (f
, Fdelq (buffer
, f
->buffer_list
));
2003 fset_buried_buffer_list
2004 (f
, Fcons (buffer
, Fdelq (buffer
, f
->buried_buffer_list
)));
2006 /* Run buffer-list-update-hook. */
2007 if (!NILP (Vrun_hooks
))
2008 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
2013 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode
, Sset_buffer_major_mode
, 1, 1, 0,
2014 doc
: /* Set an appropriate major mode for BUFFER.
2015 For the *scratch* buffer, use `initial-major-mode', otherwise choose a mode
2016 according to the default value of `major-mode'.
2017 Use this function before selecting the buffer, since it may need to inspect
2018 the current buffer's major mode. */)
2019 (Lisp_Object buffer
)
2022 Lisp_Object function
;
2024 CHECK_BUFFER (buffer
);
2026 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
2027 error ("Attempt to set major mode for a dead buffer");
2029 if (strcmp (SSDATA (BVAR (XBUFFER (buffer
), name
)), "*scratch*") == 0)
2030 function
= find_symbol_value (intern ("initial-major-mode"));
2033 function
= BVAR (&buffer_defaults
, major_mode
);
2035 && NILP (Fget (BVAR (current_buffer
, major_mode
), Qmode_class
)))
2036 function
= BVAR (current_buffer
, major_mode
);
2039 if (NILP (function
) || EQ (function
, Qfundamental_mode
))
2042 count
= SPECPDL_INDEX ();
2044 /* To select a nonfundamental mode,
2045 select the buffer temporarily and then call the mode function. */
2047 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2049 Fset_buffer (buffer
);
2052 return unbind_to (count
, Qnil
);
2055 DEFUN ("current-buffer", Fcurrent_buffer
, Scurrent_buffer
, 0, 0, 0,
2056 doc
: /* Return the current buffer as a Lisp object. */)
2059 register Lisp_Object buf
;
2060 XSETBUFFER (buf
, current_buffer
);
2064 /* Set the current buffer to B, and do not set windows_or_buffers_changed.
2065 This is used by redisplay. */
2068 set_buffer_internal_1 (register struct buffer
*b
)
2070 register struct buffer
*old_buf
;
2071 register Lisp_Object tail
;
2073 #ifdef USE_MMAP_FOR_BUFFERS
2074 if (b
->text
->beg
== NULL
)
2075 enlarge_buffer_text (b
, 0);
2076 #endif /* USE_MMAP_FOR_BUFFERS */
2078 if (current_buffer
== b
)
2081 BUFFER_CHECK_INDIRECTION (b
);
2083 old_buf
= current_buffer
;
2085 last_known_column_point
= -1; /* Invalidate indentation cache. */
2089 /* Put the undo list back in the base buffer, so that it appears
2090 that an indirect buffer shares the undo list of its base. */
2091 if (old_buf
->base_buffer
)
2092 bset_undo_list (old_buf
->base_buffer
, BVAR (old_buf
, undo_list
));
2094 /* If the old current buffer has markers to record PT, BEGV and ZV
2095 when it is not current, update them now. */
2096 record_buffer_markers (old_buf
);
2099 /* Get the undo list from the base buffer, so that it appears
2100 that an indirect buffer shares the undo list of its base. */
2102 bset_undo_list (b
, BVAR (b
->base_buffer
, undo_list
));
2104 /* If the new current buffer has markers to record PT, BEGV and ZV
2105 when it is not current, fetch them now. */
2106 fetch_buffer_markers (b
);
2108 /* Look down buffer's list of local Lisp variables
2109 to find and update any that forward into C variables. */
2113 for (tail
= BVAR (b
, local_var_alist
); CONSP (tail
); tail
= XCDR (tail
))
2115 Lisp_Object var
= XCAR (XCAR (tail
));
2116 struct Lisp_Symbol
*sym
= XSYMBOL (var
);
2117 if (sym
->redirect
== SYMBOL_LOCALIZED
/* Just to be sure. */
2118 && SYMBOL_BLV (sym
)->fwd
)
2119 /* Just reference the variable
2120 to cause it to become set for this buffer. */
2121 Fsymbol_value (var
);
2124 /* Do the same with any others that were local to the previous buffer */
2125 while (b
!= old_buf
&& (b
= old_buf
, b
));
2128 /* Switch to buffer B temporarily for redisplay purposes.
2129 This avoids certain things that don't need to be done within redisplay. */
2132 set_buffer_temp (struct buffer
*b
)
2134 register struct buffer
*old_buf
;
2136 if (current_buffer
== b
)
2139 old_buf
= current_buffer
;
2142 /* If the old current buffer has markers to record PT, BEGV and ZV
2143 when it is not current, update them now. */
2144 record_buffer_markers (old_buf
);
2146 /* If the new current buffer has markers to record PT, BEGV and ZV
2147 when it is not current, fetch them now. */
2148 fetch_buffer_markers (b
);
2151 DEFUN ("set-buffer", Fset_buffer
, Sset_buffer
, 1, 1, 0,
2152 doc
: /* Make buffer BUFFER-OR-NAME current for editing operations.
2153 BUFFER-OR-NAME may be a buffer or the name of an existing buffer.
2154 See also `with-current-buffer' when you want to make a buffer current
2155 temporarily. This function does not display the buffer, so its effect
2156 ends when the current command terminates. Use `switch-to-buffer' or
2157 `pop-to-buffer' to switch buffers permanently.
2158 The return value is the buffer made current. */)
2159 (register Lisp_Object buffer_or_name
)
2161 register Lisp_Object buffer
;
2162 buffer
= Fget_buffer (buffer_or_name
);
2164 nsberror (buffer_or_name
);
2165 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
2166 error ("Selecting deleted buffer");
2167 set_buffer_internal (XBUFFER (buffer
));
2172 restore_buffer (Lisp_Object buffer_or_name
)
2174 Fset_buffer (buffer_or_name
);
2177 /* Set the current buffer to BUFFER provided if it is alive. */
2180 set_buffer_if_live (Lisp_Object buffer
)
2182 if (BUFFER_LIVE_P (XBUFFER (buffer
)))
2183 set_buffer_internal (XBUFFER (buffer
));
2186 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only
,
2187 Sbarf_if_buffer_read_only
, 0, 0, 0,
2188 doc
: /* Signal a `buffer-read-only' error if the current buffer is read-only. */)
2191 if (!NILP (BVAR (current_buffer
, read_only
))
2192 && NILP (Vinhibit_read_only
))
2193 xsignal1 (Qbuffer_read_only
, Fcurrent_buffer ());
2197 DEFUN ("erase-buffer", Ferase_buffer
, Serase_buffer
, 0, 0, "*",
2198 doc
: /* Delete the entire contents of the current buffer.
2199 Any narrowing restriction in effect (see `narrow-to-region') is removed,
2200 so the buffer is truly empty after this. */)
2207 current_buffer
->last_window_start
= 1;
2208 /* Prevent warnings, or suspension of auto saving, that would happen
2209 if future size is less than past size. Use of erase-buffer
2210 implies that the future text is not really related to the past text. */
2211 XSETFASTINT (BVAR (current_buffer
, save_length
), 0);
2216 validate_region (register Lisp_Object
*b
, register Lisp_Object
*e
)
2218 CHECK_NUMBER_COERCE_MARKER (*b
);
2219 CHECK_NUMBER_COERCE_MARKER (*e
);
2221 if (XINT (*b
) > XINT (*e
))
2224 tem
= *b
; *b
= *e
; *e
= tem
;
2227 if (! (BEGV
<= XINT (*b
) && XINT (*e
) <= ZV
))
2228 args_out_of_range_3 (Fcurrent_buffer (), *b
, *e
);
2231 /* Advance BYTE_POS up to a character boundary
2232 and return the adjusted position. */
2235 advance_to_char_boundary (ptrdiff_t byte_pos
)
2239 if (byte_pos
== BEG
)
2240 /* Beginning of buffer is always a character boundary. */
2243 c
= FETCH_BYTE (byte_pos
);
2244 if (! CHAR_HEAD_P (c
))
2246 /* We should advance BYTE_POS only when C is a constituent of a
2247 multibyte sequence. */
2248 ptrdiff_t orig_byte_pos
= byte_pos
;
2253 c
= FETCH_BYTE (byte_pos
);
2255 while (! CHAR_HEAD_P (c
) && byte_pos
> BEG
);
2257 if (byte_pos
< orig_byte_pos
)
2258 byte_pos
= orig_byte_pos
;
2259 /* If C is a constituent of a multibyte sequence, BYTE_POS was
2260 surely advance to the correct character boundary. If C is
2261 not, BYTE_POS was unchanged. */
2267 DEFUN ("buffer-swap-text", Fbuffer_swap_text
, Sbuffer_swap_text
,
2269 doc
: /* Swap the text between current buffer and BUFFER. */)
2270 (Lisp_Object buffer
)
2272 struct buffer
*other_buffer
;
2273 CHECK_BUFFER (buffer
);
2274 other_buffer
= XBUFFER (buffer
);
2276 if (!BUFFER_LIVE_P (other_buffer
))
2277 error ("Cannot swap a dead buffer's text");
2279 /* Actually, it probably works just fine.
2280 * if (other_buffer == current_buffer)
2281 * error ("Cannot swap a buffer's text with itself"); */
2283 /* Actually, this may be workable as well, tho probably only if they're
2285 if (other_buffer
->base_buffer
2286 || current_buffer
->base_buffer
)
2287 error ("Cannot swap indirect buffers's text");
2289 { /* This is probably harder to make work. */
2290 struct buffer
*other
;
2291 FOR_EACH_BUFFER (other
)
2292 if (other
->base_buffer
== other_buffer
2293 || other
->base_buffer
== current_buffer
)
2294 error ("One of the buffers to swap has indirect buffers");
2297 #define swapfield(field, type) \
2299 type tmp##field = other_buffer->field; \
2300 other_buffer->field = current_buffer->field; \
2301 current_buffer->field = tmp##field; \
2303 #define swapfield_(field, type) \
2305 type tmp##field = BVAR (other_buffer, field); \
2306 bset_##field (other_buffer, BVAR (current_buffer, field)); \
2307 bset_##field (current_buffer, tmp##field); \
2310 swapfield (own_text
, struct buffer_text
);
2311 eassert (current_buffer
->text
== ¤t_buffer
->own_text
);
2312 eassert (other_buffer
->text
== &other_buffer
->own_text
);
2314 r_alloc_reset_variable ((void **) ¤t_buffer
->own_text
.beg
,
2315 (void **) &other_buffer
->own_text
.beg
);
2316 r_alloc_reset_variable ((void **) &other_buffer
->own_text
.beg
,
2317 (void **) ¤t_buffer
->own_text
.beg
);
2318 #endif /* REL_ALLOC */
2320 swapfield (pt
, ptrdiff_t);
2321 swapfield (pt_byte
, ptrdiff_t);
2322 swapfield (begv
, ptrdiff_t);
2323 swapfield (begv_byte
, ptrdiff_t);
2324 swapfield (zv
, ptrdiff_t);
2325 swapfield (zv_byte
, ptrdiff_t);
2326 eassert (!current_buffer
->base_buffer
);
2327 eassert (!other_buffer
->base_buffer
);
2328 swapfield (indirections
, ptrdiff_t);
2329 current_buffer
->clip_changed
= 1; other_buffer
->clip_changed
= 1;
2330 swapfield (newline_cache
, struct region_cache
*);
2331 swapfield (width_run_cache
, struct region_cache
*);
2332 swapfield (bidi_paragraph_cache
, struct region_cache
*);
2333 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2334 other_buffer
->prevent_redisplay_optimizations_p
= 1;
2335 swapfield (overlays_before
, struct Lisp_Overlay
*);
2336 swapfield (overlays_after
, struct Lisp_Overlay
*);
2337 swapfield (overlay_center
, ptrdiff_t);
2338 swapfield_ (undo_list
, Lisp_Object
);
2339 swapfield_ (mark
, Lisp_Object
);
2340 swapfield_ (enable_multibyte_characters
, Lisp_Object
);
2341 swapfield_ (bidi_display_reordering
, Lisp_Object
);
2342 swapfield_ (bidi_paragraph_direction
, Lisp_Object
);
2343 /* FIXME: Not sure what we should do with these *_marker fields.
2344 Hopefully they're just nil anyway. */
2345 swapfield_ (pt_marker
, Lisp_Object
);
2346 swapfield_ (begv_marker
, Lisp_Object
);
2347 swapfield_ (zv_marker
, Lisp_Object
);
2348 bset_point_before_scroll (current_buffer
, Qnil
);
2349 bset_point_before_scroll (other_buffer
, Qnil
);
2351 current_buffer
->text
->modiff
++; other_buffer
->text
->modiff
++;
2352 current_buffer
->text
->chars_modiff
++; other_buffer
->text
->chars_modiff
++;
2353 current_buffer
->text
->overlay_modiff
++; other_buffer
->text
->overlay_modiff
++;
2354 current_buffer
->text
->beg_unchanged
= current_buffer
->text
->gpt
;
2355 current_buffer
->text
->end_unchanged
= current_buffer
->text
->gpt
;
2356 other_buffer
->text
->beg_unchanged
= other_buffer
->text
->gpt
;
2357 other_buffer
->text
->end_unchanged
= other_buffer
->text
->gpt
;
2359 struct Lisp_Marker
*m
;
2360 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
2361 if (m
->buffer
== other_buffer
)
2362 m
->buffer
= current_buffer
;
2364 /* Since there's no indirect buffer in sight, markers on
2365 BUF_MARKERS(buf) should either be for `buf' or dead. */
2366 eassert (!m
->buffer
);
2367 for (m
= BUF_MARKERS (other_buffer
); m
; m
= m
->next
)
2368 if (m
->buffer
== current_buffer
)
2369 m
->buffer
= other_buffer
;
2371 /* Since there's no indirect buffer in sight, markers on
2372 BUF_MARKERS(buf) should either be for `buf' or dead. */
2373 eassert (!m
->buffer
);
2375 { /* Some of the C code expects that both window markers of a
2376 live window points to that window's buffer. So since we
2377 just swapped the markers between the two buffers, we need
2378 to undo the effect of this swap for window markers. */
2379 Lisp_Object w
= selected_window
, ws
= Qnil
;
2380 Lisp_Object buf1
, buf2
;
2381 XSETBUFFER (buf1
, current_buffer
); XSETBUFFER (buf2
, other_buffer
);
2383 while (NILP (Fmemq (w
, ws
)))
2386 if (MARKERP (XWINDOW (w
)->pointm
)
2387 && (EQ (XWINDOW (w
)->contents
, buf1
)
2388 || EQ (XWINDOW (w
)->contents
, buf2
)))
2389 Fset_marker (XWINDOW (w
)->pointm
,
2391 (BUF_BEGV (XBUFFER (XWINDOW (w
)->contents
))),
2392 XWINDOW (w
)->contents
);
2393 /* Blindly copied from pointm part. */
2394 if (MARKERP (XWINDOW (w
)->old_pointm
)
2395 && (EQ (XWINDOW (w
)->contents
, buf1
)
2396 || EQ (XWINDOW (w
)->contents
, buf2
)))
2397 Fset_marker (XWINDOW (w
)->old_pointm
,
2399 (BUF_BEGV (XBUFFER (XWINDOW (w
)->contents
))),
2400 XWINDOW (w
)->contents
);
2401 if (MARKERP (XWINDOW (w
)->start
)
2402 && (EQ (XWINDOW (w
)->contents
, buf1
)
2403 || EQ (XWINDOW (w
)->contents
, buf2
)))
2404 Fset_marker (XWINDOW (w
)->start
,
2406 (XBUFFER (XWINDOW (w
)->contents
)->last_window_start
),
2407 XWINDOW (w
)->contents
);
2408 w
= Fnext_window (w
, Qt
, Qt
);
2412 if (current_buffer
->text
->intervals
)
2413 (eassert (EQ (current_buffer
->text
->intervals
->up
.obj
, buffer
)),
2414 XSETBUFFER (current_buffer
->text
->intervals
->up
.obj
, current_buffer
));
2415 if (other_buffer
->text
->intervals
)
2416 (eassert (EQ (other_buffer
->text
->intervals
->up
.obj
, Fcurrent_buffer ())),
2417 XSETBUFFER (other_buffer
->text
->intervals
->up
.obj
, other_buffer
));
2422 DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte
, Sset_buffer_multibyte
,
2424 doc
: /* Set the multibyte flag of the current buffer to FLAG.
2425 If FLAG is t, this makes the buffer a multibyte buffer.
2426 If FLAG is nil, this makes the buffer a single-byte buffer.
2427 In these cases, the buffer contents remain unchanged as a sequence of
2428 bytes but the contents viewed as characters do change.
2429 If FLAG is `to', this makes the buffer a multibyte buffer by changing
2430 all eight-bit bytes to eight-bit characters.
2431 If the multibyte flag was really changed, undo information of the
2432 current buffer is cleared. */)
2435 struct Lisp_Marker
*tail
, *markers
;
2436 struct buffer
*other
;
2438 bool narrowed
= (BEG
!= BEGV
|| Z
!= ZV
);
2439 bool modified_p
= !NILP (Fbuffer_modified_p (Qnil
));
2440 Lisp_Object old_undo
= BVAR (current_buffer
, undo_list
);
2441 struct gcpro gcpro1
;
2443 if (current_buffer
->base_buffer
)
2444 error ("Cannot do `set-buffer-multibyte' on an indirect buffer");
2446 /* Do nothing if nothing actually changes. */
2447 if (NILP (flag
) == NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
2452 /* Don't record these buffer changes. We will put a special undo entry
2454 bset_undo_list (current_buffer
, Qt
);
2456 /* If the cached position is for this buffer, clear it out. */
2457 clear_charpos_cache (current_buffer
);
2460 begv
= BEGV_BYTE
, zv
= ZV_BYTE
;
2462 begv
= BEGV
, zv
= ZV
;
2465 error ("Changing multibyteness in a narrowed buffer");
2467 invalidate_buffer_caches (current_buffer
, BEGV
, ZV
);
2471 ptrdiff_t pos
, stop
;
2474 /* Do this first, so it can use CHAR_TO_BYTE
2475 to calculate the old correspondences. */
2476 set_intervals_multibyte (0);
2478 bset_enable_multibyte_characters (current_buffer
, Qnil
);
2484 TEMP_SET_PT_BOTH (PT_BYTE
, PT_BYTE
);
2487 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
2488 tail
->charpos
= tail
->bytepos
;
2490 /* Convert multibyte form of 8-bit characters to unibyte. */
2505 if (ASCII_CHAR_P (*p
))
2507 else if (CHAR_BYTE8_HEAD_P (*p
))
2509 c
= STRING_CHAR_AND_LENGTH (p
, bytes
);
2510 /* Delete all bytes for this 8-bit character but the
2511 last one, and change the last one to the character
2514 del_range_2 (pos
, pos
, pos
+ bytes
, pos
+ bytes
, 0);
2526 bytes
= BYTES_BY_CHAR_HEAD (*p
);
2527 p
+= bytes
, pos
+= bytes
;
2531 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2536 ptrdiff_t pos
, stop
;
2537 unsigned char *p
, *pend
;
2539 /* Be sure not to have a multibyte sequence striding over the GAP.
2540 Ex: We change this: "...abc\302 _GAP_ \241def..."
2541 to: "...abc _GAP_ \302\241def..." */
2544 && GPT_BYTE
> 1 && GPT_BYTE
< Z_BYTE
2545 && ! CHAR_HEAD_P (*(GAP_END_ADDR
)))
2547 unsigned char *q
= GPT_ADDR
- 1;
2549 while (! CHAR_HEAD_P (*q
) && q
> BEG_ADDR
) q
--;
2550 if (LEADING_CODE_P (*q
))
2552 ptrdiff_t new_gpt
= GPT_BYTE
- (GPT_ADDR
- q
);
2554 move_gap_both (new_gpt
, new_gpt
);
2558 /* Make the buffer contents valid as multibyte by converting
2559 8-bit characters to multibyte form. */
2577 if (ASCII_CHAR_P (*p
))
2579 else if (EQ (flag
, Qt
)
2580 && ! CHAR_BYTE8_HEAD_P (*p
)
2581 && (bytes
= MULTIBYTE_LENGTH (p
, pend
)) > 0)
2582 p
+= bytes
, pos
+= bytes
;
2585 unsigned char tmp
[MAX_MULTIBYTE_LENGTH
];
2588 c
= BYTE8_TO_CHAR (*p
);
2589 bytes
= CHAR_STRING (c
, tmp
);
2591 TEMP_SET_PT_BOTH (pos
+ 1, pos
+ 1);
2593 insert_1_both ((char *) tmp
+ 1, bytes
, bytes
, 1, 0, 0);
2594 /* Now the gap is after the just inserted data. */
2612 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2614 /* Do this first, so that chars_in_text asks the right question.
2615 set_intervals_multibyte needs it too. */
2616 bset_enable_multibyte_characters (current_buffer
, Qt
);
2618 GPT_BYTE
= advance_to_char_boundary (GPT_BYTE
);
2619 GPT
= chars_in_text (BEG_ADDR
, GPT_BYTE
- BEG_BYTE
) + BEG
;
2621 Z
= chars_in_text (GAP_END_ADDR
, Z_BYTE
- GPT_BYTE
) + GPT
;
2623 BEGV_BYTE
= advance_to_char_boundary (BEGV_BYTE
);
2624 if (BEGV_BYTE
> GPT_BYTE
)
2625 BEGV
= chars_in_text (GAP_END_ADDR
, BEGV_BYTE
- GPT_BYTE
) + GPT
;
2627 BEGV
= chars_in_text (BEG_ADDR
, BEGV_BYTE
- BEG_BYTE
) + BEG
;
2629 ZV_BYTE
= advance_to_char_boundary (ZV_BYTE
);
2630 if (ZV_BYTE
> GPT_BYTE
)
2631 ZV
= chars_in_text (GAP_END_ADDR
, ZV_BYTE
- GPT_BYTE
) + GPT
;
2633 ZV
= chars_in_text (BEG_ADDR
, ZV_BYTE
- BEG_BYTE
) + BEG
;
2636 ptrdiff_t byte
= advance_to_char_boundary (PT_BYTE
);
2639 if (byte
> GPT_BYTE
)
2640 position
= chars_in_text (GAP_END_ADDR
, byte
- GPT_BYTE
) + GPT
;
2642 position
= chars_in_text (BEG_ADDR
, byte
- BEG_BYTE
) + BEG
;
2643 TEMP_SET_PT_BOTH (position
, byte
);
2646 tail
= markers
= BUF_MARKERS (current_buffer
);
2648 /* This prevents BYTE_TO_CHAR (that is, buf_bytepos_to_charpos) from
2649 getting confused by the markers that have not yet been updated.
2650 It is also a signal that it should never create a marker. */
2651 BUF_MARKERS (current_buffer
) = NULL
;
2653 for (; tail
; tail
= tail
->next
)
2655 tail
->bytepos
= advance_to_char_boundary (tail
->bytepos
);
2656 tail
->charpos
= BYTE_TO_CHAR (tail
->bytepos
);
2659 /* Make sure no markers were put on the chain
2660 while the chain value was incorrect. */
2661 if (BUF_MARKERS (current_buffer
))
2664 BUF_MARKERS (current_buffer
) = markers
;
2666 /* Do this last, so it can calculate the new correspondences
2667 between chars and bytes. */
2668 set_intervals_multibyte (1);
2671 if (!EQ (old_undo
, Qt
))
2673 /* Represent all the above changes by a special undo entry. */
2674 bset_undo_list (current_buffer
,
2675 Fcons (list3 (Qapply
,
2676 intern ("set-buffer-multibyte"),
2677 NILP (flag
) ? Qt
: Qnil
),
2683 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2685 /* If buffer is shown in a window, let redisplay consider other windows. */
2686 if (buffer_window_count (current_buffer
))
2687 windows_or_buffers_changed
= 10;
2689 /* Copy this buffer's new multibyte status
2690 into all of its indirect buffers. */
2691 FOR_EACH_BUFFER (other
)
2692 if (other
->base_buffer
== current_buffer
&& BUFFER_LIVE_P (other
))
2694 BVAR (other
, enable_multibyte_characters
)
2695 = BVAR (current_buffer
, enable_multibyte_characters
);
2696 other
->prevent_redisplay_optimizations_p
= 1;
2699 /* Restore the modifiedness of the buffer. */
2700 if (!modified_p
&& !NILP (Fbuffer_modified_p (Qnil
)))
2701 Fset_buffer_modified_p (Qnil
);
2703 /* Update coding systems of this buffer's process (if any). */
2705 Lisp_Object process
;
2707 process
= Fget_buffer_process (Fcurrent_buffer ());
2708 if (PROCESSP (process
))
2709 setup_process_coding_systems (process
);
2715 DEFUN ("kill-all-local-variables", Fkill_all_local_variables
,
2716 Skill_all_local_variables
, 0, 0, 0,
2717 doc
: /* Switch to Fundamental mode by killing current buffer's local variables.
2718 Most local variable bindings are eliminated so that the default values
2719 become effective once more. Also, the syntax table is set from
2720 `standard-syntax-table', the local keymap is set to nil,
2721 and the abbrev table from `fundamental-mode-abbrev-table'.
2722 This function also forces redisplay of the mode line.
2724 Every function to select a new major mode starts by
2725 calling this function.
2727 As a special exception, local variables whose names have
2728 a non-nil `permanent-local' property are not eliminated by this function.
2730 The first thing this function does is run
2731 the normal hook `change-major-mode-hook'. */)
2734 Frun_hooks (1, &Qchange_major_mode_hook
);
2736 /* Make sure none of the bindings in local_var_alist
2737 remain swapped in, in their symbols. */
2739 swap_out_buffer_local_variables (current_buffer
);
2741 /* Actually eliminate all local bindings of this buffer. */
2743 reset_buffer_local_variables (current_buffer
, 0);
2745 /* Force mode-line redisplay. Useful here because all major mode
2746 commands call this function. */
2747 update_mode_lines
= 12;
2752 /* Make sure no local variables remain set up with buffer B
2753 for their current values. */
2756 swap_out_buffer_local_variables (struct buffer
*b
)
2758 Lisp_Object oalist
, alist
, buffer
;
2760 XSETBUFFER (buffer
, b
);
2761 oalist
= BVAR (b
, local_var_alist
);
2763 for (alist
= oalist
; CONSP (alist
); alist
= XCDR (alist
))
2765 Lisp_Object sym
= XCAR (XCAR (alist
));
2766 eassert (XSYMBOL (sym
)->redirect
== SYMBOL_LOCALIZED
);
2767 /* Need not do anything if some other buffer's binding is
2769 if (EQ (SYMBOL_BLV (XSYMBOL (sym
))->where
, buffer
))
2771 /* Symbol is set up for this buffer's old local value:
2773 swap_in_global_binding (XSYMBOL (sym
));
2778 /* Find all the overlays in the current buffer that contain position POS.
2779 Return the number found, and store them in a vector in *VEC_PTR.
2780 Store in *LEN_PTR the size allocated for the vector.
2781 Store in *NEXT_PTR the next position after POS where an overlay starts,
2782 or ZV if there are no more overlays between POS and ZV.
2783 Store in *PREV_PTR the previous position before POS where an overlay ends,
2784 or where an overlay starts which ends at or after POS;
2785 or BEGV if there are no such overlays from BEGV to POS.
2786 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2788 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2789 when this function is called.
2791 If EXTEND, make the vector bigger if necessary.
2792 If not, never extend the vector,
2793 and store only as many overlays as will fit.
2794 But still return the total number of overlays.
2796 If CHANGE_REQ, any position written into *PREV_PTR or
2797 *NEXT_PTR is guaranteed to be not equal to POS, unless it is the
2798 default (BEGV or ZV). */
2801 overlays_at (EMACS_INT pos
, bool extend
, Lisp_Object
**vec_ptr
,
2803 ptrdiff_t *next_ptr
, ptrdiff_t *prev_ptr
, bool change_req
)
2805 Lisp_Object overlay
, start
, end
;
2806 struct Lisp_Overlay
*tail
;
2808 ptrdiff_t len
= *len_ptr
;
2809 Lisp_Object
*vec
= *vec_ptr
;
2810 ptrdiff_t next
= ZV
;
2811 ptrdiff_t prev
= BEGV
;
2812 bool inhibit_storing
= 0;
2814 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2816 ptrdiff_t startpos
, endpos
;
2818 XSETMISC (overlay
, tail
);
2820 start
= OVERLAY_START (overlay
);
2821 end
= OVERLAY_END (overlay
);
2822 endpos
= OVERLAY_POSITION (end
);
2829 startpos
= OVERLAY_POSITION (start
);
2830 /* This one ends at or after POS
2831 so its start counts for PREV_PTR if it's before POS. */
2832 if (prev
< startpos
&& startpos
< pos
)
2836 if (startpos
<= pos
)
2840 /* The supplied vector is full.
2841 Either make it bigger, or don't store any more in it. */
2844 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2850 inhibit_storing
= 1;
2853 if (!inhibit_storing
)
2855 /* Keep counting overlays even if we can't return them all. */
2858 else if (startpos
< next
)
2862 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2864 ptrdiff_t startpos
, endpos
;
2866 XSETMISC (overlay
, tail
);
2868 start
= OVERLAY_START (overlay
);
2869 end
= OVERLAY_END (overlay
);
2870 startpos
= OVERLAY_POSITION (start
);
2873 if (startpos
< next
)
2877 endpos
= OVERLAY_POSITION (end
);
2884 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2890 inhibit_storing
= 1;
2893 if (!inhibit_storing
)
2897 if (startpos
< pos
&& startpos
> prev
)
2900 else if (endpos
< pos
&& endpos
> prev
)
2902 else if (endpos
== pos
&& startpos
> prev
2903 && (!change_req
|| startpos
< pos
))
2914 /* Find all the overlays in the current buffer that overlap the range
2915 BEG-END, or are empty at BEG, or are empty at END provided END
2916 denotes the position at the end of the current buffer.
2918 Return the number found, and store them in a vector in *VEC_PTR.
2919 Store in *LEN_PTR the size allocated for the vector.
2920 Store in *NEXT_PTR the next position after POS where an overlay starts,
2921 or ZV if there are no more overlays.
2922 Store in *PREV_PTR the previous position before POS where an overlay ends,
2923 or BEGV if there are no previous overlays.
2924 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2926 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2927 when this function is called.
2929 If EXTEND, make the vector bigger if necessary.
2930 If not, never extend the vector,
2931 and store only as many overlays as will fit.
2932 But still return the total number of overlays. */
2935 overlays_in (EMACS_INT beg
, EMACS_INT end
, bool extend
,
2936 Lisp_Object
**vec_ptr
, ptrdiff_t *len_ptr
,
2937 ptrdiff_t *next_ptr
, ptrdiff_t *prev_ptr
)
2939 Lisp_Object overlay
, ostart
, oend
;
2940 struct Lisp_Overlay
*tail
;
2942 ptrdiff_t len
= *len_ptr
;
2943 Lisp_Object
*vec
= *vec_ptr
;
2944 ptrdiff_t next
= ZV
;
2945 ptrdiff_t prev
= BEGV
;
2946 bool inhibit_storing
= 0;
2947 bool end_is_Z
= end
== Z
;
2949 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2951 ptrdiff_t startpos
, endpos
;
2953 XSETMISC (overlay
, tail
);
2955 ostart
= OVERLAY_START (overlay
);
2956 oend
= OVERLAY_END (overlay
);
2957 endpos
= OVERLAY_POSITION (oend
);
2964 startpos
= OVERLAY_POSITION (ostart
);
2965 /* Count an interval if it overlaps the range, is empty at the
2966 start of the range, or is empty at END provided END denotes the
2967 end of the buffer. */
2968 if ((beg
< endpos
&& startpos
< end
)
2969 || (startpos
== endpos
2970 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
2974 /* The supplied vector is full.
2975 Either make it bigger, or don't store any more in it. */
2978 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2984 inhibit_storing
= 1;
2987 if (!inhibit_storing
)
2989 /* Keep counting overlays even if we can't return them all. */
2992 else if (startpos
< next
)
2996 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2998 ptrdiff_t startpos
, endpos
;
3000 XSETMISC (overlay
, tail
);
3002 ostart
= OVERLAY_START (overlay
);
3003 oend
= OVERLAY_END (overlay
);
3004 startpos
= OVERLAY_POSITION (ostart
);
3007 if (startpos
< next
)
3011 endpos
= OVERLAY_POSITION (oend
);
3012 /* Count an interval if it overlaps the range, is empty at the
3013 start of the range, or is empty at END provided END denotes the
3014 end of the buffer. */
3015 if ((beg
< endpos
&& startpos
< end
)
3016 || (startpos
== endpos
3017 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
3023 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
3029 inhibit_storing
= 1;
3032 if (!inhibit_storing
)
3036 else if (endpos
< beg
&& endpos
> prev
)
3048 /* Return true if there exists an overlay with a non-nil
3049 `mouse-face' property overlapping OVERLAY. */
3052 mouse_face_overlay_overlaps (Lisp_Object overlay
)
3054 ptrdiff_t start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3055 ptrdiff_t end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3056 ptrdiff_t n
, i
, size
;
3057 Lisp_Object
*v
, tem
;
3058 Lisp_Object vbuf
[10];
3061 size
= ARRAYELTS (vbuf
);
3063 n
= overlays_in (start
, end
, 0, &v
, &size
, NULL
, NULL
);
3066 SAFE_NALLOCA (v
, 1, n
);
3067 overlays_in (start
, end
, 0, &v
, &n
, NULL
, NULL
);
3070 for (i
= 0; i
< n
; ++i
)
3071 if (!EQ (v
[i
], overlay
)
3072 && (tem
= Foverlay_get (overlay
, Qmouse_face
),
3082 /* Fast function to just test if we're at an overlay boundary. */
3084 overlay_touches_p (ptrdiff_t pos
)
3086 Lisp_Object overlay
;
3087 struct Lisp_Overlay
*tail
;
3089 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
3093 XSETMISC (overlay
,tail
);
3094 eassert (OVERLAYP (overlay
));
3096 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3099 if (endpos
== pos
|| OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
)
3103 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
3107 XSETMISC (overlay
, tail
);
3108 eassert (OVERLAYP (overlay
));
3110 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3113 if (startpos
== pos
|| OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
)
3121 Lisp_Object overlay
;
3124 EMACS_INT spriority
; /* Secondary priority. */
3128 compare_overlays (const void *v1
, const void *v2
)
3130 const struct sortvec
*s1
= v1
;
3131 const struct sortvec
*s2
= v2
;
3132 /* Return 1 if s1 should take precedence, -1 if v2 should take precedence,
3133 and 0 if they're equal. */
3134 if (s1
->priority
!= s2
->priority
)
3135 return s1
->priority
< s2
->priority
? -1 : 1;
3136 /* If the priority is equal, give precedence to the one not covered by the
3137 other. If neither covers the other, obey spriority. */
3138 else if (s1
->beg
< s2
->beg
)
3139 return (s1
->end
< s2
->end
&& s1
->spriority
> s2
->spriority
? 1 : -1);
3140 else if (s1
->beg
> s2
->beg
)
3141 return (s1
->end
> s2
->end
&& s1
->spriority
< s2
->spriority
? -1 : 1);
3142 else if (s1
->end
!= s2
->end
)
3143 return s2
->end
< s1
->end
? -1 : 1;
3144 else if (s1
->spriority
!= s2
->spriority
)
3145 return (s1
->spriority
< s2
->spriority
? -1 : 1);
3146 else if (EQ (s1
->overlay
, s2
->overlay
))
3149 /* Avoid the non-determinism of qsort by choosing an arbitrary ordering
3150 between "equal" overlays. The result can still change between
3151 invocations of Emacs, but it won't change in the middle of
3152 `find_field' (bug#6830). */
3153 return XLI (s1
->overlay
) < XLI (s2
->overlay
) ? -1 : 1;
3156 /* Sort an array of overlays by priority. The array is modified in place.
3157 The return value is the new size; this may be smaller than the original
3158 size if some of the overlays were invalid or were window-specific. */
3160 sort_overlays (Lisp_Object
*overlay_vec
, ptrdiff_t noverlays
, struct window
*w
)
3164 struct sortvec
*sortvec
;
3166 SAFE_NALLOCA (sortvec
, 1, noverlays
);
3168 /* Put the valid and relevant overlays into sortvec. */
3170 for (i
= 0, j
= 0; i
< noverlays
; i
++)
3173 Lisp_Object overlay
;
3175 overlay
= overlay_vec
[i
];
3176 if (OVERLAYP (overlay
)
3177 && OVERLAY_POSITION (OVERLAY_START (overlay
)) > 0
3178 && OVERLAY_POSITION (OVERLAY_END (overlay
)) > 0)
3180 /* If we're interested in a specific window, then ignore
3181 overlays that are limited to some other window. */
3186 window
= Foverlay_get (overlay
, Qwindow
);
3187 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3191 /* This overlay is good and counts: put it into sortvec. */
3192 sortvec
[j
].overlay
= overlay
;
3193 sortvec
[j
].beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3194 sortvec
[j
].end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3195 tem
= Foverlay_get (overlay
, Qpriority
);
3198 sortvec
[j
].priority
= 0;
3199 sortvec
[j
].spriority
= 0;
3201 else if (INTEGERP (tem
))
3203 sortvec
[j
].priority
= XINT (tem
);
3204 sortvec
[j
].spriority
= 0;
3206 else if (CONSP (tem
))
3208 Lisp_Object car
= XCAR (tem
);
3209 Lisp_Object cdr
= XCDR (tem
);
3210 sortvec
[j
].priority
= INTEGERP (car
) ? XINT (car
) : 0;
3211 sortvec
[j
].spriority
= INTEGERP (cdr
) ? XINT (cdr
) : 0;
3218 /* Sort the overlays into the proper order: increasing priority. */
3221 qsort (sortvec
, noverlays
, sizeof (struct sortvec
), compare_overlays
);
3223 for (i
= 0; i
< noverlays
; i
++)
3224 overlay_vec
[i
] = sortvec
[i
].overlay
;
3232 Lisp_Object string
, string2
;
3239 struct sortstr
*buf
; /* An array that expands as needed; never freed. */
3240 ptrdiff_t size
; /* Allocated length of that array. */
3241 ptrdiff_t used
; /* How much of the array is currently in use. */
3242 ptrdiff_t bytes
; /* Total length of the strings in buf. */
3245 /* Buffers for storing information about the overlays touching a given
3246 position. These could be automatic variables in overlay_strings, but
3247 it's more efficient to hold onto the memory instead of repeatedly
3248 allocating and freeing it. */
3249 static struct sortstrlist overlay_heads
, overlay_tails
;
3250 static unsigned char *overlay_str_buf
;
3252 /* Allocated length of overlay_str_buf. */
3253 static ptrdiff_t overlay_str_len
;
3255 /* A comparison function suitable for passing to qsort. */
3257 cmp_for_strings (const void *as1
, const void *as2
)
3259 struct sortstr
const *s1
= as1
;
3260 struct sortstr
const *s2
= as2
;
3261 if (s1
->size
!= s2
->size
)
3262 return s2
->size
< s1
->size
? -1 : 1;
3263 if (s1
->priority
!= s2
->priority
)
3264 return s1
->priority
< s2
->priority
? -1 : 1;
3269 record_overlay_string (struct sortstrlist
*ssl
, Lisp_Object str
,
3270 Lisp_Object str2
, Lisp_Object pri
, ptrdiff_t size
)
3274 if (ssl
->used
== ssl
->size
)
3275 ssl
->buf
= xpalloc (ssl
->buf
, &ssl
->size
, 5, -1, sizeof *ssl
->buf
);
3276 ssl
->buf
[ssl
->used
].string
= str
;
3277 ssl
->buf
[ssl
->used
].string2
= str2
;
3278 ssl
->buf
[ssl
->used
].size
= size
;
3279 ssl
->buf
[ssl
->used
].priority
= (INTEGERP (pri
) ? XINT (pri
) : 0);
3282 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3283 nbytes
= SCHARS (str
);
3284 else if (! STRING_MULTIBYTE (str
))
3285 nbytes
= count_size_as_multibyte (SDATA (str
),
3288 nbytes
= SBYTES (str
);
3290 if (INT_ADD_OVERFLOW (ssl
->bytes
, nbytes
))
3291 memory_full (SIZE_MAX
);
3292 ssl
->bytes
+= nbytes
;
3296 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3297 nbytes
= SCHARS (str2
);
3298 else if (! STRING_MULTIBYTE (str2
))
3299 nbytes
= count_size_as_multibyte (SDATA (str2
),
3302 nbytes
= SBYTES (str2
);
3304 if (INT_ADD_OVERFLOW (ssl
->bytes
, nbytes
))
3305 memory_full (SIZE_MAX
);
3306 ssl
->bytes
+= nbytes
;
3310 /* Concatenate the strings associated with overlays that begin or end
3311 at POS, ignoring overlays that are specific to windows other than W.
3312 The strings are concatenated in the appropriate order: shorter
3313 overlays nest inside longer ones, and higher priority inside lower.
3314 Normally all of the after-strings come first, but zero-sized
3315 overlays have their after-strings ride along with the
3316 before-strings because it would look strange to print them
3319 Returns the concatenated string's length, and return the pointer to
3320 that string via PSTR, if that variable is non-NULL. The storage of
3321 the concatenated strings may be overwritten by subsequent calls. */
3324 overlay_strings (ptrdiff_t pos
, struct window
*w
, unsigned char **pstr
)
3326 Lisp_Object overlay
, window
, str
;
3327 struct Lisp_Overlay
*ov
;
3328 ptrdiff_t startpos
, endpos
;
3329 bool multibyte
= ! NILP (BVAR (current_buffer
, enable_multibyte_characters
));
3331 overlay_heads
.used
= overlay_heads
.bytes
= 0;
3332 overlay_tails
.used
= overlay_tails
.bytes
= 0;
3333 for (ov
= current_buffer
->overlays_before
; ov
; ov
= ov
->next
)
3335 XSETMISC (overlay
, ov
);
3336 eassert (OVERLAYP (overlay
));
3338 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3339 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3342 if (endpos
!= pos
&& startpos
!= pos
)
3344 window
= Foverlay_get (overlay
, Qwindow
);
3345 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3348 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3349 record_overlay_string (&overlay_heads
, str
,
3351 ? Foverlay_get (overlay
, Qafter_string
)
3353 Foverlay_get (overlay
, Qpriority
),
3355 else if (endpos
== pos
3356 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3357 record_overlay_string (&overlay_tails
, str
, Qnil
,
3358 Foverlay_get (overlay
, Qpriority
),
3361 for (ov
= current_buffer
->overlays_after
; ov
; ov
= ov
->next
)
3363 XSETMISC (overlay
, ov
);
3364 eassert (OVERLAYP (overlay
));
3366 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3367 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3370 if (endpos
!= pos
&& startpos
!= pos
)
3372 window
= Foverlay_get (overlay
, Qwindow
);
3373 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3376 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3377 record_overlay_string (&overlay_heads
, str
,
3379 ? Foverlay_get (overlay
, Qafter_string
)
3381 Foverlay_get (overlay
, Qpriority
),
3383 else if (endpos
== pos
3384 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3385 record_overlay_string (&overlay_tails
, str
, Qnil
,
3386 Foverlay_get (overlay
, Qpriority
),
3389 if (overlay_tails
.used
> 1)
3390 qsort (overlay_tails
.buf
, overlay_tails
.used
, sizeof (struct sortstr
),
3392 if (overlay_heads
.used
> 1)
3393 qsort (overlay_heads
.buf
, overlay_heads
.used
, sizeof (struct sortstr
),
3395 if (overlay_heads
.bytes
|| overlay_tails
.bytes
)
3402 if (INT_ADD_OVERFLOW (overlay_heads
.bytes
, overlay_tails
.bytes
))
3403 memory_full (SIZE_MAX
);
3404 total
= overlay_heads
.bytes
+ overlay_tails
.bytes
;
3405 if (total
> overlay_str_len
)
3406 overlay_str_buf
= xpalloc (overlay_str_buf
, &overlay_str_len
,
3407 total
- overlay_str_len
, -1, 1);
3409 p
= overlay_str_buf
;
3410 for (i
= overlay_tails
.used
; --i
>= 0;)
3413 tem
= overlay_tails
.buf
[i
].string
;
3414 nbytes
= copy_text (SDATA (tem
), p
,
3416 STRING_MULTIBYTE (tem
), multibyte
);
3419 for (i
= 0; i
< overlay_heads
.used
; ++i
)
3422 tem
= overlay_heads
.buf
[i
].string
;
3423 nbytes
= copy_text (SDATA (tem
), p
,
3425 STRING_MULTIBYTE (tem
), multibyte
);
3427 tem
= overlay_heads
.buf
[i
].string2
;
3430 nbytes
= copy_text (SDATA (tem
), p
,
3432 STRING_MULTIBYTE (tem
), multibyte
);
3436 if (p
!= overlay_str_buf
+ total
)
3439 *pstr
= overlay_str_buf
;
3445 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
3448 recenter_overlay_lists (struct buffer
*buf
, ptrdiff_t pos
)
3450 Lisp_Object overlay
, beg
, end
;
3451 struct Lisp_Overlay
*prev
, *tail
, *next
;
3453 /* See if anything in overlays_before should move to overlays_after. */
3455 /* We don't strictly need prev in this loop; it should always be nil.
3456 But we use it for symmetry and in case that should cease to be true
3457 with some future change. */
3459 for (tail
= buf
->overlays_before
; tail
; prev
= tail
, tail
= next
)
3462 XSETMISC (overlay
, tail
);
3463 eassert (OVERLAYP (overlay
));
3465 beg
= OVERLAY_START (overlay
);
3466 end
= OVERLAY_END (overlay
);
3468 if (OVERLAY_POSITION (end
) > pos
)
3470 /* OVERLAY needs to be moved. */
3471 ptrdiff_t where
= OVERLAY_POSITION (beg
);
3472 struct Lisp_Overlay
*other
, *other_prev
;
3474 /* Splice the cons cell TAIL out of overlays_before. */
3478 set_buffer_overlays_before (buf
, next
);
3480 /* Search thru overlays_after for where to put it. */
3482 for (other
= buf
->overlays_after
; other
;
3483 other_prev
= other
, other
= other
->next
)
3485 Lisp_Object otherbeg
, otheroverlay
;
3487 XSETMISC (otheroverlay
, other
);
3488 eassert (OVERLAYP (otheroverlay
));
3490 otherbeg
= OVERLAY_START (otheroverlay
);
3491 if (OVERLAY_POSITION (otherbeg
) >= where
)
3495 /* Add TAIL to overlays_after before OTHER. */
3498 other_prev
->next
= tail
;
3500 set_buffer_overlays_after (buf
, tail
);
3504 /* We've reached the things that should stay in overlays_before.
3505 All the rest of overlays_before must end even earlier,
3510 /* See if anything in overlays_after should be in overlays_before. */
3512 for (tail
= buf
->overlays_after
; tail
; prev
= tail
, tail
= next
)
3515 XSETMISC (overlay
, tail
);
3516 eassert (OVERLAYP (overlay
));
3518 beg
= OVERLAY_START (overlay
);
3519 end
= OVERLAY_END (overlay
);
3521 /* Stop looking, when we know that nothing further
3522 can possibly end before POS. */
3523 if (OVERLAY_POSITION (beg
) > pos
)
3526 if (OVERLAY_POSITION (end
) <= pos
)
3528 /* OVERLAY needs to be moved. */
3529 ptrdiff_t where
= OVERLAY_POSITION (end
);
3530 struct Lisp_Overlay
*other
, *other_prev
;
3532 /* Splice the cons cell TAIL out of overlays_after. */
3536 set_buffer_overlays_after (buf
, next
);
3538 /* Search thru overlays_before for where to put it. */
3540 for (other
= buf
->overlays_before
; other
;
3541 other_prev
= other
, other
= other
->next
)
3543 Lisp_Object otherend
, otheroverlay
;
3545 XSETMISC (otheroverlay
, other
);
3546 eassert (OVERLAYP (otheroverlay
));
3548 otherend
= OVERLAY_END (otheroverlay
);
3549 if (OVERLAY_POSITION (otherend
) <= where
)
3553 /* Add TAIL to overlays_before before OTHER. */
3556 other_prev
->next
= tail
;
3558 set_buffer_overlays_before (buf
, tail
);
3563 buf
->overlay_center
= pos
;
3567 adjust_overlays_for_insert (ptrdiff_t pos
, ptrdiff_t length
)
3569 /* After an insertion, the lists are still sorted properly,
3570 but we may need to update the value of the overlay center. */
3571 if (current_buffer
->overlay_center
>= pos
)
3572 current_buffer
->overlay_center
+= length
;
3576 adjust_overlays_for_delete (ptrdiff_t pos
, ptrdiff_t length
)
3578 if (current_buffer
->overlay_center
< pos
)
3579 /* The deletion was to our right. No change needed; the before- and
3580 after-lists are still consistent. */
3582 else if (current_buffer
->overlay_center
- pos
> length
)
3583 /* The deletion was to our left. We need to adjust the center value
3584 to account for the change in position, but the lists are consistent
3585 given the new value. */
3586 current_buffer
->overlay_center
-= length
;
3588 /* We're right in the middle. There might be things on the after-list
3589 that now belong on the before-list. Recentering will move them,
3590 and also update the center point. */
3591 recenter_overlay_lists (current_buffer
, pos
);
3594 /* Fix up overlays that were garbled as a result of permuting markers
3595 in the range START through END. Any overlay with at least one
3596 endpoint in this range will need to be unlinked from the overlay
3597 list and reinserted in its proper place.
3598 Such an overlay might even have negative size at this point.
3599 If so, we'll make the overlay empty. */
3601 fix_start_end_in_overlays (register ptrdiff_t start
, register ptrdiff_t end
)
3603 Lisp_Object overlay
;
3604 struct Lisp_Overlay
*before_list
IF_LINT (= NULL
);
3605 struct Lisp_Overlay
*after_list
IF_LINT (= NULL
);
3606 /* These are either nil, indicating that before_list or after_list
3607 should be assigned, or the cons cell the cdr of which should be
3609 struct Lisp_Overlay
*beforep
= NULL
, *afterp
= NULL
;
3610 /* 'Parent', likewise, indicates a cons cell or
3611 current_buffer->overlays_before or overlays_after, depending
3612 which loop we're in. */
3613 struct Lisp_Overlay
*tail
, *parent
;
3614 ptrdiff_t startpos
, endpos
;
3616 /* This algorithm shifts links around instead of consing and GCing.
3617 The loop invariant is that before_list (resp. after_list) is a
3618 well-formed list except that its last element, the CDR of beforep
3619 (resp. afterp) if beforep (afterp) isn't nil or before_list
3620 (after_list) if it is, is still uninitialized. So it's not a bug
3621 that before_list isn't initialized, although it may look
3623 for (parent
= NULL
, tail
= current_buffer
->overlays_before
; tail
;)
3625 XSETMISC (overlay
, tail
);
3627 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3628 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3630 /* If the overlay is backwards, make it empty. */
3631 if (endpos
< startpos
)
3634 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3642 || (startpos
>= start
&& startpos
< end
))
3644 /* Add it to the end of the wrong list. Later on,
3645 recenter_overlay_lists will move it to the right place. */
3646 if (endpos
< current_buffer
->overlay_center
)
3651 afterp
->next
= tail
;
3659 beforep
->next
= tail
;
3663 set_buffer_overlays_before (current_buffer
, tail
->next
);
3665 parent
->next
= tail
->next
;
3669 parent
= tail
, tail
= parent
->next
;
3671 for (parent
= NULL
, tail
= current_buffer
->overlays_after
; tail
;)
3673 XSETMISC (overlay
, tail
);
3675 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3676 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3678 /* If the overlay is backwards, make it empty. */
3679 if (endpos
< startpos
)
3682 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3686 if (startpos
>= end
)
3689 if (startpos
>= start
3690 || (endpos
>= start
&& endpos
< end
))
3692 if (endpos
< current_buffer
->overlay_center
)
3697 afterp
->next
= tail
;
3705 beforep
->next
= tail
;
3709 set_buffer_overlays_after (current_buffer
, tail
->next
);
3711 parent
->next
= tail
->next
;
3715 parent
= tail
, tail
= parent
->next
;
3718 /* Splice the constructed (wrong) lists into the buffer's lists,
3719 and let the recenter function make it sane again. */
3722 beforep
->next
= current_buffer
->overlays_before
;
3723 set_buffer_overlays_before (current_buffer
, before_list
);
3728 afterp
->next
= current_buffer
->overlays_after
;
3729 set_buffer_overlays_after (current_buffer
, after_list
);
3731 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3734 /* We have two types of overlay: the one whose ending marker is
3735 after-insertion-marker (this is the usual case) and the one whose
3736 ending marker is before-insertion-marker. When `overlays_before'
3737 contains overlays of the latter type and the former type in this
3738 order and both overlays end at inserting position, inserting a text
3739 increases only the ending marker of the latter type, which results
3740 in incorrect ordering of `overlays_before'.
3742 This function fixes ordering of overlays in the slot
3743 `overlays_before' of the buffer *BP. Before the insertion, `point'
3744 was at PREV, and now is at POS. */
3747 fix_overlays_before (struct buffer
*bp
, ptrdiff_t prev
, ptrdiff_t pos
)
3749 /* If parent is nil, replace overlays_before; otherwise, parent->next. */
3750 struct Lisp_Overlay
*tail
= bp
->overlays_before
, *parent
= NULL
, *right_pair
;
3752 ptrdiff_t end
IF_LINT (= 0);
3754 /* After the insertion, the several overlays may be in incorrect
3755 order. The possibility is that, in the list `overlays_before',
3756 an overlay which ends at POS appears after an overlay which ends
3757 at PREV. Since POS is greater than PREV, we must fix the
3758 ordering of these overlays, by moving overlays ends at POS before
3759 the overlays ends at PREV. */
3761 /* At first, find a place where disordered overlays should be linked
3762 in. It is where an overlay which end before POS exists. (i.e. an
3763 overlay whose ending marker is after-insertion-marker if disorder
3766 && (XSETMISC (tem
, tail
),
3767 (end
= OVERLAY_POSITION (OVERLAY_END (tem
))) >= pos
))
3773 /* If we don't find such an overlay,
3774 or the found one ends before PREV,
3775 or the found one is the last one in the list,
3776 we don't have to fix anything. */
3777 if (!tail
|| end
< prev
|| !tail
->next
)
3780 right_pair
= parent
;
3784 /* Now, end position of overlays in the list TAIL should be before
3785 or equal to PREV. In the loop, an overlay which ends at POS is
3786 moved ahead to the place indicated by the CDR of RIGHT_PAIR. If
3787 we found an overlay which ends before PREV, the remaining
3788 overlays are in correct order. */
3791 XSETMISC (tem
, tail
);
3792 end
= OVERLAY_POSITION (OVERLAY_END (tem
));
3795 { /* This overlay is disordered. */
3796 struct Lisp_Overlay
*found
= tail
;
3798 /* Unlink the found overlay. */
3800 parent
->next
= tail
;
3801 /* Move an overlay at RIGHT_PLACE to the next of the found one,
3802 and link it into the right place. */
3805 found
->next
= bp
->overlays_before
;
3806 set_buffer_overlays_before (bp
, found
);
3810 found
->next
= right_pair
->next
;
3811 right_pair
->next
= found
;
3814 else if (end
== prev
)
3819 else /* No more disordered overlay. */
3824 DEFUN ("overlayp", Foverlayp
, Soverlayp
, 1, 1, 0,
3825 doc
: /* Return t if OBJECT is an overlay. */)
3826 (Lisp_Object object
)
3828 return (OVERLAYP (object
) ? Qt
: Qnil
);
3831 DEFUN ("make-overlay", Fmake_overlay
, Smake_overlay
, 2, 5, 0,
3832 doc
: /* Create a new overlay with range BEG to END in BUFFER and return it.
3833 If omitted, BUFFER defaults to the current buffer.
3834 BEG and END may be integers or markers.
3835 The fourth arg FRONT-ADVANCE, if non-nil, makes the marker
3836 for the front of the overlay advance when text is inserted there
3837 \(which means the text *is not* included in the overlay).
3838 The fifth arg REAR-ADVANCE, if non-nil, makes the marker
3839 for the rear of the overlay advance when text is inserted there
3840 \(which means the text *is* included in the overlay). */)
3841 (Lisp_Object beg
, Lisp_Object end
, Lisp_Object buffer
,
3842 Lisp_Object front_advance
, Lisp_Object rear_advance
)
3844 Lisp_Object overlay
;
3848 XSETBUFFER (buffer
, current_buffer
);
3850 CHECK_BUFFER (buffer
);
3852 if (MARKERP (beg
) && !EQ (Fmarker_buffer (beg
), buffer
))
3853 signal_error ("Marker points into wrong buffer", beg
);
3854 if (MARKERP (end
) && !EQ (Fmarker_buffer (end
), buffer
))
3855 signal_error ("Marker points into wrong buffer", end
);
3857 CHECK_NUMBER_COERCE_MARKER (beg
);
3858 CHECK_NUMBER_COERCE_MARKER (end
);
3860 if (XINT (beg
) > XINT (end
))
3863 temp
= beg
; beg
= end
; end
= temp
;
3866 b
= XBUFFER (buffer
);
3868 beg
= Fset_marker (Fmake_marker (), beg
, buffer
);
3869 end
= Fset_marker (Fmake_marker (), end
, buffer
);
3871 if (!NILP (front_advance
))
3872 XMARKER (beg
)->insertion_type
= 1;
3873 if (!NILP (rear_advance
))
3874 XMARKER (end
)->insertion_type
= 1;
3876 overlay
= build_overlay (beg
, end
, Qnil
);
3878 /* Put the new overlay on the wrong list. */
3879 end
= OVERLAY_END (overlay
);
3880 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
3882 eassert (b
->overlays_after
|| (XOVERLAY (overlay
)->next
== NULL
));
3883 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3884 set_buffer_overlays_after (b
, XOVERLAY (overlay
));
3888 eassert (b
->overlays_before
|| (XOVERLAY (overlay
)->next
== NULL
));
3889 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3890 set_buffer_overlays_before (b
, XOVERLAY (overlay
));
3892 /* This puts it in the right list, and in the right order. */
3893 recenter_overlay_lists (b
, b
->overlay_center
);
3895 /* We don't need to redisplay the region covered by the overlay, because
3896 the overlay has no properties at the moment. */
3901 /* Mark a section of BUF as needing redisplay because of overlays changes. */
3904 modify_overlay (struct buffer
*buf
, ptrdiff_t start
, ptrdiff_t end
)
3908 ptrdiff_t temp
= start
;
3913 BUF_COMPUTE_UNCHANGED (buf
, start
, end
);
3915 bset_redisplay (buf
);
3917 ++BUF_OVERLAY_MODIFF (buf
);
3920 /* Remove OVERLAY from LIST. */
3922 static struct Lisp_Overlay
*
3923 unchain_overlay (struct Lisp_Overlay
*list
, struct Lisp_Overlay
*overlay
)
3925 register struct Lisp_Overlay
*tail
, **prev
= &list
;
3927 for (tail
= list
; tail
; prev
= &tail
->next
, tail
= *prev
)
3928 if (tail
== overlay
)
3930 *prev
= overlay
->next
;
3931 overlay
->next
= NULL
;
3937 /* Remove OVERLAY from both overlay lists of B. */
3940 unchain_both (struct buffer
*b
, Lisp_Object overlay
)
3942 struct Lisp_Overlay
*ov
= XOVERLAY (overlay
);
3944 set_buffer_overlays_before (b
, unchain_overlay (b
->overlays_before
, ov
));
3945 set_buffer_overlays_after (b
, unchain_overlay (b
->overlays_after
, ov
));
3946 eassert (XOVERLAY (overlay
)->next
== NULL
);
3949 DEFUN ("move-overlay", Fmove_overlay
, Smove_overlay
, 3, 4, 0,
3950 doc
: /* Set the endpoints of OVERLAY to BEG and END in BUFFER.
3951 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.
3952 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current
3954 (Lisp_Object overlay
, Lisp_Object beg
, Lisp_Object end
, Lisp_Object buffer
)
3956 struct buffer
*b
, *ob
= 0;
3957 Lisp_Object obuffer
;
3958 ptrdiff_t count
= SPECPDL_INDEX ();
3959 ptrdiff_t n_beg
, n_end
, o_beg
IF_LINT (= 0), o_end
IF_LINT (= 0);
3961 CHECK_OVERLAY (overlay
);
3963 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3965 XSETBUFFER (buffer
, current_buffer
);
3966 CHECK_BUFFER (buffer
);
3968 if (NILP (Fbuffer_live_p (buffer
)))
3969 error ("Attempt to move overlay to a dead buffer");
3971 if (MARKERP (beg
) && !EQ (Fmarker_buffer (beg
), buffer
))
3972 signal_error ("Marker points into wrong buffer", beg
);
3973 if (MARKERP (end
) && !EQ (Fmarker_buffer (end
), buffer
))
3974 signal_error ("Marker points into wrong buffer", end
);
3976 CHECK_NUMBER_COERCE_MARKER (beg
);
3977 CHECK_NUMBER_COERCE_MARKER (end
);
3979 if (XINT (beg
) > XINT (end
))
3982 temp
= beg
; beg
= end
; end
= temp
;
3985 specbind (Qinhibit_quit
, Qt
);
3987 obuffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3988 b
= XBUFFER (buffer
);
3990 if (!NILP (obuffer
))
3992 ob
= XBUFFER (obuffer
);
3994 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3995 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3997 unchain_both (ob
, overlay
);
4000 /* Set the overlay boundaries, which may clip them. */
4001 Fset_marker (OVERLAY_START (overlay
), beg
, buffer
);
4002 Fset_marker (OVERLAY_END (overlay
), end
, buffer
);
4004 n_beg
= marker_position (OVERLAY_START (overlay
));
4005 n_end
= marker_position (OVERLAY_END (overlay
));
4007 /* If the overlay has changed buffers, do a thorough redisplay. */
4008 if (!EQ (buffer
, obuffer
))
4010 /* Redisplay where the overlay was. */
4012 modify_overlay (ob
, o_beg
, o_end
);
4014 /* Redisplay where the overlay is going to be. */
4015 modify_overlay (b
, n_beg
, n_end
);
4018 /* Redisplay the area the overlay has just left, or just enclosed. */
4021 modify_overlay (b
, o_end
, n_end
);
4022 else if (o_end
== n_end
)
4023 modify_overlay (b
, o_beg
, n_beg
);
4025 modify_overlay (b
, min (o_beg
, n_beg
), max (o_end
, n_end
));
4028 /* Delete the overlay if it is empty after clipping and has the
4029 evaporate property. */
4030 if (n_beg
== n_end
&& !NILP (Foverlay_get (overlay
, Qevaporate
)))
4031 return unbind_to (count
, Fdelete_overlay (overlay
));
4033 /* Put the overlay into the new buffer's overlay lists, first on the
4035 if (n_end
< b
->overlay_center
)
4037 XOVERLAY (overlay
)->next
= b
->overlays_after
;
4038 set_buffer_overlays_after (b
, XOVERLAY (overlay
));
4042 XOVERLAY (overlay
)->next
= b
->overlays_before
;
4043 set_buffer_overlays_before (b
, XOVERLAY (overlay
));
4046 /* This puts it in the right list, and in the right order. */
4047 recenter_overlay_lists (b
, b
->overlay_center
);
4049 return unbind_to (count
, overlay
);
4052 DEFUN ("delete-overlay", Fdelete_overlay
, Sdelete_overlay
, 1, 1, 0,
4053 doc
: /* Delete the overlay OVERLAY from its buffer. */)
4054 (Lisp_Object overlay
)
4058 ptrdiff_t count
= SPECPDL_INDEX ();
4060 CHECK_OVERLAY (overlay
);
4062 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4066 b
= XBUFFER (buffer
);
4067 specbind (Qinhibit_quit
, Qt
);
4069 unchain_both (b
, overlay
);
4070 drop_overlay (b
, XOVERLAY (overlay
));
4072 /* When deleting an overlay with before or after strings, turn off
4073 display optimizations for the affected buffer, on the basis that
4074 these strings may contain newlines. This is easier to do than to
4075 check for that situation during redisplay. */
4076 if (!windows_or_buffers_changed
4077 && (!NILP (Foverlay_get (overlay
, Qbefore_string
))
4078 || !NILP (Foverlay_get (overlay
, Qafter_string
))))
4079 b
->prevent_redisplay_optimizations_p
= 1;
4081 return unbind_to (count
, Qnil
);
4084 DEFUN ("delete-all-overlays", Fdelete_all_overlays
, Sdelete_all_overlays
, 0, 1, 0,
4085 doc
: /* Delete all overlays of BUFFER.
4086 BUFFER omitted or nil means delete all overlays of the current
4088 (Lisp_Object buffer
)
4090 delete_all_overlays (decode_buffer (buffer
));
4094 /* Overlay dissection functions. */
4096 DEFUN ("overlay-start", Foverlay_start
, Soverlay_start
, 1, 1, 0,
4097 doc
: /* Return the position at which OVERLAY starts. */)
4098 (Lisp_Object overlay
)
4100 CHECK_OVERLAY (overlay
);
4102 return (Fmarker_position (OVERLAY_START (overlay
)));
4105 DEFUN ("overlay-end", Foverlay_end
, Soverlay_end
, 1, 1, 0,
4106 doc
: /* Return the position at which OVERLAY ends. */)
4107 (Lisp_Object overlay
)
4109 CHECK_OVERLAY (overlay
);
4111 return (Fmarker_position (OVERLAY_END (overlay
)));
4114 DEFUN ("overlay-buffer", Foverlay_buffer
, Soverlay_buffer
, 1, 1, 0,
4115 doc
: /* Return the buffer OVERLAY belongs to.
4116 Return nil if OVERLAY has been deleted. */)
4117 (Lisp_Object overlay
)
4119 CHECK_OVERLAY (overlay
);
4121 return Fmarker_buffer (OVERLAY_START (overlay
));
4124 DEFUN ("overlay-properties", Foverlay_properties
, Soverlay_properties
, 1, 1, 0,
4125 doc
: /* Return a list of the properties on OVERLAY.
4126 This is a copy of OVERLAY's plist; modifying its conses has no effect on
4128 (Lisp_Object overlay
)
4130 CHECK_OVERLAY (overlay
);
4132 return Fcopy_sequence (XOVERLAY (overlay
)->plist
);
4136 DEFUN ("overlays-at", Foverlays_at
, Soverlays_at
, 1, 2, 0,
4137 doc
: /* Return a list of the overlays that contain the character at POS.
4138 If SORTED is non-nil, then sort them by decreasing priority. */)
4139 (Lisp_Object pos
, Lisp_Object sorted
)
4141 ptrdiff_t len
, noverlays
;
4142 Lisp_Object
*overlay_vec
;
4145 CHECK_NUMBER_COERCE_MARKER (pos
);
4147 if (!buffer_has_overlays ())
4151 /* We can't use alloca here because overlays_at can call xrealloc. */
4152 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4154 /* Put all the overlays we want in a vector in overlay_vec.
4155 Store the length in len. */
4156 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4160 noverlays
= sort_overlays (overlay_vec
, noverlays
,
4161 WINDOWP (sorted
) ? XWINDOW (sorted
) : NULL
);
4163 /* Make a list of them all. */
4164 result
= Flist (noverlays
, overlay_vec
);
4166 xfree (overlay_vec
);
4170 DEFUN ("overlays-in", Foverlays_in
, Soverlays_in
, 2, 2, 0,
4171 doc
: /* Return a list of the overlays that overlap the region BEG ... END.
4172 Overlap means that at least one character is contained within the overlay
4173 and also contained within the specified region.
4174 Empty overlays are included in the result if they are located at BEG,
4175 between BEG and END, or at END provided END denotes the position at the
4176 end of the buffer. */)
4177 (Lisp_Object beg
, Lisp_Object end
)
4179 ptrdiff_t len
, noverlays
;
4180 Lisp_Object
*overlay_vec
;
4183 CHECK_NUMBER_COERCE_MARKER (beg
);
4184 CHECK_NUMBER_COERCE_MARKER (end
);
4186 if (!buffer_has_overlays ())
4190 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4192 /* Put all the overlays we want in a vector in overlay_vec.
4193 Store the length in len. */
4194 noverlays
= overlays_in (XINT (beg
), XINT (end
), 1, &overlay_vec
, &len
,
4197 /* Make a list of them all. */
4198 result
= Flist (noverlays
, overlay_vec
);
4200 xfree (overlay_vec
);
4204 DEFUN ("next-overlay-change", Fnext_overlay_change
, Snext_overlay_change
,
4206 doc
: /* Return the next position after POS where an overlay starts or ends.
4207 If there are no overlay boundaries from POS to (point-max),
4208 the value is (point-max). */)
4211 ptrdiff_t i
, len
, noverlays
;
4213 Lisp_Object
*overlay_vec
;
4215 CHECK_NUMBER_COERCE_MARKER (pos
);
4217 if (!buffer_has_overlays ())
4218 return make_number (ZV
);
4221 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4223 /* Put all the overlays we want in a vector in overlay_vec.
4224 Store the length in len.
4225 endpos gets the position where the next overlay starts. */
4226 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4229 /* If any of these overlays ends before endpos,
4230 use its ending point instead. */
4231 for (i
= 0; i
< noverlays
; i
++)
4236 oend
= OVERLAY_END (overlay_vec
[i
]);
4237 oendpos
= OVERLAY_POSITION (oend
);
4238 if (oendpos
< endpos
)
4242 xfree (overlay_vec
);
4243 return make_number (endpos
);
4246 DEFUN ("previous-overlay-change", Fprevious_overlay_change
,
4247 Sprevious_overlay_change
, 1, 1, 0,
4248 doc
: /* Return the previous position before POS where an overlay starts or ends.
4249 If there are no overlay boundaries from (point-min) to POS,
4250 the value is (point-min). */)
4254 Lisp_Object
*overlay_vec
;
4257 CHECK_NUMBER_COERCE_MARKER (pos
);
4259 if (!buffer_has_overlays ())
4260 return make_number (BEGV
);
4262 /* At beginning of buffer, we know the answer;
4263 avoid bug subtracting 1 below. */
4264 if (XINT (pos
) == BEGV
)
4268 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4270 /* Put all the overlays we want in a vector in overlay_vec.
4271 Store the length in len.
4272 prevpos gets the position of the previous change. */
4273 overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4276 xfree (overlay_vec
);
4277 return make_number (prevpos
);
4280 /* These functions are for debugging overlays. */
4282 DEFUN ("overlay-lists", Foverlay_lists
, Soverlay_lists
, 0, 0, 0,
4283 doc
: /* Return a pair of lists giving all the overlays of the current buffer.
4284 The car has all the overlays before the overlay center;
4285 the cdr has all the overlays after the overlay center.
4286 Recentering overlays moves overlays between these lists.
4287 The lists you get are copies, so that changing them has no effect.
4288 However, the overlays you get are the real objects that the buffer uses. */)
4291 struct Lisp_Overlay
*ol
;
4292 Lisp_Object before
= Qnil
, after
= Qnil
, tmp
;
4294 for (ol
= current_buffer
->overlays_before
; ol
; ol
= ol
->next
)
4297 before
= Fcons (tmp
, before
);
4299 for (ol
= current_buffer
->overlays_after
; ol
; ol
= ol
->next
)
4302 after
= Fcons (tmp
, after
);
4305 return Fcons (Fnreverse (before
), Fnreverse (after
));
4308 DEFUN ("overlay-recenter", Foverlay_recenter
, Soverlay_recenter
, 1, 1, 0,
4309 doc
: /* Recenter the overlays of the current buffer around position POS.
4310 That makes overlay lookup faster for positions near POS (but perhaps slower
4311 for positions far away from POS). */)
4315 CHECK_NUMBER_COERCE_MARKER (pos
);
4317 p
= clip_to_bounds (PTRDIFF_MIN
, XINT (pos
), PTRDIFF_MAX
);
4318 recenter_overlay_lists (current_buffer
, p
);
4322 DEFUN ("overlay-get", Foverlay_get
, Soverlay_get
, 2, 2, 0,
4323 doc
: /* Get the property of overlay OVERLAY with property name PROP. */)
4324 (Lisp_Object overlay
, Lisp_Object prop
)
4326 CHECK_OVERLAY (overlay
);
4327 return lookup_char_property (XOVERLAY (overlay
)->plist
, prop
, 0);
4330 DEFUN ("overlay-put", Foverlay_put
, Soverlay_put
, 3, 3, 0,
4331 doc
: /* Set one property of overlay OVERLAY: give property PROP value VALUE.
4332 VALUE will be returned.*/)
4333 (Lisp_Object overlay
, Lisp_Object prop
, Lisp_Object value
)
4335 Lisp_Object tail
, buffer
;
4338 CHECK_OVERLAY (overlay
);
4340 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4342 for (tail
= XOVERLAY (overlay
)->plist
;
4343 CONSP (tail
) && CONSP (XCDR (tail
));
4344 tail
= XCDR (XCDR (tail
)))
4345 if (EQ (XCAR (tail
), prop
))
4347 changed
= !EQ (XCAR (XCDR (tail
)), value
);
4348 XSETCAR (XCDR (tail
), value
);
4351 /* It wasn't in the list, so add it to the front. */
4352 changed
= !NILP (value
);
4354 (overlay
, Fcons (prop
, Fcons (value
, XOVERLAY (overlay
)->plist
)));
4356 if (! NILP (buffer
))
4359 modify_overlay (XBUFFER (buffer
),
4360 marker_position (OVERLAY_START (overlay
)),
4361 marker_position (OVERLAY_END (overlay
)));
4362 if (EQ (prop
, Qevaporate
) && ! NILP (value
)
4363 && (OVERLAY_POSITION (OVERLAY_START (overlay
))
4364 == OVERLAY_POSITION (OVERLAY_END (overlay
))))
4365 Fdelete_overlay (overlay
);
4371 /* Subroutine of report_overlay_modification. */
4373 /* Lisp vector holding overlay hook functions to call.
4374 Vector elements come in pairs.
4375 Each even-index element is a list of hook functions.
4376 The following odd-index element is the overlay they came from.
4378 Before the buffer change, we fill in this vector
4379 as we call overlay hook functions.
4380 After the buffer change, we get the functions to call from this vector.
4381 This way we always call the same functions before and after the change. */
4382 static Lisp_Object last_overlay_modification_hooks
;
4384 /* Number of elements actually used in last_overlay_modification_hooks. */
4385 static ptrdiff_t last_overlay_modification_hooks_used
;
4387 /* Add one functionlist/overlay pair
4388 to the end of last_overlay_modification_hooks. */
4391 add_overlay_mod_hooklist (Lisp_Object functionlist
, Lisp_Object overlay
)
4393 ptrdiff_t oldsize
= ASIZE (last_overlay_modification_hooks
);
4395 if (oldsize
- 1 <= last_overlay_modification_hooks_used
)
4396 last_overlay_modification_hooks
=
4397 larger_vector (last_overlay_modification_hooks
, 2, -1);
4398 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4399 functionlist
); last_overlay_modification_hooks_used
++;
4400 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4401 overlay
); last_overlay_modification_hooks_used
++;
4404 /* Run the modification-hooks of overlays that include
4405 any part of the text in START to END.
4406 If this change is an insertion, also
4407 run the insert-before-hooks of overlay starting at END,
4408 and the insert-after-hooks of overlay ending at START.
4410 This is called both before and after the modification.
4411 AFTER is true when we call after the modification.
4413 ARG1, ARG2, ARG3 are arguments to pass to the hook functions.
4414 When AFTER is nonzero, they are the start position,
4415 the position after the inserted new text,
4416 and the length of deleted or replaced old text. */
4419 report_overlay_modification (Lisp_Object start
, Lisp_Object end
, bool after
,
4420 Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
)
4422 Lisp_Object prop
, overlay
;
4423 struct Lisp_Overlay
*tail
;
4424 /* True if this change is an insertion. */
4425 bool insertion
= (after
? XFASTINT (arg3
) == 0 : EQ (start
, end
));
4426 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4431 /* We used to run the functions as soon as we found them and only register
4432 them in last_overlay_modification_hooks for the purpose of the `after'
4433 case. But running elisp code as we traverse the list of overlays is
4434 painful because the list can be modified by the elisp code so we had to
4435 copy at several places. We now simply do a read-only traversal that
4436 only collects the functions to run and we run them afterwards. It's
4437 simpler, especially since all the code was already there. -stef */
4441 /* We are being called before a change.
4442 Scan the overlays to find the functions to call. */
4443 last_overlay_modification_hooks_used
= 0;
4444 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4446 ptrdiff_t startpos
, endpos
;
4447 Lisp_Object ostart
, oend
;
4449 XSETMISC (overlay
, tail
);
4451 ostart
= OVERLAY_START (overlay
);
4452 oend
= OVERLAY_END (overlay
);
4453 endpos
= OVERLAY_POSITION (oend
);
4454 if (XFASTINT (start
) > endpos
)
4456 startpos
= OVERLAY_POSITION (ostart
);
4457 if (insertion
&& (XFASTINT (start
) == startpos
4458 || XFASTINT (end
) == startpos
))
4460 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4462 add_overlay_mod_hooklist (prop
, overlay
);
4464 if (insertion
&& (XFASTINT (start
) == endpos
4465 || XFASTINT (end
) == endpos
))
4467 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4469 add_overlay_mod_hooklist (prop
, overlay
);
4471 /* Test for intersecting intervals. This does the right thing
4472 for both insertion and deletion. */
4473 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4475 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4477 add_overlay_mod_hooklist (prop
, overlay
);
4481 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4483 ptrdiff_t startpos
, endpos
;
4484 Lisp_Object ostart
, oend
;
4486 XSETMISC (overlay
, tail
);
4488 ostart
= OVERLAY_START (overlay
);
4489 oend
= OVERLAY_END (overlay
);
4490 startpos
= OVERLAY_POSITION (ostart
);
4491 endpos
= OVERLAY_POSITION (oend
);
4492 if (XFASTINT (end
) < startpos
)
4494 if (insertion
&& (XFASTINT (start
) == startpos
4495 || XFASTINT (end
) == startpos
))
4497 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4499 add_overlay_mod_hooklist (prop
, overlay
);
4501 if (insertion
&& (XFASTINT (start
) == endpos
4502 || XFASTINT (end
) == endpos
))
4504 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4506 add_overlay_mod_hooklist (prop
, overlay
);
4508 /* Test for intersecting intervals. This does the right thing
4509 for both insertion and deletion. */
4510 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4512 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4514 add_overlay_mod_hooklist (prop
, overlay
);
4519 GCPRO4 (overlay
, arg1
, arg2
, arg3
);
4521 /* Call the functions recorded in last_overlay_modification_hooks.
4522 First copy the vector contents, in case some of these hooks
4523 do subsequent modification of the buffer. */
4524 ptrdiff_t size
= last_overlay_modification_hooks_used
;
4529 SAFE_ALLOCA_LISP (copy
, size
);
4530 memcpy (copy
, XVECTOR (last_overlay_modification_hooks
)->contents
,
4533 for (i
= 0; i
< size
;)
4535 Lisp_Object prop_i
, overlay_i
;
4537 overlay_i
= copy
[i
++];
4538 call_overlay_mod_hooks (prop_i
, overlay_i
, after
, arg1
, arg2
, arg3
);
4547 call_overlay_mod_hooks (Lisp_Object list
, Lisp_Object overlay
, bool after
,
4548 Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
)
4550 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4552 GCPRO4 (list
, arg1
, arg2
, arg3
);
4554 while (CONSP (list
))
4557 call4 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
);
4559 call5 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
, arg3
);
4565 /* Delete any zero-sized overlays at position POS, if the `evaporate'
4568 evaporate_overlays (ptrdiff_t pos
)
4570 Lisp_Object overlay
, hit_list
;
4571 struct Lisp_Overlay
*tail
;
4574 if (pos
<= current_buffer
->overlay_center
)
4575 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4578 XSETMISC (overlay
, tail
);
4579 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4582 if (endpos
== pos
&& OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
4583 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4584 hit_list
= Fcons (overlay
, hit_list
);
4587 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4590 XSETMISC (overlay
, tail
);
4591 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4594 if (startpos
== pos
&& OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
4595 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4596 hit_list
= Fcons (overlay
, hit_list
);
4598 for (; CONSP (hit_list
); hit_list
= XCDR (hit_list
))
4599 Fdelete_overlay (XCAR (hit_list
));
4602 /***********************************************************************
4603 Allocation with mmap
4604 ***********************************************************************/
4606 /* Note: WINDOWSNT implements this stuff on w32heap.c. */
4607 #if defined USE_MMAP_FOR_BUFFERS && !defined WINDOWSNT
4609 #include <sys/mman.h>
4612 #ifdef MAP_ANONYMOUS
4613 #define MAP_ANON MAP_ANONYMOUS
4620 #define MAP_FAILED ((void *) -1)
4630 /* Memory is allocated in regions which are mapped using mmap(2).
4631 The current implementation lets the system select mapped
4632 addresses; we're not using MAP_FIXED in general, except when
4633 trying to enlarge regions.
4635 Each mapped region starts with a mmap_region structure, the user
4636 area starts after that structure, aligned to MEM_ALIGN.
4638 +-----------------------+
4639 | struct mmap_info + |
4641 +-----------------------+
4645 +-----------------------+ */
4649 /* User-specified size. */
4650 size_t nbytes_specified
;
4652 /* Number of bytes mapped */
4653 size_t nbytes_mapped
;
4655 /* Pointer to the location holding the address of the memory
4656 allocated with the mmap'd block. The variable actually points
4657 after this structure. */
4660 /* Next and previous in list of all mmap'd regions. */
4661 struct mmap_region
*next
, *prev
;
4664 /* Doubly-linked list of mmap'd regions. */
4666 static struct mmap_region
*mmap_regions
;
4668 /* File descriptor for mmap. If we don't have anonymous mapping,
4669 /dev/zero will be opened on it. */
4673 /* Page size on this system. */
4675 static int mmap_page_size
;
4677 /* 1 means mmap has been initialized. */
4679 static bool mmap_initialized_p
;
4681 /* Value is X rounded up to the next multiple of N. */
4683 #define ROUND(X, N) (((X) + (N) - 1) / (N) * (N))
4685 /* Size of mmap_region structure plus padding. */
4687 #define MMAP_REGION_STRUCT_SIZE \
4688 ROUND (sizeof (struct mmap_region), MEM_ALIGN)
4690 /* Given a pointer P to the start of the user-visible part of a mapped
4691 region, return a pointer to the start of the region. */
4693 #define MMAP_REGION(P) \
4694 ((struct mmap_region *) ((char *) (P) - MMAP_REGION_STRUCT_SIZE))
4696 /* Given a pointer P to the start of a mapped region, return a pointer
4697 to the start of the user-visible part of the region. */
4699 #define MMAP_USER_AREA(P) \
4700 ((void *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
4702 #define MEM_ALIGN sizeof (double)
4704 /* Predicate returning true if part of the address range [START .. END]
4705 is currently mapped. Used to prevent overwriting an existing
4708 Default is to conservatively assume the address range is occupied by
4709 something else. This can be overridden by system configuration
4710 files if system-specific means to determine this exists. */
4712 #ifndef MMAP_ALLOCATED_P
4713 #define MMAP_ALLOCATED_P(start, end) 1
4716 /* Perform necessary initializations for the use of mmap. */
4722 /* The value of mmap_fd is initially 0 in temacs, and -1
4723 in a dumped Emacs. */
4726 /* No anonymous mmap -- we need the file descriptor. */
4727 mmap_fd
= emacs_open ("/dev/zero", O_RDONLY
, 0);
4729 fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno
));
4731 #endif /* MAP_ANON == 0 */
4733 if (mmap_initialized_p
)
4735 mmap_initialized_p
= 1;
4741 mmap_page_size
= getpagesize ();
4744 /* Unmap a region. P is a pointer to the start of the user-araa of
4748 mmap_free_1 (struct mmap_region
*r
)
4751 r
->next
->prev
= r
->prev
;
4753 r
->prev
->next
= r
->next
;
4755 mmap_regions
= r
->next
;
4757 if (munmap (r
, r
->nbytes_mapped
) == -1)
4758 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4762 /* Enlarge region R by NPAGES pages. NPAGES < 0 means shrink R.
4763 Value is true if successful. */
4766 mmap_enlarge (struct mmap_region
*r
, int npages
)
4768 char *region_end
= (char *) r
+ r
->nbytes_mapped
;
4774 /* Unmap pages at the end of the region. */
4775 nbytes
= - npages
* mmap_page_size
;
4776 if (munmap (region_end
- nbytes
, nbytes
) == -1)
4777 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4780 r
->nbytes_mapped
-= nbytes
;
4784 else if (npages
> 0)
4786 nbytes
= npages
* mmap_page_size
;
4788 /* Try to map additional pages at the end of the region. We
4789 cannot do this if the address range is already occupied by
4790 something else because mmap deletes any previous mapping.
4791 I'm not sure this is worth doing, let's see. */
4792 if (!MMAP_ALLOCATED_P (region_end
, region_end
+ nbytes
))
4796 p
= mmap (region_end
, nbytes
, PROT_READ
| PROT_WRITE
,
4797 MAP_ANON
| MAP_PRIVATE
| MAP_FIXED
, mmap_fd
, 0);
4798 if (p
== MAP_FAILED
)
4799 ; /* fprintf (stderr, "mmap: %s\n", emacs_strerror (errno)); */
4800 else if (p
!= region_end
)
4802 /* Kernels are free to choose a different address. In
4803 that case, unmap what we've mapped above; we have
4805 if (munmap (p
, nbytes
) == -1)
4806 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4810 r
->nbytes_mapped
+= nbytes
;
4820 /* Allocate a block of storage large enough to hold NBYTES bytes of
4821 data. A pointer to the data is returned in *VAR. VAR is thus the
4822 address of some variable which will use the data area.
4824 The allocation of 0 bytes is valid.
4826 If we can't allocate the necessary memory, set *VAR to null, and
4830 mmap_alloc (void **var
, size_t nbytes
)
4837 map
= ROUND (nbytes
+ MMAP_REGION_STRUCT_SIZE
, mmap_page_size
);
4838 p
= mmap (NULL
, map
, PROT_READ
| PROT_WRITE
, MAP_ANON
| MAP_PRIVATE
,
4841 if (p
== MAP_FAILED
)
4843 if (errno
!= ENOMEM
)
4844 fprintf (stderr
, "mmap: %s\n", emacs_strerror (errno
));
4849 struct mmap_region
*r
= p
;
4851 r
->nbytes_specified
= nbytes
;
4852 r
->nbytes_mapped
= map
;
4855 r
->next
= mmap_regions
;
4860 p
= MMAP_USER_AREA (p
);
4867 /* Free a block of relocatable storage whose data is pointed to by
4868 PTR. Store 0 in *PTR to show there's no block allocated. */
4871 mmap_free (void **var
)
4877 mmap_free_1 (MMAP_REGION (*var
));
4883 /* Given a pointer at address VAR to data allocated with mmap_alloc,
4884 resize it to size NBYTES. Change *VAR to reflect the new block,
4885 and return this value. If more memory cannot be allocated, then
4886 leave *VAR unchanged, and return null. */
4889 mmap_realloc (void **var
, size_t nbytes
)
4896 result
= mmap_alloc (var
, nbytes
);
4897 else if (nbytes
== 0)
4900 result
= mmap_alloc (var
, nbytes
);
4904 struct mmap_region
*r
= MMAP_REGION (*var
);
4905 size_t room
= r
->nbytes_mapped
- MMAP_REGION_STRUCT_SIZE
;
4910 void *old_ptr
= *var
;
4912 /* Try to map additional pages at the end of the region.
4913 If that fails, allocate a new region, copy data
4914 from the old region, then free it. */
4915 if (mmap_enlarge (r
, (ROUND (nbytes
- room
, mmap_page_size
)
4918 r
->nbytes_specified
= nbytes
;
4919 *var
= result
= old_ptr
;
4921 else if (mmap_alloc (var
, nbytes
))
4923 memcpy (*var
, old_ptr
, r
->nbytes_specified
);
4924 mmap_free_1 (MMAP_REGION (old_ptr
));
4926 r
= MMAP_REGION (result
);
4927 r
->nbytes_specified
= nbytes
;
4935 else if (room
- nbytes
>= mmap_page_size
)
4937 /* Shrinking by at least a page. Let's give some
4938 memory back to the system.
4940 The extra parens are to make the division happens first,
4941 on positive values, so we know it will round towards
4943 mmap_enlarge (r
, - ((room
- nbytes
) / mmap_page_size
));
4945 r
->nbytes_specified
= nbytes
;
4949 /* Leave it alone. */
4951 r
->nbytes_specified
= nbytes
;
4959 #endif /* USE_MMAP_FOR_BUFFERS */
4963 /***********************************************************************
4964 Buffer-text Allocation
4965 ***********************************************************************/
4967 /* Allocate NBYTES bytes for buffer B's text buffer. */
4970 alloc_buffer_text (struct buffer
*b
, ptrdiff_t nbytes
)
4975 #if defined USE_MMAP_FOR_BUFFERS
4976 p
= mmap_alloc ((void **) &b
->text
->beg
, nbytes
);
4977 #elif defined REL_ALLOC
4978 p
= r_alloc ((void **) &b
->text
->beg
, nbytes
);
4980 p
= xmalloc (nbytes
);
4986 memory_full (nbytes
);
4993 /* Enlarge buffer B's text buffer by DELTA bytes. DELTA < 0 means
4997 enlarge_buffer_text (struct buffer
*b
, ptrdiff_t delta
)
5000 ptrdiff_t nbytes
= (BUF_Z_BYTE (b
) - BUF_BEG_BYTE (b
) + BUF_GAP_SIZE (b
) + 1
5003 #if defined USE_MMAP_FOR_BUFFERS
5004 p
= mmap_realloc ((void **) &b
->text
->beg
, nbytes
);
5005 #elif defined REL_ALLOC
5006 p
= r_re_alloc ((void **) &b
->text
->beg
, nbytes
);
5008 p
= xrealloc (b
->text
->beg
, nbytes
);
5014 memory_full (nbytes
);
5017 BUF_BEG_ADDR (b
) = p
;
5022 /* Free buffer B's text buffer. */
5025 free_buffer_text (struct buffer
*b
)
5029 #if defined USE_MMAP_FOR_BUFFERS
5030 mmap_free ((void **) &b
->text
->beg
);
5031 #elif defined REL_ALLOC
5032 r_alloc_free ((void **) &b
->text
->beg
);
5034 xfree (b
->text
->beg
);
5037 BUF_BEG_ADDR (b
) = NULL
;
5043 /***********************************************************************
5045 ***********************************************************************/
5048 init_buffer_once (void)
5052 memset (buffer_permanent_local_flags
, 0, sizeof buffer_permanent_local_flags
);
5054 /* Make sure all markable slots in buffer_defaults
5055 are initialized reasonably, so mark_buffer won't choke. */
5056 reset_buffer (&buffer_defaults
);
5057 eassert (EQ (BVAR (&buffer_defaults
, name
), make_number (0)));
5058 reset_buffer_local_variables (&buffer_defaults
, 1);
5059 eassert (EQ (BVAR (&buffer_local_symbols
, name
), make_number (0)));
5060 reset_buffer (&buffer_local_symbols
);
5061 reset_buffer_local_variables (&buffer_local_symbols
, 1);
5062 /* Prevent GC from getting confused. */
5063 buffer_defaults
.text
= &buffer_defaults
.own_text
;
5064 buffer_local_symbols
.text
= &buffer_local_symbols
.own_text
;
5065 /* No one will share the text with these buffers, but let's play it safe. */
5066 buffer_defaults
.indirections
= 0;
5067 buffer_local_symbols
.indirections
= 0;
5068 /* Likewise no one will display them. */
5069 buffer_defaults
.window_count
= 0;
5070 buffer_local_symbols
.window_count
= 0;
5071 set_buffer_intervals (&buffer_defaults
, NULL
);
5072 set_buffer_intervals (&buffer_local_symbols
, NULL
);
5073 /* This is not strictly necessary, but let's make them initialized. */
5074 bset_name (&buffer_defaults
, build_pure_c_string (" *buffer-defaults*"));
5075 bset_name (&buffer_local_symbols
, build_pure_c_string (" *buffer-local-symbols*"));
5076 BUFFER_PVEC_INIT (&buffer_defaults
);
5077 BUFFER_PVEC_INIT (&buffer_local_symbols
);
5079 /* Set up the default values of various buffer slots. */
5080 /* Must do these before making the first buffer! */
5082 /* real setup is done in bindings.el */
5083 bset_mode_line_format (&buffer_defaults
, build_pure_c_string ("%-"));
5084 bset_header_line_format (&buffer_defaults
, Qnil
);
5085 bset_abbrev_mode (&buffer_defaults
, Qnil
);
5086 bset_overwrite_mode (&buffer_defaults
, Qnil
);
5087 bset_case_fold_search (&buffer_defaults
, Qt
);
5088 bset_auto_fill_function (&buffer_defaults
, Qnil
);
5089 bset_selective_display (&buffer_defaults
, Qnil
);
5090 bset_selective_display_ellipses (&buffer_defaults
, Qt
);
5091 bset_abbrev_table (&buffer_defaults
, Qnil
);
5092 bset_display_table (&buffer_defaults
, Qnil
);
5093 bset_undo_list (&buffer_defaults
, Qnil
);
5094 bset_mark_active (&buffer_defaults
, Qnil
);
5095 bset_file_format (&buffer_defaults
, Qnil
);
5096 bset_auto_save_file_format (&buffer_defaults
, Qt
);
5097 set_buffer_overlays_before (&buffer_defaults
, NULL
);
5098 set_buffer_overlays_after (&buffer_defaults
, NULL
);
5099 buffer_defaults
.overlay_center
= BEG
;
5101 XSETFASTINT (BVAR (&buffer_defaults
, tab_width
), 8);
5102 bset_truncate_lines (&buffer_defaults
, Qnil
);
5103 bset_word_wrap (&buffer_defaults
, Qnil
);
5104 bset_ctl_arrow (&buffer_defaults
, Qt
);
5105 bset_bidi_display_reordering (&buffer_defaults
, Qt
);
5106 bset_bidi_paragraph_direction (&buffer_defaults
, Qnil
);
5107 bset_cursor_type (&buffer_defaults
, Qt
);
5108 bset_extra_line_spacing (&buffer_defaults
, Qnil
);
5109 bset_cursor_in_non_selected_windows (&buffer_defaults
, Qt
);
5111 bset_enable_multibyte_characters (&buffer_defaults
, Qt
);
5112 bset_buffer_file_coding_system (&buffer_defaults
, Qnil
);
5113 XSETFASTINT (BVAR (&buffer_defaults
, fill_column
), 70);
5114 XSETFASTINT (BVAR (&buffer_defaults
, left_margin
), 0);
5115 bset_cache_long_scans (&buffer_defaults
, Qt
);
5116 bset_file_truename (&buffer_defaults
, Qnil
);
5117 XSETFASTINT (BVAR (&buffer_defaults
, display_count
), 0);
5118 XSETFASTINT (BVAR (&buffer_defaults
, left_margin_cols
), 0);
5119 XSETFASTINT (BVAR (&buffer_defaults
, right_margin_cols
), 0);
5120 bset_left_fringe_width (&buffer_defaults
, Qnil
);
5121 bset_right_fringe_width (&buffer_defaults
, Qnil
);
5122 bset_fringes_outside_margins (&buffer_defaults
, Qnil
);
5123 bset_scroll_bar_width (&buffer_defaults
, Qnil
);
5124 bset_scroll_bar_height (&buffer_defaults
, Qnil
);
5125 bset_vertical_scroll_bar_type (&buffer_defaults
, Qt
);
5126 bset_horizontal_scroll_bar_type (&buffer_defaults
, Qt
);
5127 bset_indicate_empty_lines (&buffer_defaults
, Qnil
);
5128 bset_indicate_buffer_boundaries (&buffer_defaults
, Qnil
);
5129 bset_fringe_indicator_alist (&buffer_defaults
, Qnil
);
5130 bset_fringe_cursor_alist (&buffer_defaults
, Qnil
);
5131 bset_scroll_up_aggressively (&buffer_defaults
, Qnil
);
5132 bset_scroll_down_aggressively (&buffer_defaults
, Qnil
);
5133 bset_display_time (&buffer_defaults
, Qnil
);
5135 /* Assign the local-flags to the slots that have default values.
5136 The local flag is a bit that is used in the buffer
5137 to say that it has its own local value for the slot.
5138 The local flag bits are in the local_var_flags slot of the buffer. */
5140 /* Nothing can work if this isn't true */
5141 { verify (sizeof (EMACS_INT
) == word_size
); }
5143 /* 0 means not a lisp var, -1 means always local, else mask */
5144 memset (&buffer_local_flags
, 0, sizeof buffer_local_flags
);
5145 bset_filename (&buffer_local_flags
, make_number (-1));
5146 bset_directory (&buffer_local_flags
, make_number (-1));
5147 bset_backed_up (&buffer_local_flags
, make_number (-1));
5148 bset_save_length (&buffer_local_flags
, make_number (-1));
5149 bset_auto_save_file_name (&buffer_local_flags
, make_number (-1));
5150 bset_read_only (&buffer_local_flags
, make_number (-1));
5151 bset_major_mode (&buffer_local_flags
, make_number (-1));
5152 bset_mode_name (&buffer_local_flags
, make_number (-1));
5153 bset_undo_list (&buffer_local_flags
, make_number (-1));
5154 bset_mark_active (&buffer_local_flags
, make_number (-1));
5155 bset_point_before_scroll (&buffer_local_flags
, make_number (-1));
5156 bset_file_truename (&buffer_local_flags
, make_number (-1));
5157 bset_invisibility_spec (&buffer_local_flags
, make_number (-1));
5158 bset_file_format (&buffer_local_flags
, make_number (-1));
5159 bset_auto_save_file_format (&buffer_local_flags
, make_number (-1));
5160 bset_display_count (&buffer_local_flags
, make_number (-1));
5161 bset_display_time (&buffer_local_flags
, make_number (-1));
5162 bset_enable_multibyte_characters (&buffer_local_flags
, make_number (-1));
5165 XSETFASTINT (BVAR (&buffer_local_flags
, mode_line_format
), idx
); ++idx
;
5166 XSETFASTINT (BVAR (&buffer_local_flags
, abbrev_mode
), idx
); ++idx
;
5167 XSETFASTINT (BVAR (&buffer_local_flags
, overwrite_mode
), idx
); ++idx
;
5168 XSETFASTINT (BVAR (&buffer_local_flags
, case_fold_search
), idx
); ++idx
;
5169 XSETFASTINT (BVAR (&buffer_local_flags
, auto_fill_function
), idx
); ++idx
;
5170 XSETFASTINT (BVAR (&buffer_local_flags
, selective_display
), idx
); ++idx
;
5171 XSETFASTINT (BVAR (&buffer_local_flags
, selective_display_ellipses
), idx
); ++idx
;
5172 XSETFASTINT (BVAR (&buffer_local_flags
, tab_width
), idx
); ++idx
;
5173 XSETFASTINT (BVAR (&buffer_local_flags
, truncate_lines
), idx
); ++idx
;
5174 XSETFASTINT (BVAR (&buffer_local_flags
, word_wrap
), idx
); ++idx
;
5175 XSETFASTINT (BVAR (&buffer_local_flags
, ctl_arrow
), idx
); ++idx
;
5176 XSETFASTINT (BVAR (&buffer_local_flags
, fill_column
), idx
); ++idx
;
5177 XSETFASTINT (BVAR (&buffer_local_flags
, left_margin
), idx
); ++idx
;
5178 XSETFASTINT (BVAR (&buffer_local_flags
, abbrev_table
), idx
); ++idx
;
5179 XSETFASTINT (BVAR (&buffer_local_flags
, display_table
), idx
); ++idx
;
5180 XSETFASTINT (BVAR (&buffer_local_flags
, syntax_table
), idx
); ++idx
;
5181 XSETFASTINT (BVAR (&buffer_local_flags
, cache_long_scans
), idx
); ++idx
;
5182 XSETFASTINT (BVAR (&buffer_local_flags
, category_table
), idx
); ++idx
;
5183 XSETFASTINT (BVAR (&buffer_local_flags
, bidi_display_reordering
), idx
); ++idx
;
5184 XSETFASTINT (BVAR (&buffer_local_flags
, bidi_paragraph_direction
), idx
); ++idx
;
5185 XSETFASTINT (BVAR (&buffer_local_flags
, buffer_file_coding_system
), idx
);
5186 /* Make this one a permanent local. */
5187 buffer_permanent_local_flags
[idx
++] = 1;
5188 XSETFASTINT (BVAR (&buffer_local_flags
, left_margin_cols
), idx
); ++idx
;
5189 XSETFASTINT (BVAR (&buffer_local_flags
, right_margin_cols
), idx
); ++idx
;
5190 XSETFASTINT (BVAR (&buffer_local_flags
, left_fringe_width
), idx
); ++idx
;
5191 XSETFASTINT (BVAR (&buffer_local_flags
, right_fringe_width
), idx
); ++idx
;
5192 XSETFASTINT (BVAR (&buffer_local_flags
, fringes_outside_margins
), idx
); ++idx
;
5193 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_bar_width
), idx
); ++idx
;
5194 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_bar_height
), idx
); ++idx
;
5195 XSETFASTINT (BVAR (&buffer_local_flags
, vertical_scroll_bar_type
), idx
); ++idx
;
5196 XSETFASTINT (BVAR (&buffer_local_flags
, horizontal_scroll_bar_type
), idx
); ++idx
;
5197 XSETFASTINT (BVAR (&buffer_local_flags
, indicate_empty_lines
), idx
); ++idx
;
5198 XSETFASTINT (BVAR (&buffer_local_flags
, indicate_buffer_boundaries
), idx
); ++idx
;
5199 XSETFASTINT (BVAR (&buffer_local_flags
, fringe_indicator_alist
), idx
); ++idx
;
5200 XSETFASTINT (BVAR (&buffer_local_flags
, fringe_cursor_alist
), idx
); ++idx
;
5201 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_up_aggressively
), idx
); ++idx
;
5202 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_down_aggressively
), idx
); ++idx
;
5203 XSETFASTINT (BVAR (&buffer_local_flags
, header_line_format
), idx
); ++idx
;
5204 XSETFASTINT (BVAR (&buffer_local_flags
, cursor_type
), idx
); ++idx
;
5205 XSETFASTINT (BVAR (&buffer_local_flags
, extra_line_spacing
), idx
); ++idx
;
5206 XSETFASTINT (BVAR (&buffer_local_flags
, cursor_in_non_selected_windows
), idx
); ++idx
;
5208 /* Need more room? */
5209 if (idx
>= MAX_PER_BUFFER_VARS
)
5211 last_per_buffer_idx
= idx
;
5213 Vbuffer_alist
= Qnil
;
5217 QSFundamental
= build_pure_c_string ("Fundamental");
5219 Qfundamental_mode
= intern_c_string ("fundamental-mode");
5220 bset_major_mode (&buffer_defaults
, Qfundamental_mode
);
5222 Qmode_class
= intern_c_string ("mode-class");
5224 Qprotected_field
= intern_c_string ("protected-field");
5226 Qpermanent_local
= intern_c_string ("permanent-local");
5228 Qkill_buffer_hook
= intern_c_string ("kill-buffer-hook");
5229 Fput (Qkill_buffer_hook
, Qpermanent_local
, Qt
);
5231 /* super-magic invisible buffer */
5232 Vprin1_to_string_buffer
= Fget_buffer_create (build_pure_c_string (" prin1"));
5233 Vbuffer_alist
= Qnil
;
5235 Fset_buffer (Fget_buffer_create (build_pure_c_string ("*scratch*")));
5237 inhibit_modification_hooks
= 0;
5241 init_buffer (int initialized
)
5248 #ifdef USE_MMAP_FOR_BUFFERS
5254 /* These must be reset in the dumped Emacs, to avoid stale
5255 references to mmap'ed memory from before the dump.
5257 WINDOWSNT doesn't need this because it doesn't track mmap'ed
5258 regions by hand (see w32heap.c, which uses system APIs for
5259 that purpose), and thus doesn't use mmap_regions. */
5260 mmap_regions
= NULL
;
5264 /* The dumped buffers reference addresses of buffer text
5265 recorded by temacs, that cannot be used by the dumped Emacs.
5266 We map new memory for their text here.
5268 Implementation note: the buffers we carry from temacs are:
5269 " prin1", "*scratch*", " *Minibuf-0*", "*Messages*", and
5270 " *code-conversion-work*". They are created by
5271 init_buffer_once and init_window_once (which are not called
5272 in the dumped Emacs), and by the first call to coding.c routines. */
5275 b
->text
->beg
= NULL
;
5276 enlarge_buffer_text (b
, 0);
5283 /* Only buffers with allocated buffer text should be present at
5284 this point in temacs. */
5287 eassert (b
->text
->beg
!= NULL
);
5290 #else /* not USE_MMAP_FOR_BUFFERS */
5291 /* Avoid compiler warnings. */
5293 #endif /* USE_MMAP_FOR_BUFFERS */
5295 Fset_buffer (Fget_buffer_create (build_local_string ("*scratch*")));
5296 if (NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
)))
5297 Fset_buffer_multibyte (Qnil
);
5299 pwd
= get_current_dir_name ();
5302 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5304 /* Maybe this should really use some standard subroutine
5305 whose definition is filename syntax dependent. */
5307 if (!(IS_DIRECTORY_SEP (pwd
[len
- 1])))
5309 /* Grow buffer to add directory separator and '\0'. */
5310 pwd
= realloc (pwd
, len
+ 2);
5312 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5313 pwd
[len
] = DIRECTORY_SEP
;
5314 pwd
[len
+ 1] = '\0';
5318 /* At this moment, we still don't know how to decode the directory
5319 name. So, we keep the bytes in unibyte form so that file I/O
5320 routines correctly get the original bytes. */
5321 bset_directory (current_buffer
, make_unibyte_string (pwd
, len
));
5323 /* Add /: to the front of the name
5324 if it would otherwise be treated as magic. */
5325 temp
= Ffind_file_name_handler (BVAR (current_buffer
, directory
), Qt
);
5327 /* If the default dir is just /, TEMP is non-nil
5328 because of the ange-ftp completion handler.
5329 However, it is not necessary to turn / into /:/.
5330 So avoid doing that. */
5331 && strcmp ("/", SSDATA (BVAR (current_buffer
, directory
))))
5334 concat2 (build_local_string ("/:"), BVAR (current_buffer
, directory
)));
5336 temp
= get_minibuffer (0);
5337 bset_directory (XBUFFER (temp
), BVAR (current_buffer
, directory
));
5342 /* Similar to defvar_lisp but define a variable whose value is the
5343 Lisp_Object stored in the current buffer. LNAME is the Lisp-level
5344 variable name. VNAME is the name of the buffer slot. PREDICATE
5345 is nil for a general Lisp variable. If PREDICATE is non-nil, then
5346 only Lisp values that satisfies the PREDICATE are allowed (except
5347 that nil is allowed too). DOC is a dummy where you write the doc
5348 string as a comment. */
5350 #define DEFVAR_PER_BUFFER(lname, vname, predicate, doc) \
5352 static struct Lisp_Buffer_Objfwd bo_fwd; \
5353 defvar_per_buffer (&bo_fwd, lname, vname, predicate); \
5357 defvar_per_buffer (struct Lisp_Buffer_Objfwd
*bo_fwd
, const char *namestring
,
5358 Lisp_Object
*address
, Lisp_Object predicate
)
5360 struct Lisp_Symbol
*sym
;
5363 sym
= XSYMBOL (intern (namestring
));
5364 offset
= (char *)address
- (char *)current_buffer
;
5366 bo_fwd
->type
= Lisp_Fwd_Buffer_Obj
;
5367 bo_fwd
->offset
= offset
;
5368 bo_fwd
->predicate
= predicate
;
5369 sym
->declared_special
= 1;
5370 sym
->redirect
= SYMBOL_FORWARDED
;
5371 SET_SYMBOL_FWD (sym
, (union Lisp_Fwd
*) bo_fwd
);
5372 XSETSYMBOL (PER_BUFFER_SYMBOL (offset
), sym
);
5374 if (PER_BUFFER_IDX (offset
) == 0)
5375 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
5376 slot of buffer_local_flags. */
5381 /* Initialize the buffer routines. */
5383 syms_of_buffer (void)
5385 staticpro (&last_overlay_modification_hooks
);
5386 last_overlay_modification_hooks
5387 = Fmake_vector (make_number (10), Qnil
);
5389 staticpro (&Qfundamental_mode
);
5390 staticpro (&Qmode_class
);
5391 staticpro (&QSFundamental
);
5392 staticpro (&Vbuffer_alist
);
5393 staticpro (&Qprotected_field
);
5394 staticpro (&Qpermanent_local
);
5395 staticpro (&Qkill_buffer_hook
);
5397 DEFSYM (Qchoice
, "choice");
5398 DEFSYM (Qleft
, "left");
5399 DEFSYM (Qright
, "right");
5400 DEFSYM (Qrange
, "range");
5402 DEFSYM (Qpermanent_local_hook
, "permanent-local-hook");
5403 DEFSYM (Qoverlayp
, "overlayp");
5404 DEFSYM (Qevaporate
, "evaporate");
5405 DEFSYM (Qmodification_hooks
, "modification-hooks");
5406 DEFSYM (Qinsert_in_front_hooks
, "insert-in-front-hooks");
5407 DEFSYM (Qinsert_behind_hooks
, "insert-behind-hooks");
5408 DEFSYM (Qget_file_buffer
, "get-file-buffer");
5409 DEFSYM (Qpriority
, "priority");
5410 DEFSYM (Qbefore_string
, "before-string");
5411 DEFSYM (Qafter_string
, "after-string");
5412 DEFSYM (Qfirst_change_hook
, "first-change-hook");
5413 DEFSYM (Qbefore_change_functions
, "before-change-functions");
5414 DEFSYM (Qafter_change_functions
, "after-change-functions");
5415 DEFSYM (Qkill_buffer_query_functions
, "kill-buffer-query-functions");
5417 DEFSYM (Qvertical_scroll_bar
, "vertical-scroll-bar");
5418 Fput (Qvertical_scroll_bar
, Qchoice
, list4 (Qnil
, Qt
, Qleft
, Qright
));
5419 DEFSYM (Qhorizontal_scroll_bar
, "horizontal-scroll-bar");
5421 DEFSYM (Qfraction
, "fraction");
5422 Fput (Qfraction
, Qrange
, Fcons (make_float (0.0), make_float (1.0)));
5424 DEFSYM (Qoverwrite_mode
, "overwrite-mode");
5425 Fput (Qoverwrite_mode
, Qchoice
,
5426 list3 (Qnil
, intern ("overwrite-mode-textual"),
5427 intern ("overwrite-mode-binary")));
5429 Fput (Qprotected_field
, Qerror_conditions
,
5430 listn (CONSTYPE_PURE
, 2, Qprotected_field
, Qerror
));
5431 Fput (Qprotected_field
, Qerror_message
,
5432 build_pure_c_string ("Attempt to modify a protected field"));
5434 DEFVAR_BUFFER_DEFAULTS ("default-mode-line-format",
5436 doc
: /* Default value of `mode-line-format' for buffers that don't override it.
5437 This is the same as (default-value 'mode-line-format). */);
5439 DEFVAR_BUFFER_DEFAULTS ("default-header-line-format",
5441 doc
: /* Default value of `header-line-format' for buffers that don't override it.
5442 This is the same as (default-value 'header-line-format). */);
5444 DEFVAR_BUFFER_DEFAULTS ("default-cursor-type", cursor_type
,
5445 doc
: /* Default value of `cursor-type' for buffers that don't override it.
5446 This is the same as (default-value 'cursor-type). */);
5448 DEFVAR_BUFFER_DEFAULTS ("default-line-spacing",
5450 doc
: /* Default value of `line-spacing' for buffers that don't override it.
5451 This is the same as (default-value 'line-spacing). */);
5453 DEFVAR_BUFFER_DEFAULTS ("default-cursor-in-non-selected-windows",
5454 cursor_in_non_selected_windows
,
5455 doc
: /* Default value of `cursor-in-non-selected-windows'.
5456 This is the same as (default-value 'cursor-in-non-selected-windows). */);
5458 DEFVAR_BUFFER_DEFAULTS ("default-abbrev-mode",
5460 doc
: /* Default value of `abbrev-mode' for buffers that do not override it.
5461 This is the same as (default-value 'abbrev-mode). */);
5463 DEFVAR_BUFFER_DEFAULTS ("default-ctl-arrow",
5465 doc
: /* Default value of `ctl-arrow' for buffers that do not override it.
5466 This is the same as (default-value 'ctl-arrow). */);
5468 DEFVAR_BUFFER_DEFAULTS ("default-enable-multibyte-characters",
5469 enable_multibyte_characters
,
5470 doc
: /* Default value of `enable-multibyte-characters' for buffers not overriding it.
5471 This is the same as (default-value 'enable-multibyte-characters). */);
5473 DEFVAR_BUFFER_DEFAULTS ("default-buffer-file-coding-system",
5474 buffer_file_coding_system
,
5475 doc
: /* Default value of `buffer-file-coding-system' for buffers not overriding it.
5476 This is the same as (default-value 'buffer-file-coding-system). */);
5478 DEFVAR_BUFFER_DEFAULTS ("default-truncate-lines",
5480 doc
: /* Default value of `truncate-lines' for buffers that do not override it.
5481 This is the same as (default-value 'truncate-lines). */);
5483 DEFVAR_BUFFER_DEFAULTS ("default-fill-column",
5485 doc
: /* Default value of `fill-column' for buffers that do not override it.
5486 This is the same as (default-value 'fill-column). */);
5488 DEFVAR_BUFFER_DEFAULTS ("default-left-margin",
5490 doc
: /* Default value of `left-margin' for buffers that do not override it.
5491 This is the same as (default-value 'left-margin). */);
5493 DEFVAR_BUFFER_DEFAULTS ("default-tab-width",
5495 doc
: /* Default value of `tab-width' for buffers that do not override it.
5496 NOTE: This controls the display width of a TAB character, and not
5497 the size of an indentation step.
5498 This is the same as (default-value 'tab-width). */);
5500 DEFVAR_BUFFER_DEFAULTS ("default-case-fold-search",
5502 doc
: /* Default value of `case-fold-search' for buffers that don't override it.
5503 This is the same as (default-value 'case-fold-search). */);
5505 DEFVAR_BUFFER_DEFAULTS ("default-left-margin-width",
5507 doc
: /* Default value of `left-margin-width' for buffers that don't override it.
5508 This is the same as (default-value 'left-margin-width). */);
5510 DEFVAR_BUFFER_DEFAULTS ("default-right-margin-width",
5512 doc
: /* Default value of `right-margin-width' for buffers that don't override it.
5513 This is the same as (default-value 'right-margin-width). */);
5515 DEFVAR_BUFFER_DEFAULTS ("default-left-fringe-width",
5517 doc
: /* Default value of `left-fringe-width' for buffers that don't override it.
5518 This is the same as (default-value 'left-fringe-width). */);
5520 DEFVAR_BUFFER_DEFAULTS ("default-right-fringe-width",
5522 doc
: /* Default value of `right-fringe-width' for buffers that don't override it.
5523 This is the same as (default-value 'right-fringe-width). */);
5525 DEFVAR_BUFFER_DEFAULTS ("default-fringes-outside-margins",
5526 fringes_outside_margins
,
5527 doc
: /* Default value of `fringes-outside-margins' for buffers that don't override it.
5528 This is the same as (default-value 'fringes-outside-margins). */);
5530 DEFVAR_BUFFER_DEFAULTS ("default-scroll-bar-width",
5532 doc
: /* Default value of `scroll-bar-width' for buffers that don't override it.
5533 This is the same as (default-value 'scroll-bar-width). */);
5535 DEFVAR_BUFFER_DEFAULTS ("default-vertical-scroll-bar",
5536 vertical_scroll_bar_type
,
5537 doc
: /* Default value of `vertical-scroll-bar' for buffers that don't override it.
5538 This is the same as (default-value 'vertical-scroll-bar). */);
5540 DEFVAR_BUFFER_DEFAULTS ("default-indicate-empty-lines",
5541 indicate_empty_lines
,
5542 doc
: /* Default value of `indicate-empty-lines' for buffers that don't override it.
5543 This is the same as (default-value 'indicate-empty-lines). */);
5545 DEFVAR_BUFFER_DEFAULTS ("default-indicate-buffer-boundaries",
5546 indicate_buffer_boundaries
,
5547 doc
: /* Default value of `indicate-buffer-boundaries' for buffers that don't override it.
5548 This is the same as (default-value 'indicate-buffer-boundaries). */);
5550 DEFVAR_BUFFER_DEFAULTS ("default-fringe-indicator-alist",
5551 fringe_indicator_alist
,
5552 doc
: /* Default value of `fringe-indicator-alist' for buffers that don't override it.
5553 This is the same as (default-value 'fringe-indicator-alist'). */);
5555 DEFVAR_BUFFER_DEFAULTS ("default-fringe-cursor-alist",
5556 fringe_cursor_alist
,
5557 doc
: /* Default value of `fringe-cursor-alist' for buffers that don't override it.
5558 This is the same as (default-value 'fringe-cursor-alist'). */);
5560 DEFVAR_BUFFER_DEFAULTS ("default-scroll-up-aggressively",
5561 scroll_up_aggressively
,
5562 doc
: /* Default value of `scroll-up-aggressively'.
5563 This value applies in buffers that don't have their own local values.
5564 This is the same as (default-value 'scroll-up-aggressively). */);
5566 DEFVAR_BUFFER_DEFAULTS ("default-scroll-down-aggressively",
5567 scroll_down_aggressively
,
5568 doc
: /* Default value of `scroll-down-aggressively'.
5569 This value applies in buffers that don't have their own local values.
5570 This is the same as (default-value 'scroll-down-aggressively). */);
5572 DEFVAR_PER_BUFFER ("header-line-format",
5573 &BVAR (current_buffer
, header_line_format
),
5575 doc
: /* Analogous to `mode-line-format', but controls the header line.
5576 The header line appears, optionally, at the top of a window;
5577 the mode line appears at the bottom. */);
5579 DEFVAR_PER_BUFFER ("mode-line-format", &BVAR (current_buffer
, mode_line_format
),
5581 doc
: /* Template for displaying mode line for current buffer.
5583 The value may be nil, a string, a symbol or a list.
5585 A value of nil means don't display a mode line.
5587 For any symbol other than t or nil, the symbol's value is processed as
5588 a mode line construct. As a special exception, if that value is a
5589 string, the string is processed verbatim, without handling any
5590 %-constructs (see below). Also, unless the symbol has a non-nil
5591 `risky-local-variable' property, all properties in any strings, as
5592 well as all :eval and :propertize forms in the value, are ignored.
5594 A list whose car is a string or list is processed by processing each
5595 of the list elements recursively, as separate mode line constructs,
5596 and concatenating the results.
5598 A list of the form `(:eval FORM)' is processed by evaluating FORM and
5599 using the result as a mode line construct. Be careful--FORM should
5600 not load any files, because that can cause an infinite recursion.
5602 A list of the form `(:propertize ELT PROPS...)' is processed by
5603 processing ELT as the mode line construct, and adding the text
5604 properties PROPS to the result.
5606 A list whose car is a symbol is processed by examining the symbol's
5607 value, and, if that value is non-nil, processing the cadr of the list
5608 recursively; and if that value is nil, processing the caddr of the
5611 A list whose car is an integer is processed by processing the cadr of
5612 the list, and padding (if the number is positive) or truncating (if
5613 negative) to the width specified by that number.
5615 A string is printed verbatim in the mode line except for %-constructs:
5616 %b -- print buffer name. %f -- print visited file name.
5617 %F -- print frame name.
5618 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
5619 %& is like %*, but ignore read-only-ness.
5620 % means buffer is read-only and * means it is modified.
5621 For a modified read-only buffer, %* gives % and %+ gives *.
5622 %s -- print process status. %l -- print the current line number.
5623 %c -- print the current column number (this makes editing slower).
5624 To make the column number update correctly in all cases,
5625 `column-number-mode' must be non-nil.
5626 %i -- print the size of the buffer.
5627 %I -- like %i, but use k, M, G, etc., to abbreviate.
5628 %p -- print percent of buffer above top of window, or Top, Bot or All.
5629 %P -- print percent of buffer above bottom of window, perhaps plus Top,
5630 or print Bottom or All.
5631 %n -- print Narrow if appropriate.
5632 %t -- visited file is text or binary (if OS supports this distinction).
5633 %z -- print mnemonics of keyboard, terminal, and buffer coding systems.
5634 %Z -- like %z, but including the end-of-line format.
5635 %e -- print error message about full memory.
5636 %@ -- print @ or hyphen. @ means that default-directory is on a
5638 %[ -- print one [ for each recursive editing level. %] similar.
5639 %% -- print %. %- -- print infinitely many dashes.
5640 Decimal digits after the % specify field width to which to pad. */);
5642 DEFVAR_BUFFER_DEFAULTS ("default-major-mode", major_mode
,
5643 doc
: /* Value of `major-mode' for new buffers. */);
5645 DEFVAR_PER_BUFFER ("major-mode", &BVAR (current_buffer
, major_mode
),
5647 doc
: /* Symbol for current buffer's major mode.
5648 The default value (normally `fundamental-mode') affects new buffers.
5649 A value of nil means to use the current buffer's major mode, provided
5650 it is not marked as "special".
5652 When a mode is used by default, `find-file' switches to it before it
5653 reads the contents into the buffer and before it finishes setting up
5654 the buffer. Thus, the mode and its hooks should not expect certain
5655 variables such as `buffer-read-only' and `buffer-file-coding-system'
5658 DEFVAR_PER_BUFFER ("mode-name", &BVAR (current_buffer
, mode_name
),
5660 doc
: /* Pretty name of current buffer's major mode.
5661 Usually a string, but can use any of the constructs for `mode-line-format',
5663 Format with `format-mode-line' to produce a string value. */);
5665 DEFVAR_PER_BUFFER ("local-abbrev-table", &BVAR (current_buffer
, abbrev_table
), Qnil
,
5666 doc
: /* Local (mode-specific) abbrev table of current buffer. */);
5668 DEFVAR_PER_BUFFER ("abbrev-mode", &BVAR (current_buffer
, abbrev_mode
), Qnil
,
5669 doc
: /* Non-nil if Abbrev mode is enabled.
5670 Use the command `abbrev-mode' to change this variable. */);
5672 DEFVAR_PER_BUFFER ("case-fold-search", &BVAR (current_buffer
, case_fold_search
),
5674 doc
: /* Non-nil if searches and matches should ignore case. */);
5676 DEFVAR_PER_BUFFER ("fill-column", &BVAR (current_buffer
, fill_column
),
5678 doc
: /* Column beyond which automatic line-wrapping should happen.
5679 Interactively, you can set the buffer local value using \\[set-fill-column]. */);
5681 DEFVAR_PER_BUFFER ("left-margin", &BVAR (current_buffer
, left_margin
),
5683 doc
: /* Column for the default `indent-line-function' to indent to.
5684 Linefeed indents to this column in Fundamental mode. */);
5686 DEFVAR_PER_BUFFER ("tab-width", &BVAR (current_buffer
, tab_width
),
5688 doc
: /* Distance between tab stops (for display of tab characters), in columns.
5689 NOTE: This controls the display width of a TAB character, and not
5690 the size of an indentation step.
5691 This should be an integer greater than zero. */);
5693 DEFVAR_PER_BUFFER ("ctl-arrow", &BVAR (current_buffer
, ctl_arrow
), Qnil
,
5694 doc
: /* Non-nil means display control chars with uparrow.
5695 A value of nil means use backslash and octal digits.
5696 This variable does not apply to characters whose display is specified
5697 in the current display table (if there is one). */);
5699 DEFVAR_PER_BUFFER ("enable-multibyte-characters",
5700 &BVAR (current_buffer
, enable_multibyte_characters
),
5702 doc
: /* Non-nil means the buffer contents are regarded as multi-byte characters.
5703 Otherwise they are regarded as unibyte. This affects the display,
5704 file I/O and the behavior of various editing commands.
5706 This variable is buffer-local but you cannot set it directly;
5707 use the function `set-buffer-multibyte' to change a buffer's representation.
5708 See also Info node `(elisp)Text Representations'. */);
5709 XSYMBOL (intern_c_string ("enable-multibyte-characters"))->constant
= 1;
5711 DEFVAR_PER_BUFFER ("buffer-file-coding-system",
5712 &BVAR (current_buffer
, buffer_file_coding_system
), Qnil
,
5713 doc
: /* Coding system to be used for encoding the buffer contents on saving.
5714 This variable applies to saving the buffer, and also to `write-region'
5715 and other functions that use `write-region'.
5716 It does not apply to sending output to subprocesses, however.
5718 If this is nil, the buffer is saved without any code conversion
5719 unless some coding system is specified in `file-coding-system-alist'
5720 for the buffer file.
5722 If the text to be saved cannot be encoded as specified by this variable,
5723 an alternative encoding is selected by `select-safe-coding-system', which see.
5725 The variable `coding-system-for-write', if non-nil, overrides this variable.
5727 This variable is never applied to a way of decoding a file while reading it. */);
5729 DEFVAR_PER_BUFFER ("bidi-display-reordering",
5730 &BVAR (current_buffer
, bidi_display_reordering
), Qnil
,
5731 doc
: /* Non-nil means reorder bidirectional text for display in the visual order. */);
5733 DEFVAR_PER_BUFFER ("bidi-paragraph-direction",
5734 &BVAR (current_buffer
, bidi_paragraph_direction
), Qnil
,
5735 doc
: /* If non-nil, forces directionality of text paragraphs in the buffer.
5737 If this is nil (the default), the direction of each paragraph is
5738 determined by the first strong directional character of its text.
5739 The values of `right-to-left' and `left-to-right' override that.
5740 Any other value is treated as nil.
5742 This variable has no effect unless the buffer's value of
5743 \`bidi-display-reordering' is non-nil. */);
5745 DEFVAR_PER_BUFFER ("truncate-lines", &BVAR (current_buffer
, truncate_lines
), Qnil
,
5746 doc
: /* Non-nil means do not display continuation lines.
5747 Instead, give each line of text just one screen line.
5749 Note that this is overridden by the variable
5750 `truncate-partial-width-windows' if that variable is non-nil
5751 and this buffer is not full-frame width.
5753 Minibuffers set this variable to nil. */);
5755 DEFVAR_PER_BUFFER ("word-wrap", &BVAR (current_buffer
, word_wrap
), Qnil
,
5756 doc
: /* Non-nil means to use word-wrapping for continuation lines.
5757 When word-wrapping is on, continuation lines are wrapped at the space
5758 or tab character nearest to the right window edge.
5759 If nil, continuation lines are wrapped at the right screen edge.
5761 This variable has no effect if long lines are truncated (see
5762 `truncate-lines' and `truncate-partial-width-windows'). If you use
5763 word-wrapping, you might want to reduce the value of
5764 `truncate-partial-width-windows', since wrapping can make text readable
5765 in narrower windows.
5767 Instead of setting this variable directly, most users should use
5768 Visual Line mode . Visual Line mode, when enabled, sets `word-wrap'
5769 to t, and additionally redefines simple editing commands to act on
5770 visual lines rather than logical lines. See the documentation of
5771 `visual-line-mode'. */);
5773 DEFVAR_PER_BUFFER ("default-directory", &BVAR (current_buffer
, directory
),
5775 doc
: /* Name of default directory of current buffer. Should end with slash.
5776 To interactively change the default directory, use command `cd'. */);
5778 DEFVAR_PER_BUFFER ("auto-fill-function", &BVAR (current_buffer
, auto_fill_function
),
5780 doc
: /* Function called (if non-nil) to perform auto-fill.
5781 It is called after self-inserting any character specified in
5782 the `auto-fill-chars' table.
5783 NOTE: This variable is not a hook;
5784 its value may not be a list of functions. */);
5786 DEFVAR_PER_BUFFER ("buffer-file-name", &BVAR (current_buffer
, filename
),
5788 doc
: /* Name of file visited in current buffer, or nil if not visiting a file.
5789 This should be an absolute file name. */);
5791 DEFVAR_PER_BUFFER ("buffer-file-truename", &BVAR (current_buffer
, file_truename
),
5793 doc
: /* Abbreviated truename of file visited in current buffer, or nil if none.
5794 The truename of a file is calculated by `file-truename'
5795 and then abbreviated with `abbreviate-file-name'. */);
5797 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
5798 &BVAR (current_buffer
, auto_save_file_name
),
5800 doc
: /* Name of file for auto-saving current buffer.
5801 If it is nil, that means don't auto-save this buffer. */);
5803 DEFVAR_PER_BUFFER ("buffer-read-only", &BVAR (current_buffer
, read_only
), Qnil
,
5804 doc
: /* Non-nil if this buffer is read-only. */);
5806 DEFVAR_PER_BUFFER ("buffer-backed-up", &BVAR (current_buffer
, backed_up
), Qnil
,
5807 doc
: /* Non-nil if this buffer's file has been backed up.
5808 Backing up is done before the first time the file is saved. */);
5810 DEFVAR_PER_BUFFER ("buffer-saved-size", &BVAR (current_buffer
, save_length
),
5812 doc
: /* Length of current buffer when last read in, saved or auto-saved.
5814 -1 means auto-saving turned off until next real save.
5816 If you set this to -2, that means don't turn off auto-saving in this buffer
5817 if its text size shrinks. If you use `buffer-swap-text' on a buffer,
5818 you probably should set this to -2 in that buffer. */);
5820 DEFVAR_PER_BUFFER ("selective-display", &BVAR (current_buffer
, selective_display
),
5822 doc
: /* Non-nil enables selective display.
5823 An integer N as value means display only lines
5824 that start with less than N columns of space.
5825 A value of t means that the character ^M makes itself and
5826 all the rest of the line invisible; also, when saving the buffer
5827 in a file, save the ^M as a newline. */);
5829 DEFVAR_PER_BUFFER ("selective-display-ellipses",
5830 &BVAR (current_buffer
, selective_display_ellipses
),
5832 doc
: /* Non-nil means display ... on previous line when a line is invisible. */);
5834 DEFVAR_PER_BUFFER ("overwrite-mode", &BVAR (current_buffer
, overwrite_mode
),
5836 doc
: /* Non-nil if self-insertion should replace existing text.
5837 The value should be one of `overwrite-mode-textual',
5838 `overwrite-mode-binary', or nil.
5839 If it is `overwrite-mode-textual', self-insertion still
5840 inserts at the end of a line, and inserts when point is before a tab,
5841 until the tab is filled in.
5842 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too. */);
5844 DEFVAR_PER_BUFFER ("buffer-display-table", &BVAR (current_buffer
, display_table
),
5846 doc
: /* Display table that controls display of the contents of current buffer.
5848 If this variable is nil, the value of `standard-display-table' is used.
5849 Each window can have its own, overriding display table, see
5850 `set-window-display-table' and `window-display-table'.
5852 The display table is a char-table created with `make-display-table'.
5853 A char-table is an array indexed by character codes. Normal array
5854 primitives `aref' and `aset' can be used to access elements of a char-table.
5856 Each of the char-table elements control how to display the corresponding
5857 text character: the element at index C in the table says how to display
5858 the character whose code is C. Each element should be a vector of
5859 characters or nil. The value nil means display the character in the
5860 default fashion; otherwise, the characters from the vector are delivered
5861 to the screen instead of the original character.
5863 For example, (aset buffer-display-table ?X [?Y]) tells Emacs
5864 to display a capital Y instead of each X character.
5866 In addition, a char-table has six extra slots to control the display of:
5868 the end of a truncated screen line (extra-slot 0, a single character);
5869 the end of a continued line (extra-slot 1, a single character);
5870 the escape character used to display character codes in octal
5871 (extra-slot 2, a single character);
5872 the character used as an arrow for control characters (extra-slot 3,
5873 a single character);
5874 the decoration indicating the presence of invisible lines (extra-slot 4,
5875 a vector of characters);
5876 the character used to draw the border between side-by-side windows
5877 (extra-slot 5, a single character).
5879 See also the functions `display-table-slot' and `set-display-table-slot'. */);
5881 DEFVAR_PER_BUFFER ("left-margin-width", &BVAR (current_buffer
, left_margin_cols
),
5883 doc
: /* Width in columns of left marginal area for display of a buffer.
5884 A value of nil means no marginal area.
5886 Setting this variable does not take effect until a new buffer is displayed
5887 in a window. To make the change take effect, call `set-window-buffer'. */);
5889 DEFVAR_PER_BUFFER ("right-margin-width", &BVAR (current_buffer
, right_margin_cols
),
5891 doc
: /* Width in columns of right marginal area for display of a buffer.
5892 A value of nil means no marginal area.
5894 Setting this variable does not take effect until a new buffer is displayed
5895 in a window. To make the change take effect, call `set-window-buffer'. */);
5897 DEFVAR_PER_BUFFER ("left-fringe-width", &BVAR (current_buffer
, left_fringe_width
),
5899 doc
: /* Width of this buffer's left fringe (in pixels).
5900 A value of 0 means no left fringe is shown in this buffer's window.
5901 A value of nil means to use the left fringe width from the window's frame.
5903 Setting this variable does not take effect until a new buffer is displayed
5904 in a window. To make the change take effect, call `set-window-buffer'. */);
5906 DEFVAR_PER_BUFFER ("right-fringe-width", &BVAR (current_buffer
, right_fringe_width
),
5908 doc
: /* Width of this buffer's right fringe (in pixels).
5909 A value of 0 means no right fringe is shown in this buffer's window.
5910 A value of nil means to use the right fringe width from the window's frame.
5912 Setting this variable does not take effect until a new buffer is displayed
5913 in a window. To make the change take effect, call `set-window-buffer'. */);
5915 DEFVAR_PER_BUFFER ("fringes-outside-margins", &BVAR (current_buffer
, fringes_outside_margins
),
5917 doc
: /* Non-nil means to display fringes outside display margins.
5918 A value of nil means to display fringes between margins and buffer text.
5920 Setting this variable does not take effect until a new buffer is displayed
5921 in a window. To make the change take effect, call `set-window-buffer'. */);
5923 DEFVAR_PER_BUFFER ("scroll-bar-width", &BVAR (current_buffer
, scroll_bar_width
),
5925 doc
: /* Width of this buffer's scroll bars in pixels.
5926 A value of nil means to use the scroll bar width from the window's frame. */);
5928 DEFVAR_PER_BUFFER ("scroll-bar-height", &BVAR (current_buffer
, scroll_bar_height
),
5930 doc
: /* Height of this buffer's scroll bars in pixels.
5931 A value of nil means to use the scroll bar height from the window's frame. */);
5933 DEFVAR_PER_BUFFER ("vertical-scroll-bar", &BVAR (current_buffer
, vertical_scroll_bar_type
),
5934 Qvertical_scroll_bar
,
5935 doc
: /* Position of this buffer's vertical scroll bar.
5936 The value takes effect whenever you tell a window to display this buffer;
5937 for instance, with `set-window-buffer' or when `display-buffer' displays it.
5939 A value of `left' or `right' means put the vertical scroll bar at that side
5940 of the window; a value of nil means don't show any vertical scroll bars.
5941 A value of t (the default) means do whatever the window's frame specifies. */);
5943 DEFVAR_PER_BUFFER ("horizontal-scroll-bar", &BVAR (current_buffer
, horizontal_scroll_bar_type
),
5945 doc
: /* Position of this buffer's horizontal scroll bar.
5946 The value takes effect whenever you tell a window to display this buffer;
5947 for instance, with `set-window-buffer' or when `display-buffer' displays it.
5949 A value of `bottom' means put the horizontal scroll bar at the bottom of
5950 the window; a value of nil means don't show any horizontal scroll bars.
5951 A value of t (the default) means do whatever the window's frame
5954 DEFVAR_PER_BUFFER ("indicate-empty-lines",
5955 &BVAR (current_buffer
, indicate_empty_lines
), Qnil
,
5956 doc
: /* Visually indicate empty lines after the buffer end.
5957 If non-nil, a bitmap is displayed in the left fringe of a window on
5958 window-systems. */);
5960 DEFVAR_PER_BUFFER ("indicate-buffer-boundaries",
5961 &BVAR (current_buffer
, indicate_buffer_boundaries
), Qnil
,
5962 doc
: /* Visually indicate buffer boundaries and scrolling.
5963 If non-nil, the first and last line of the buffer are marked in the fringe
5964 of a window on window-systems with angle bitmaps, or if the window can be
5965 scrolled, the top and bottom line of the window are marked with up and down
5968 If value is a symbol `left' or `right', both angle and arrow bitmaps
5969 are displayed in the left or right fringe, resp. Any other value
5970 that doesn't look like an alist means display the angle bitmaps in
5971 the left fringe but no arrows.
5973 You can exercise more precise control by using an alist as the
5974 value. Each alist element (INDICATOR . POSITION) specifies
5975 where to show one of the indicators. INDICATOR is one of `top',
5976 `bottom', `up', `down', or t, which specifies the default position,
5977 and POSITION is one of `left', `right', or nil, meaning do not show
5980 For example, ((top . left) (t . right)) places the top angle bitmap in
5981 left fringe, the bottom angle bitmap in right fringe, and both arrow
5982 bitmaps in right fringe. To show just the angle bitmaps in the left
5983 fringe, but no arrow bitmaps, use ((top . left) (bottom . left)). */);
5985 DEFVAR_PER_BUFFER ("fringe-indicator-alist",
5986 &BVAR (current_buffer
, fringe_indicator_alist
), Qnil
,
5987 doc
: /* Mapping from logical to physical fringe indicator bitmaps.
5988 The value is an alist where each element (INDICATOR . BITMAPS)
5989 specifies the fringe bitmaps used to display a specific logical
5992 INDICATOR specifies the logical indicator type which is one of the
5993 following symbols: `truncation' , `continuation', `overlay-arrow',
5994 `top', `bottom', `top-bottom', `up', `down', empty-line', or `unknown'.
5996 BITMAPS is a list of symbols (LEFT RIGHT [LEFT1 RIGHT1]) which specifies
5997 the actual bitmap shown in the left or right fringe for the logical
5998 indicator. LEFT and RIGHT are the bitmaps shown in the left and/or
5999 right fringe for the specific indicator. The LEFT1 or RIGHT1 bitmaps
6000 are used only for the `bottom' and `top-bottom' indicators when the
6001 last (only) line has no final newline. BITMAPS may also be a single
6002 symbol which is used in both left and right fringes. */);
6004 DEFVAR_PER_BUFFER ("fringe-cursor-alist",
6005 &BVAR (current_buffer
, fringe_cursor_alist
), Qnil
,
6006 doc
: /* Mapping from logical to physical fringe cursor bitmaps.
6007 The value is an alist where each element (CURSOR . BITMAP)
6008 specifies the fringe bitmaps used to display a specific logical
6009 cursor type in the fringe.
6011 CURSOR specifies the logical cursor type which is one of the following
6012 symbols: `box' , `hollow', `bar', `hbar', or `hollow-small'. The last
6013 one is used to show a hollow cursor on narrow lines display lines
6014 where the normal hollow cursor will not fit.
6016 BITMAP is the corresponding fringe bitmap shown for the logical
6019 DEFVAR_PER_BUFFER ("scroll-up-aggressively",
6020 &BVAR (current_buffer
, scroll_up_aggressively
), Qfraction
,
6021 doc
: /* How far to scroll windows upward.
6022 If you move point off the bottom, the window scrolls automatically.
6023 This variable controls how far it scrolls. The value nil, the default,
6024 means scroll to center point. A fraction means scroll to put point
6025 that fraction of the window's height from the bottom of the window.
6026 When the value is 0.0, point goes at the bottom line, which in the
6027 simple case that you moved off with C-f means scrolling just one line.
6028 1.0 means point goes at the top, so that in that simple case, the
6029 window scrolls by a full window height. Meaningful values are
6030 between 0.0 and 1.0, inclusive. */);
6032 DEFVAR_PER_BUFFER ("scroll-down-aggressively",
6033 &BVAR (current_buffer
, scroll_down_aggressively
), Qfraction
,
6034 doc
: /* How far to scroll windows downward.
6035 If you move point off the top, the window scrolls automatically.
6036 This variable controls how far it scrolls. The value nil, the default,
6037 means scroll to center point. A fraction means scroll to put point
6038 that fraction of the window's height from the top of the window.
6039 When the value is 0.0, point goes at the top line, which in the
6040 simple case that you moved off with C-b means scrolling just one line.
6041 1.0 means point goes at the bottom, so that in that simple case, the
6042 window scrolls by a full window height. Meaningful values are
6043 between 0.0 and 1.0, inclusive. */);
6045 DEFVAR_LISP ("before-change-functions", Vbefore_change_functions
,
6046 doc
: /* List of functions to call before each text change.
6047 Two arguments are passed to each function: the positions of
6048 the beginning and end of the range of old text to be changed.
6049 \(For an insertion, the beginning and end are at the same place.)
6050 No information is given about the length of the text after the change.
6052 Buffer changes made while executing the `before-change-functions'
6053 don't call any before-change or after-change functions.
6054 That's because `inhibit-modification-hooks' is temporarily set non-nil.
6056 If an unhandled error happens in running these functions,
6057 the variable's value remains nil. That prevents the error
6058 from happening repeatedly and making Emacs nonfunctional. */);
6059 Vbefore_change_functions
= Qnil
;
6061 DEFVAR_LISP ("after-change-functions", Vafter_change_functions
,
6062 doc
: /* List of functions to call after each text change.
6063 Three arguments are passed to each function: the positions of
6064 the beginning and end of the range of changed text,
6065 and the length in bytes of the pre-change text replaced by that range.
6066 \(For an insertion, the pre-change length is zero;
6067 for a deletion, that length is the number of bytes deleted,
6068 and the post-change beginning and end are at the same place.)
6070 Buffer changes made while executing the `after-change-functions'
6071 don't call any before-change or after-change functions.
6072 That's because `inhibit-modification-hooks' is temporarily set non-nil.
6074 If an unhandled error happens in running these functions,
6075 the variable's value remains nil. That prevents the error
6076 from happening repeatedly and making Emacs nonfunctional. */);
6077 Vafter_change_functions
= Qnil
;
6079 DEFVAR_LISP ("first-change-hook", Vfirst_change_hook
,
6080 doc
: /* A list of functions to call before changing a buffer which is unmodified.
6081 The functions are run using the `run-hooks' function. */);
6082 Vfirst_change_hook
= Qnil
;
6084 DEFVAR_PER_BUFFER ("buffer-undo-list", &BVAR (current_buffer
, undo_list
), Qnil
,
6085 doc
: /* List of undo entries in current buffer.
6086 Recent changes come first; older changes follow newer.
6088 An entry (BEG . END) represents an insertion which begins at
6089 position BEG and ends at position END.
6091 An entry (TEXT . POSITION) represents the deletion of the string TEXT
6092 from (abs POSITION). If POSITION is positive, point was at the front
6093 of the text being deleted; if negative, point was at the end.
6095 An entry (t HIGH LOW USEC PSEC) indicates that the buffer was previously
6096 unmodified; (HIGH LOW USEC PSEC) is in the same style as (current-time)
6097 and is the visited file's modification time, as of that time. If the
6098 modification time of the most recent save is different, this entry is
6101 An entry (t . 0) means means the buffer was previously unmodified but
6102 its time stamp was unknown because it was not associated with a file.
6103 An entry (t . -1) is similar, except that it means the buffer's visited
6106 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
6107 was modified between BEG and END. PROPERTY is the property name,
6108 and VALUE is the old value.
6110 An entry (apply FUN-NAME . ARGS) means undo the change with
6111 \(apply FUN-NAME ARGS).
6113 An entry (apply DELTA BEG END FUN-NAME . ARGS) supports selective undo
6114 in the active region. BEG and END is the range affected by this entry
6115 and DELTA is the number of characters added or deleted in that range by
6118 An entry (MARKER . DISTANCE) indicates that the marker MARKER
6119 was adjusted in position by the offset DISTANCE (an integer).
6121 An entry of the form POSITION indicates that point was at the buffer
6122 location given by the integer. Undoing an entry of this form places
6125 Entries with value `nil' mark undo boundaries. The undo command treats
6126 the changes between two undo boundaries as a single step to be undone.
6128 If the value of the variable is t, undo information is not recorded. */);
6130 DEFVAR_PER_BUFFER ("mark-active", &BVAR (current_buffer
, mark_active
), Qnil
,
6131 doc
: /* Non-nil means the mark and region are currently active in this buffer. */);
6133 DEFVAR_PER_BUFFER ("cache-long-scans", &BVAR (current_buffer
, cache_long_scans
), Qnil
,
6134 doc
: /* Non-nil means that Emacs should use caches in attempt to speedup buffer scans.
6136 There is no reason to set this to nil except for debugging purposes.
6138 Normally, the line-motion functions work by scanning the buffer for
6139 newlines. Columnar operations (like `move-to-column' and
6140 `compute-motion') also work by scanning the buffer, summing character
6141 widths as they go. This works well for ordinary text, but if the
6142 buffer's lines are very long (say, more than 500 characters), these
6143 motion functions will take longer to execute. Emacs may also take
6144 longer to update the display.
6146 If `cache-long-scans' is non-nil, these motion functions cache the
6147 results of their scans, and consult the cache to avoid rescanning
6148 regions of the buffer until the text is modified. The caches are most
6149 beneficial when they prevent the most searching---that is, when the
6150 buffer contains long lines and large regions of characters with the
6151 same, fixed screen width.
6153 When `cache-long-scans' is non-nil, processing short lines will
6154 become slightly slower (because of the overhead of consulting the
6155 cache), and the caches will use memory roughly proportional to the
6156 number of newlines and characters whose screen width varies.
6158 Bidirectional editing also requires buffer scans to find paragraph
6159 separators. If you have large paragraphs or no paragraph separators
6160 at all, these scans may be slow. If `cache-long-scans' is non-nil,
6161 results of these scans are cached. This doesn't help too much if
6162 paragraphs are of the reasonable (few thousands of characters) size.
6164 The caches require no explicit maintenance; their accuracy is
6165 maintained internally by the Emacs primitives. Enabling or disabling
6166 the cache should not affect the behavior of any of the motion
6167 functions; it should only affect their performance. */);
6169 DEFVAR_PER_BUFFER ("point-before-scroll", &BVAR (current_buffer
, point_before_scroll
), Qnil
,
6170 doc
: /* Value of point before the last series of scroll operations, or nil. */);
6172 DEFVAR_PER_BUFFER ("buffer-file-format", &BVAR (current_buffer
, file_format
), Qnil
,
6173 doc
: /* List of formats to use when saving this buffer.
6174 Formats are defined by `format-alist'. This variable is
6175 set when a file is visited. */);
6177 DEFVAR_PER_BUFFER ("buffer-auto-save-file-format",
6178 &BVAR (current_buffer
, auto_save_file_format
), Qnil
,
6179 doc
: /* Format in which to write auto-save files.
6180 Should be a list of symbols naming formats that are defined in `format-alist'.
6181 If it is t, which is the default, auto-save files are written in the
6182 same format as a regular save would use. */);
6184 DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
6185 &BVAR (current_buffer
, invisibility_spec
), Qnil
,
6186 doc
: /* Invisibility spec of this buffer.
6187 The default is t, which means that text is invisible if it has a non-nil
6188 `invisible' property.
6189 This variable can also be a list. The list can have two kinds of elements:
6190 `ATOM' and `(ATOM . ELLIPSIS)'. A text character is invisible if its
6191 `invisible' property is `ATOM', or has an `invisible' property that is a list
6192 that contains `ATOM'.
6193 If the `(ATOM . ELLIPSIS)' form is used, and `ELLIPSIS' is non-nil, an
6194 ellipsis will be displayed after the invisible characters.
6195 Setting this variable is very fast, much faster than scanning all the text in
6196 the buffer looking for properties to change. */);
6198 DEFVAR_PER_BUFFER ("buffer-display-count",
6199 &BVAR (current_buffer
, display_count
), Qintegerp
,
6200 doc
: /* A number incremented each time this buffer is displayed in a window.
6201 The function `set-window-buffer' increments it. */);
6203 DEFVAR_PER_BUFFER ("buffer-display-time",
6204 &BVAR (current_buffer
, display_time
), Qnil
,
6205 doc
: /* Time stamp updated each time this buffer is displayed in a window.
6206 The function `set-window-buffer' updates this variable
6207 to the value obtained by calling `current-time'.
6208 If the buffer has never been shown in a window, the value is nil. */);
6210 DEFVAR_LISP ("transient-mark-mode", Vtransient_mark_mode
,
6211 doc
: /* Non-nil if Transient Mark mode is enabled.
6212 See the command `transient-mark-mode' for a description of this minor mode.
6214 Non-nil also enables highlighting of the region whenever the mark is active.
6215 The variable `highlight-nonselected-windows' controls whether to highlight
6216 all windows or just the selected window.
6218 Lisp programs may give this variable certain special values:
6220 - A value of `lambda' enables Transient Mark mode temporarily.
6221 It is disabled again after any subsequent action that would
6222 normally deactivate the mark (e.g. buffer modification).
6224 - A value of (only . OLDVAL) enables Transient Mark mode
6225 temporarily. After any subsequent point motion command that is
6226 not shift-translated, or any other action that would normally
6227 deactivate the mark (e.g. buffer modification), the value of
6228 `transient-mark-mode' is set to OLDVAL. */);
6229 Vtransient_mark_mode
= Qnil
;
6231 DEFVAR_LISP ("inhibit-read-only", Vinhibit_read_only
,
6232 doc
: /* Non-nil means disregard read-only status of buffers or characters.
6233 If the value is t, disregard `buffer-read-only' and all `read-only'
6234 text properties. If the value is a list, disregard `buffer-read-only'
6235 and disregard a `read-only' text property if the property value
6236 is a member of the list. */);
6237 Vinhibit_read_only
= Qnil
;
6239 DEFVAR_PER_BUFFER ("cursor-type", &BVAR (current_buffer
, cursor_type
), Qnil
,
6240 doc
: /* Cursor to use when this buffer is in the selected window.
6241 Values are interpreted as follows:
6243 t use the cursor specified for the frame
6244 nil don't display a cursor
6245 box display a filled box cursor
6246 hollow display a hollow box cursor
6247 bar display a vertical bar cursor with default width
6248 (bar . WIDTH) display a vertical bar cursor with width WIDTH
6249 hbar display a horizontal bar cursor with default height
6250 (hbar . HEIGHT) display a horizontal bar cursor with height HEIGHT
6251 ANYTHING ELSE display a hollow box cursor
6253 When the buffer is displayed in a non-selected window, the
6254 cursor's appearance is instead controlled by the variable
6255 `cursor-in-non-selected-windows'. */);
6257 DEFVAR_PER_BUFFER ("line-spacing",
6258 &BVAR (current_buffer
, extra_line_spacing
), Qnumberp
,
6259 doc
: /* Additional space to put between lines when displaying a buffer.
6260 The space is measured in pixels, and put below lines on graphic displays,
6261 see `display-graphic-p'.
6262 If value is a floating point number, it specifies the spacing relative
6263 to the default frame line height. A value of nil means add no extra space. */);
6265 DEFVAR_PER_BUFFER ("cursor-in-non-selected-windows",
6266 &BVAR (current_buffer
, cursor_in_non_selected_windows
), Qnil
,
6267 doc
: /* Non-nil means show a cursor in non-selected windows.
6268 If nil, only shows a cursor in the selected window.
6269 If t, displays a cursor related to the usual cursor type
6270 \(a solid box becomes hollow, a bar becomes a narrower bar).
6271 You can also specify the cursor type as in the `cursor-type' variable.
6272 Use Custom to set this variable and update the display." */);
6274 DEFVAR_LISP ("kill-buffer-query-functions", Vkill_buffer_query_functions
,
6275 doc
: /* List of functions called with no args to query before killing a buffer.
6276 The buffer being killed will be current while the functions are running.
6278 If any of them returns nil, the buffer is not killed. Functions run by
6279 this hook are supposed to not change the current buffer. */);
6280 Vkill_buffer_query_functions
= Qnil
;
6282 DEFVAR_LISP ("change-major-mode-hook", Vchange_major_mode_hook
,
6283 doc
: /* Normal hook run before changing the major mode of a buffer.
6284 The function `kill-all-local-variables' runs this before doing anything else. */);
6285 Vchange_major_mode_hook
= Qnil
;
6286 DEFSYM (Qchange_major_mode_hook
, "change-major-mode-hook");
6288 DEFVAR_LISP ("buffer-list-update-hook", Vbuffer_list_update_hook
,
6289 doc
: /* Hook run when the buffer list changes.
6290 Functions running this hook are, `get-buffer-create',
6291 `make-indirect-buffer', `rename-buffer', `kill-buffer',
6292 `bury-buffer-internal' and `select-window'. */);
6293 Vbuffer_list_update_hook
= Qnil
;
6294 DEFSYM (Qbuffer_list_update_hook
, "buffer-list-update-hook");
6296 defsubr (&Sbuffer_live_p
);
6297 defsubr (&Sbuffer_list
);
6298 defsubr (&Sget_buffer
);
6299 defsubr (&Sget_file_buffer
);
6300 defsubr (&Sget_buffer_create
);
6301 defsubr (&Smake_indirect_buffer
);
6302 defsubr (&Sgenerate_new_buffer_name
);
6303 defsubr (&Sbuffer_name
);
6304 defsubr (&Sbuffer_file_name
);
6305 defsubr (&Sbuffer_base_buffer
);
6306 defsubr (&Sbuffer_local_value
);
6307 defsubr (&Sbuffer_local_variables
);
6308 defsubr (&Sbuffer_modified_p
);
6309 defsubr (&Sforce_mode_line_update
);
6310 defsubr (&Sset_buffer_modified_p
);
6311 defsubr (&Sbuffer_modified_tick
);
6312 defsubr (&Sbuffer_chars_modified_tick
);
6313 defsubr (&Srename_buffer
);
6314 defsubr (&Sother_buffer
);
6315 defsubr (&Sbuffer_enable_undo
);
6316 defsubr (&Skill_buffer
);
6317 defsubr (&Sbury_buffer_internal
);
6318 defsubr (&Sset_buffer_major_mode
);
6319 defsubr (&Scurrent_buffer
);
6320 defsubr (&Sset_buffer
);
6321 defsubr (&Sbarf_if_buffer_read_only
);
6322 defsubr (&Serase_buffer
);
6323 defsubr (&Sbuffer_swap_text
);
6324 defsubr (&Sset_buffer_multibyte
);
6325 defsubr (&Skill_all_local_variables
);
6327 defsubr (&Soverlayp
);
6328 defsubr (&Smake_overlay
);
6329 defsubr (&Sdelete_overlay
);
6330 defsubr (&Sdelete_all_overlays
);
6331 defsubr (&Smove_overlay
);
6332 defsubr (&Soverlay_start
);
6333 defsubr (&Soverlay_end
);
6334 defsubr (&Soverlay_buffer
);
6335 defsubr (&Soverlay_properties
);
6336 defsubr (&Soverlays_at
);
6337 defsubr (&Soverlays_in
);
6338 defsubr (&Snext_overlay_change
);
6339 defsubr (&Sprevious_overlay_change
);
6340 defsubr (&Soverlay_recenter
);
6341 defsubr (&Soverlay_lists
);
6342 defsubr (&Soverlay_get
);
6343 defsubr (&Soverlay_put
);
6344 defsubr (&Srestore_buffer_modified_p
);
6348 keys_of_buffer (void)
6350 initial_define_key (control_x_map
, 'b', "switch-to-buffer");
6351 initial_define_key (control_x_map
, 'k', "kill-buffer");
6353 /* This must not be in syms_of_buffer, because Qdisabled is not
6354 initialized when that function gets called. */
6355 Fput (intern_c_string ("erase-buffer"), Qdisabled
, Qt
);