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
)
1138 return BVAR (current_buffer
, name
);
1139 CHECK_BUFFER (buffer
);
1140 return BVAR (XBUFFER (buffer
), name
);
1143 DEFUN ("buffer-file-name", Fbuffer_file_name
, Sbuffer_file_name
, 0, 1, 0,
1144 doc
: /* Return name of file BUFFER is visiting, or nil if none.
1145 No argument or nil as argument means use the current buffer. */)
1146 (register Lisp_Object buffer
)
1149 return BVAR (current_buffer
, filename
);
1150 CHECK_BUFFER (buffer
);
1151 return BVAR (XBUFFER (buffer
), filename
);
1154 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer
, Sbuffer_base_buffer
,
1156 doc
: /* Return the base buffer of indirect buffer BUFFER.
1157 If BUFFER is not indirect, return nil.
1158 BUFFER defaults to the current buffer. */)
1159 (register Lisp_Object buffer
)
1161 struct buffer
*base
;
1162 Lisp_Object base_buffer
;
1165 base
= current_buffer
->base_buffer
;
1168 CHECK_BUFFER (buffer
);
1169 base
= XBUFFER (buffer
)->base_buffer
;
1174 XSETBUFFER (base_buffer
, base
);
1178 DEFUN ("buffer-local-value", Fbuffer_local_value
,
1179 Sbuffer_local_value
, 2, 2, 0,
1180 doc
: /* Return the value of VARIABLE in BUFFER.
1181 If VARIABLE does not have a buffer-local binding in BUFFER, the value
1182 is the default binding of the variable. */)
1183 (register Lisp_Object variable
, register Lisp_Object buffer
)
1185 register Lisp_Object result
= buffer_local_value (variable
, buffer
);
1187 if (EQ (result
, Qunbound
))
1188 xsignal1 (Qvoid_variable
, variable
);
1194 /* Like Fbuffer_local_value, but return Qunbound if the variable is
1198 buffer_local_value (Lisp_Object variable
, Lisp_Object buffer
)
1200 register struct buffer
*buf
;
1201 register Lisp_Object result
;
1202 struct Lisp_Symbol
*sym
;
1204 CHECK_SYMBOL (variable
);
1205 CHECK_BUFFER (buffer
);
1206 buf
= XBUFFER (buffer
);
1207 sym
= XSYMBOL (variable
);
1210 switch (sym
->redirect
)
1212 case SYMBOL_VARALIAS
: sym
= indirect_variable (sym
); goto start
;
1213 case SYMBOL_PLAINVAL
: result
= SYMBOL_VAL (sym
); break;
1214 case SYMBOL_LOCALIZED
:
1215 { /* Look in local_var_alist. */
1216 struct Lisp_Buffer_Local_Value
*blv
= SYMBOL_BLV (sym
);
1217 XSETSYMBOL (variable
, sym
); /* Update In case of aliasing. */
1218 result
= Fassoc (variable
, BVAR (buf
, local_var_alist
));
1222 { /* What binding is loaded right now? */
1223 Lisp_Object current_alist_element
= blv
->valcell
;
1225 /* The value of the currently loaded binding is not
1226 stored in it, but rather in the realvalue slot.
1227 Store that value into the binding it belongs to
1228 in case that is the one we are about to use. */
1230 XSETCDR (current_alist_element
,
1231 do_symval_forwarding (blv
->fwd
));
1233 /* Now get the (perhaps updated) value out of the binding. */
1234 result
= XCDR (result
);
1237 result
= Fdefault_value (variable
);
1240 case SYMBOL_FORWARDED
:
1242 union Lisp_Fwd
*fwd
= SYMBOL_FWD (sym
);
1243 if (BUFFER_OBJFWDP (fwd
))
1244 result
= per_buffer_value (buf
, XBUFFER_OBJFWD (fwd
)->offset
);
1246 result
= Fdefault_value (variable
);
1249 default: emacs_abort ();
1255 /* Return an alist of the Lisp-level buffer-local bindings of
1256 buffer BUF. That is, don't include the variables maintained
1257 in special slots in the buffer object.
1258 If not CLONE, replace elements of the form (VAR . unbound)
1262 buffer_lisp_local_variables (struct buffer
*buf
, bool clone
)
1264 Lisp_Object result
= Qnil
;
1266 for (tail
= BVAR (buf
, local_var_alist
); CONSP (tail
); tail
= XCDR (tail
))
1268 Lisp_Object val
, elt
;
1272 /* Reference each variable in the alist in buf.
1273 If inquiring about the current buffer, this gets the current values,
1274 so store them into the alist so the alist is up to date.
1275 If inquiring about some other buffer, this swaps out any values
1276 for that buffer, making the alist up to date automatically. */
1277 val
= find_symbol_value (XCAR (elt
));
1278 /* Use the current buffer value only if buf is the current buffer. */
1279 if (buf
!= current_buffer
)
1282 result
= Fcons (!clone
&& EQ (val
, Qunbound
)
1284 : Fcons (XCAR (elt
), val
),
1291 DEFUN ("buffer-local-variables", Fbuffer_local_variables
,
1292 Sbuffer_local_variables
, 0, 1, 0,
1293 doc
: /* Return an alist of variables that are buffer-local in BUFFER.
1294 Most elements look like (SYMBOL . VALUE), describing one variable.
1295 For a symbol that is locally unbound, just the symbol appears in the value.
1296 Note that storing new VALUEs in these elements doesn't change the variables.
1297 No argument or nil as argument means use current buffer as BUFFER. */)
1298 (register Lisp_Object buffer
)
1300 register struct buffer
*buf
;
1301 register Lisp_Object result
;
1304 buf
= current_buffer
;
1307 CHECK_BUFFER (buffer
);
1308 buf
= XBUFFER (buffer
);
1311 result
= buffer_lisp_local_variables (buf
, 0);
1313 /* Add on all the variables stored in special slots. */
1317 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
1319 idx
= PER_BUFFER_IDX (offset
);
1320 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
1321 && SYMBOLP (PER_BUFFER_SYMBOL (offset
)))
1323 Lisp_Object sym
= PER_BUFFER_SYMBOL (offset
);
1324 Lisp_Object val
= per_buffer_value (buf
, offset
);
1325 result
= Fcons (EQ (val
, Qunbound
) ? sym
: Fcons (sym
, val
),
1334 DEFUN ("buffer-modified-p", Fbuffer_modified_p
, Sbuffer_modified_p
,
1336 doc
: /* Return t if BUFFER was modified since its file was last read or saved.
1337 No argument or nil as argument means use current buffer as BUFFER. */)
1338 (register Lisp_Object buffer
)
1340 register struct buffer
*buf
;
1342 buf
= current_buffer
;
1345 CHECK_BUFFER (buffer
);
1346 buf
= XBUFFER (buffer
);
1349 return BUF_SAVE_MODIFF (buf
) < BUF_MODIFF (buf
) ? Qt
: Qnil
;
1352 DEFUN ("force-mode-line-update", Fforce_mode_line_update
,
1353 Sforce_mode_line_update
, 0, 1, 0,
1354 doc
: /* Force redisplay of the current buffer's mode line and header line.
1355 With optional non-nil ALL, force redisplay of all mode lines and
1356 header lines. This function also forces recomputation of the
1357 menu bar menus and the frame title. */)
1362 update_mode_lines
= 10;
1363 /* FIXME: This can't be right. */
1364 current_buffer
->prevent_redisplay_optimizations_p
= true;
1366 else if (buffer_window_count (current_buffer
))
1368 bset_update_mode_line (current_buffer
);
1369 current_buffer
->prevent_redisplay_optimizations_p
= true;
1374 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p
, Sset_buffer_modified_p
,
1376 doc
: /* Mark current buffer as modified or unmodified according to FLAG.
1377 A non-nil FLAG means mark the buffer modified. */)
1380 Frestore_buffer_modified_p (flag
);
1382 /* Set update_mode_lines only if buffer is displayed in some window.
1383 Packages like jit-lock or lazy-lock preserve a buffer's modified
1384 state by recording/restoring the state around blocks of code.
1385 Setting update_mode_lines makes redisplay consider all windows
1386 (on all frames). Stealth fontification of buffers not displayed
1387 would incur additional redisplay costs if we'd set
1388 update_modes_lines unconditionally.
1390 Ideally, I think there should be another mechanism for fontifying
1391 buffers without "modifying" buffers, or redisplay should be
1392 smarter about updating the `*' in mode lines. --gerd */
1393 return Fforce_mode_line_update (Qnil
);
1396 DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p
,
1397 Srestore_buffer_modified_p
, 1, 1, 0,
1398 doc
: /* Like `set-buffer-modified-p', with a difference concerning redisplay.
1399 It is not ensured that mode lines will be updated to show the modified
1400 state of the current buffer. Use with care. */)
1405 /* If buffer becoming modified, lock the file.
1406 If buffer becoming unmodified, unlock the file. */
1408 struct buffer
*b
= current_buffer
->base_buffer
1409 ? current_buffer
->base_buffer
1412 fn
= BVAR (b
, file_truename
);
1413 /* Test buffer-file-name so that binding it to nil is effective. */
1414 if (!NILP (fn
) && ! NILP (BVAR (b
, filename
)))
1416 bool already
= SAVE_MODIFF
< MODIFF
;
1417 if (!already
&& !NILP (flag
))
1419 else if (already
&& NILP (flag
))
1423 /* Here we have a problem. SAVE_MODIFF is used here to encode
1424 buffer-modified-p (as SAVE_MODIFF<MODIFF) as well as
1425 recent-auto-save-p (as SAVE_MODIFF<auto_save_modified). So if we
1426 modify SAVE_MODIFF to affect one, we may affect the other
1428 E.g. if FLAG is nil we need to set SAVE_MODIFF to MODIFF, but
1429 if SAVE_MODIFF<auto_save_modified that means we risk changing
1430 recent-auto-save-p from t to nil.
1431 Vice versa, if FLAG is non-nil and SAVE_MODIFF>=auto_save_modified
1432 we risk changing recent-auto-save-p from nil to t. */
1433 SAVE_MODIFF
= (NILP (flag
)
1434 /* FIXME: This unavoidably sets recent-auto-save-p to nil. */
1436 /* Let's try to preserve recent-auto-save-p. */
1437 : SAVE_MODIFF
< MODIFF
? SAVE_MODIFF
1438 /* If SAVE_MODIFF == auto_save_modified == MODIFF,
1439 we can either decrease SAVE_MODIFF and auto_save_modified
1440 or increase MODIFF. */
1446 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick
, Sbuffer_modified_tick
,
1448 doc
: /* Return BUFFER's tick counter, incremented for each change in text.
1449 Each buffer has a tick counter which is incremented each time the
1450 text in that buffer is changed. It wraps around occasionally.
1451 No argument or nil as argument means use current buffer as BUFFER. */)
1452 (register Lisp_Object buffer
)
1454 register struct buffer
*buf
;
1456 buf
= current_buffer
;
1459 CHECK_BUFFER (buffer
);
1460 buf
= XBUFFER (buffer
);
1463 return make_number (BUF_MODIFF (buf
));
1466 DEFUN ("buffer-chars-modified-tick", Fbuffer_chars_modified_tick
,
1467 Sbuffer_chars_modified_tick
, 0, 1, 0,
1468 doc
: /* Return BUFFER's character-change tick counter.
1469 Each buffer has a character-change tick counter, which is set to the
1470 value of the buffer's tick counter \(see `buffer-modified-tick'), each
1471 time text in that buffer is inserted or deleted. By comparing the
1472 values returned by two individual calls of `buffer-chars-modified-tick',
1473 you can tell whether a character change occurred in that buffer in
1474 between these calls. No argument or nil as argument means use current
1475 buffer as BUFFER. */)
1476 (register Lisp_Object buffer
)
1478 register struct buffer
*buf
;
1480 buf
= current_buffer
;
1483 CHECK_BUFFER (buffer
);
1484 buf
= XBUFFER (buffer
);
1487 return make_number (BUF_CHARS_MODIFF (buf
));
1490 DEFUN ("rename-buffer", Frename_buffer
, Srename_buffer
, 1, 2,
1491 "(list (read-string \"Rename buffer (to new name): \" \
1492 nil 'buffer-name-history (buffer-name (current-buffer))) \
1493 current-prefix-arg)",
1494 doc
: /* Change current buffer's name to NEWNAME (a string).
1495 If second arg UNIQUE is nil or omitted, it is an error if a
1496 buffer named NEWNAME already exists.
1497 If UNIQUE is non-nil, come up with a new name using
1498 `generate-new-buffer-name'.
1499 Interactively, you can set UNIQUE with a prefix argument.
1500 We return the name we actually gave the buffer.
1501 This does not change the name of the visited file (if any). */)
1502 (register Lisp_Object newname
, Lisp_Object unique
)
1504 register Lisp_Object tem
, buf
;
1506 CHECK_STRING (newname
);
1508 if (SCHARS (newname
) == 0)
1509 error ("Empty string is invalid as a buffer name");
1511 tem
= Fget_buffer (newname
);
1514 /* Don't short-circuit if UNIQUE is t. That is a useful way to
1515 rename the buffer automatically so you can create another
1516 with the original name. It makes UNIQUE equivalent to
1517 (rename-buffer (generate-new-buffer-name NEWNAME)). */
1518 if (NILP (unique
) && XBUFFER (tem
) == current_buffer
)
1519 return BVAR (current_buffer
, name
);
1521 newname
= Fgenerate_new_buffer_name (newname
, BVAR (current_buffer
, name
));
1523 error ("Buffer name `%s' is in use", SDATA (newname
));
1526 bset_name (current_buffer
, newname
);
1528 /* Catch redisplay's attention. Unless we do this, the mode lines for
1529 any windows displaying current_buffer will stay unchanged. */
1530 update_mode_lines
= 11;
1532 XSETBUFFER (buf
, current_buffer
);
1533 Fsetcar (Frassq (buf
, Vbuffer_alist
), newname
);
1534 if (NILP (BVAR (current_buffer
, filename
))
1535 && !NILP (BVAR (current_buffer
, auto_save_file_name
)))
1536 call0 (intern ("rename-auto-save-file"));
1538 /* Run buffer-list-update-hook. */
1539 if (!NILP (Vrun_hooks
))
1540 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1542 /* Refetch since that last call may have done GC. */
1543 return BVAR (current_buffer
, name
);
1546 /* True if B can be used as 'other-than-BUFFER' buffer. */
1549 candidate_buffer (Lisp_Object b
, Lisp_Object buffer
)
1551 return (BUFFERP (b
) && !EQ (b
, buffer
)
1552 && BUFFER_LIVE_P (XBUFFER (b
))
1553 && !BUFFER_HIDDEN_P (XBUFFER (b
)));
1556 DEFUN ("other-buffer", Fother_buffer
, Sother_buffer
, 0, 3, 0,
1557 doc
: /* Return most recently selected buffer other than BUFFER.
1558 Buffers not visible in windows are preferred to visible buffers, unless
1559 optional second argument VISIBLE-OK is non-nil. Ignore the argument
1560 BUFFER unless it denotes a live buffer. If the optional third argument
1561 FRAME is non-nil, use that frame's buffer list instead of the selected
1562 frame's buffer list.
1564 The buffer is found by scanning the selected or specified frame's buffer
1565 list first, followed by the list of all buffers. If no other buffer
1566 exists, return the buffer `*scratch*' (creating it if necessary). */)
1567 (register Lisp_Object buffer
, Lisp_Object visible_ok
, Lisp_Object frame
)
1569 struct frame
*f
= decode_any_frame (frame
);
1570 Lisp_Object tail
= f
->buffer_list
, pred
= f
->buffer_predicate
;
1571 Lisp_Object buf
, notsogood
= Qnil
;
1573 /* Consider buffers that have been seen in the frame first. */
1574 for (; CONSP (tail
); tail
= XCDR (tail
))
1577 if (candidate_buffer (buf
, buffer
)
1578 /* If the frame has a buffer_predicate, disregard buffers that
1579 don't fit the predicate. */
1580 && (NILP (pred
) || !NILP (call1 (pred
, buf
))))
1582 if (!NILP (visible_ok
)
1583 || NILP (Fget_buffer_window (buf
, Qvisible
)))
1585 else if (NILP (notsogood
))
1590 /* Consider alist of all buffers next. */
1591 FOR_EACH_LIVE_BUFFER (tail
, buf
)
1593 if (candidate_buffer (buf
, buffer
)
1594 /* If the frame has a buffer_predicate, disregard buffers that
1595 don't fit the predicate. */
1596 && (NILP (pred
) || !NILP (call1 (pred
, buf
))))
1598 if (!NILP (visible_ok
)
1599 || NILP (Fget_buffer_window (buf
, Qvisible
)))
1601 else if (NILP (notsogood
))
1606 if (!NILP (notsogood
))
1610 buf
= Fget_buffer (build_string ("*scratch*"));
1613 buf
= Fget_buffer_create (build_string ("*scratch*"));
1614 Fset_buffer_major_mode (buf
);
1620 /* The following function is a safe variant of Fother_buffer: It doesn't
1621 pay attention to any frame-local buffer lists, doesn't care about
1622 visibility of buffers, and doesn't evaluate any frame predicates. */
1625 other_buffer_safely (Lisp_Object buffer
)
1627 Lisp_Object tail
, buf
;
1629 FOR_EACH_LIVE_BUFFER (tail
, buf
)
1630 if (candidate_buffer (buf
, buffer
))
1633 buf
= Fget_buffer (build_string ("*scratch*"));
1636 buf
= Fget_buffer_create (build_string ("*scratch*"));
1637 Fset_buffer_major_mode (buf
);
1643 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo
, Sbuffer_enable_undo
,
1645 doc
: /* Start keeping undo information for buffer BUFFER.
1646 No argument or nil as argument means do this for the current buffer. */)
1647 (register Lisp_Object buffer
)
1649 Lisp_Object real_buffer
;
1652 XSETBUFFER (real_buffer
, current_buffer
);
1655 real_buffer
= Fget_buffer (buffer
);
1656 if (NILP (real_buffer
))
1660 if (EQ (BVAR (XBUFFER (real_buffer
), undo_list
), Qt
))
1661 bset_undo_list (XBUFFER (real_buffer
), Qnil
);
1666 /* Truncate undo list and shrink the gap of BUFFER. */
1669 compact_buffer (struct buffer
*buffer
)
1671 BUFFER_CHECK_INDIRECTION (buffer
);
1673 /* Skip dead buffers, indirect buffers and buffers
1674 which aren't changed since last compaction. */
1675 if (BUFFER_LIVE_P (buffer
)
1676 && (buffer
->base_buffer
== NULL
)
1677 && (BUF_COMPACT (buffer
) != BUF_MODIFF (buffer
)))
1679 /* If a buffer's undo list is Qt, that means that undo is
1680 turned off in that buffer. Calling truncate_undo_list on
1681 Qt tends to return NULL, which effectively turns undo back on.
1682 So don't call truncate_undo_list if undo_list is Qt. */
1683 if (!EQ (buffer
->INTERNAL_FIELD (undo_list
), Qt
))
1684 truncate_undo_list (buffer
);
1686 /* Shrink buffer gaps. */
1687 if (!buffer
->text
->inhibit_shrinking
)
1689 /* If a buffer's gap size is more than 10% of the buffer
1690 size, or larger than GAP_BYTES_DFL bytes, then shrink it
1691 accordingly. Keep a minimum size of GAP_BYTES_MIN bytes. */
1692 ptrdiff_t size
= clip_to_bounds (GAP_BYTES_MIN
,
1693 BUF_Z_BYTE (buffer
) / 10,
1695 if (BUF_GAP_SIZE (buffer
) > size
)
1696 make_gap_1 (buffer
, -(BUF_GAP_SIZE (buffer
) - size
));
1698 BUF_COMPACT (buffer
) = BUF_MODIFF (buffer
);
1702 DEFUN ("kill-buffer", Fkill_buffer
, Skill_buffer
, 0, 1, "bKill buffer: ",
1703 doc
: /* Kill the buffer specified by BUFFER-OR-NAME.
1704 The argument may be a buffer or the name of an existing buffer.
1705 Argument nil or omitted means kill the current buffer. Return t if the
1706 buffer is actually killed, nil otherwise.
1708 The functions in `kill-buffer-query-functions' are called with the
1709 buffer to be killed as the current buffer. If any of them returns nil,
1710 the buffer is not killed. The hook `kill-buffer-hook' is run before the
1711 buffer is actually killed. The buffer being killed will be current
1712 while the hook is running. Functions called by any of these hooks are
1713 supposed to not change the current buffer.
1715 Any processes that have this buffer as the `process-buffer' are killed
1716 with SIGHUP. This function calls `replace-buffer-in-windows' for
1717 cleaning up all windows currently displaying the buffer to be killed. */)
1718 (Lisp_Object buffer_or_name
)
1721 register struct buffer
*b
;
1722 register Lisp_Object tem
;
1723 register struct Lisp_Marker
*m
;
1724 struct gcpro gcpro1
;
1726 if (NILP (buffer_or_name
))
1727 buffer
= Fcurrent_buffer ();
1729 buffer
= Fget_buffer (buffer_or_name
);
1731 nsberror (buffer_or_name
);
1733 b
= XBUFFER (buffer
);
1735 /* Avoid trouble for buffer already dead. */
1736 if (!BUFFER_LIVE_P (b
))
1739 /* Run hooks with the buffer to be killed the current buffer. */
1741 ptrdiff_t count
= SPECPDL_INDEX ();
1742 Lisp_Object arglist
[1];
1744 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1745 set_buffer_internal (b
);
1747 /* First run the query functions; if any query is answered no,
1748 don't kill the buffer. */
1749 arglist
[0] = Qkill_buffer_query_functions
;
1750 tem
= Frun_hook_with_args_until_failure (1, arglist
);
1752 return unbind_to (count
, Qnil
);
1754 /* Query if the buffer is still modified. */
1755 if (INTERACTIVE
&& !NILP (BVAR (b
, filename
))
1756 && BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
1759 tem
= do_yes_or_no_p (format2 ("Buffer %s modified; kill anyway? ",
1760 BVAR (b
, name
), make_number (0)));
1763 return unbind_to (count
, Qnil
);
1766 /* If the hooks have killed the buffer, exit now. */
1767 if (!BUFFER_LIVE_P (b
))
1768 return unbind_to (count
, Qt
);
1770 /* Then run the hooks. */
1771 Frun_hooks (1, &Qkill_buffer_hook
);
1772 unbind_to (count
, Qnil
);
1775 /* If the hooks have killed the buffer, exit now. */
1776 if (!BUFFER_LIVE_P (b
))
1779 /* We have no more questions to ask. Verify that it is valid
1780 to kill the buffer. This must be done after the questions
1781 since anything can happen within do_yes_or_no_p. */
1783 /* Don't kill the minibuffer now current. */
1784 if (EQ (buffer
, XWINDOW (minibuf_window
)->contents
))
1787 /* When we kill an ordinary buffer which shares it's buffer text
1788 with indirect buffer(s), we must kill indirect buffer(s) too.
1789 We do it at this stage so nothing terrible happens if they
1790 ask questions or their hooks get errors. */
1791 if (!b
->base_buffer
&& b
->indirections
> 0)
1793 struct buffer
*other
;
1797 FOR_EACH_BUFFER (other
)
1798 if (other
->base_buffer
== b
)
1801 XSETBUFFER (buf
, other
);
1807 /* Exit if we now have killed the base buffer (Bug#11665). */
1808 if (!BUFFER_LIVE_P (b
))
1812 /* Run replace_buffer_in_windows before making another buffer current
1813 since set-window-buffer-start-and-point will refuse to make another
1814 buffer current if the selected window does not show the current
1815 buffer (bug#10114). */
1816 replace_buffer_in_windows (buffer
);
1818 /* Exit if replacing the buffer in windows has killed our buffer. */
1819 if (!BUFFER_LIVE_P (b
))
1822 /* Make this buffer not be current. Exit if it is the sole visible
1824 if (b
== current_buffer
)
1826 tem
= Fother_buffer (buffer
, Qnil
, Qnil
);
1828 if (b
== current_buffer
)
1832 /* If the buffer now current is shown in the minibuffer and our buffer
1833 is the sole other buffer give up. */
1834 XSETBUFFER (tem
, current_buffer
);
1835 if (EQ (tem
, XWINDOW (minibuf_window
)->contents
)
1836 && EQ (buffer
, Fother_buffer (buffer
, Qnil
, Qnil
)))
1839 /* Now there is no question: we can kill the buffer. */
1841 /* Unlock this buffer's file, if it is locked. */
1845 kill_buffer_processes (buffer
);
1848 /* Killing buffer processes may run sentinels which may have killed
1850 if (!BUFFER_LIVE_P (b
))
1853 /* These may run Lisp code and into infinite loops (if someone
1854 insisted on circular lists) so allow quitting here. */
1855 frames_discard_buffer (buffer
);
1857 clear_charpos_cache (b
);
1859 tem
= Vinhibit_quit
;
1861 /* Remove the buffer from the list of all buffers. */
1862 Vbuffer_alist
= Fdelq (Frassq (buffer
, Vbuffer_alist
), Vbuffer_alist
);
1863 /* If replace_buffer_in_windows didn't do its job fix that now. */
1864 replace_buffer_in_windows_safely (buffer
);
1865 Vinhibit_quit
= tem
;
1867 /* Delete any auto-save file, if we saved it in this session.
1868 But not if the buffer is modified. */
1869 if (STRINGP (BVAR (b
, auto_save_file_name
))
1870 && BUF_AUTOSAVE_MODIFF (b
) != 0
1871 && BUF_SAVE_MODIFF (b
) < BUF_AUTOSAVE_MODIFF (b
)
1872 && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
)
1873 && NILP (Fsymbol_value (intern ("auto-save-visited-file-name"))))
1876 delete = Fsymbol_value (intern ("delete-auto-save-files"));
1877 if (! NILP (delete))
1878 internal_delete_file (BVAR (b
, auto_save_file_name
));
1881 /* Deleting an auto-save file could have killed our buffer. */
1882 if (!BUFFER_LIVE_P (b
))
1888 /* Unchain all markers that belong to this indirect buffer.
1889 Don't unchain the markers that belong to the base buffer
1890 or its other indirect buffers. */
1891 struct Lisp_Marker
**mp
= &BUF_MARKERS (b
);
1902 /* Intervals should be owned by the base buffer (Bug#16502). */
1903 i
= buffer_intervals (b
);
1907 XSETBUFFER (owner
, b
->base_buffer
);
1908 set_interval_object (i
, owner
);
1913 /* Unchain all markers of this buffer and its indirect buffers.
1914 and leave them pointing nowhere. */
1915 for (m
= BUF_MARKERS (b
); m
; )
1917 struct Lisp_Marker
*next
= m
->next
;
1922 BUF_MARKERS (b
) = NULL
;
1923 set_buffer_intervals (b
, NULL
);
1925 /* Perhaps we should explicitly free the interval tree here... */
1927 /* Since we've unlinked the markers, the overlays can't be here any more
1929 b
->overlays_before
= NULL
;
1930 b
->overlays_after
= NULL
;
1932 /* Reset the local variables, so that this buffer's local values
1933 won't be protected from GC. They would be protected
1934 if they happened to remain cached in their symbols.
1935 This gets rid of them for certain. */
1936 swap_out_buffer_local_variables (b
);
1937 reset_buffer_local_variables (b
, 1);
1939 bset_name (b
, Qnil
);
1944 /* Notify our base buffer that we don't share the text anymore. */
1945 eassert (b
->indirections
== -1);
1946 b
->base_buffer
->indirections
--;
1947 eassert (b
->base_buffer
->indirections
>= 0);
1948 /* Make sure that we wasn't confused. */
1949 eassert (b
->window_count
== -1);
1953 /* Make sure that no one shows us. */
1954 eassert (b
->window_count
== 0);
1955 /* No one shares our buffer text, can free it. */
1956 free_buffer_text (b
);
1959 if (b
->newline_cache
)
1961 free_region_cache (b
->newline_cache
);
1962 b
->newline_cache
= 0;
1964 if (b
->width_run_cache
)
1966 free_region_cache (b
->width_run_cache
);
1967 b
->width_run_cache
= 0;
1969 if (b
->bidi_paragraph_cache
)
1971 free_region_cache (b
->bidi_paragraph_cache
);
1972 b
->bidi_paragraph_cache
= 0;
1974 bset_width_table (b
, Qnil
);
1976 bset_undo_list (b
, Qnil
);
1978 /* Run buffer-list-update-hook. */
1979 if (!NILP (Vrun_hooks
))
1980 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1985 /* Move association for BUFFER to the front of buffer (a)lists. Since
1986 we do this each time BUFFER is selected visibly, the more recently
1987 selected buffers are always closer to the front of those lists. This
1988 means that other_buffer is more likely to choose a relevant buffer.
1990 Note that this moves BUFFER to the front of the buffer lists of the
1991 selected frame even if BUFFER is not shown there. If BUFFER is not
1992 shown in the selected frame, consider the present behavior a feature.
1993 `select-window' gets this right since it shows BUFFER in the selected
1994 window when calling us. */
1997 record_buffer (Lisp_Object buffer
)
1999 Lisp_Object aelt
, aelt_cons
, tem
;
2000 register struct frame
*f
= XFRAME (selected_frame
);
2002 CHECK_BUFFER (buffer
);
2004 /* Update Vbuffer_alist (we know that it has an entry for BUFFER).
2005 Don't allow quitting since this might leave the buffer list in an
2006 inconsistent state. */
2007 tem
= Vinhibit_quit
;
2009 aelt
= Frassq (buffer
, Vbuffer_alist
);
2010 aelt_cons
= Fmemq (aelt
, Vbuffer_alist
);
2011 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
2012 XSETCDR (aelt_cons
, Vbuffer_alist
);
2013 Vbuffer_alist
= aelt_cons
;
2014 Vinhibit_quit
= tem
;
2016 /* Update buffer list of selected frame. */
2017 fset_buffer_list (f
, Fcons (buffer
, Fdelq (buffer
, f
->buffer_list
)));
2018 fset_buried_buffer_list (f
, Fdelq (buffer
, f
->buried_buffer_list
));
2020 /* Run buffer-list-update-hook. */
2021 if (!NILP (Vrun_hooks
))
2022 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
2026 /* Move BUFFER to the end of the buffer (a)lists. Do nothing if the
2027 buffer is killed. For the selected frame's buffer list this moves
2028 BUFFER to its end even if it was never shown in that frame. If
2029 this happens we have a feature, hence `bury-buffer-internal' should be
2030 called only when BUFFER was shown in the selected frame. */
2032 DEFUN ("bury-buffer-internal", Fbury_buffer_internal
, Sbury_buffer_internal
,
2034 doc
: /* Move BUFFER to the end of the buffer list. */)
2035 (Lisp_Object buffer
)
2037 Lisp_Object aelt
, aelt_cons
, tem
;
2038 register struct frame
*f
= XFRAME (selected_frame
);
2040 CHECK_BUFFER (buffer
);
2042 /* Update Vbuffer_alist (we know that it has an entry for BUFFER).
2043 Don't allow quitting since this might leave the buffer list in an
2044 inconsistent state. */
2045 tem
= Vinhibit_quit
;
2047 aelt
= Frassq (buffer
, Vbuffer_alist
);
2048 aelt_cons
= Fmemq (aelt
, Vbuffer_alist
);
2049 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
2050 XSETCDR (aelt_cons
, Qnil
);
2051 Vbuffer_alist
= nconc2 (Vbuffer_alist
, aelt_cons
);
2052 Vinhibit_quit
= tem
;
2054 /* Update buffer lists of selected frame. */
2055 fset_buffer_list (f
, Fdelq (buffer
, f
->buffer_list
));
2056 fset_buried_buffer_list
2057 (f
, Fcons (buffer
, Fdelq (buffer
, f
->buried_buffer_list
)));
2059 /* Run buffer-list-update-hook. */
2060 if (!NILP (Vrun_hooks
))
2061 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
2066 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode
, Sset_buffer_major_mode
, 1, 1, 0,
2067 doc
: /* Set an appropriate major mode for BUFFER.
2068 For the *scratch* buffer, use `initial-major-mode', otherwise choose a mode
2069 according to the default value of `major-mode'.
2070 Use this function before selecting the buffer, since it may need to inspect
2071 the current buffer's major mode. */)
2072 (Lisp_Object buffer
)
2075 Lisp_Object function
;
2077 CHECK_BUFFER (buffer
);
2079 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
2080 error ("Attempt to set major mode for a dead buffer");
2082 if (strcmp (SSDATA (BVAR (XBUFFER (buffer
), name
)), "*scratch*") == 0)
2083 function
= find_symbol_value (intern ("initial-major-mode"));
2086 function
= BVAR (&buffer_defaults
, major_mode
);
2088 && NILP (Fget (BVAR (current_buffer
, major_mode
), Qmode_class
)))
2089 function
= BVAR (current_buffer
, major_mode
);
2092 if (NILP (function
) || EQ (function
, Qfundamental_mode
))
2095 count
= SPECPDL_INDEX ();
2097 /* To select a nonfundamental mode,
2098 select the buffer temporarily and then call the mode function. */
2100 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2102 Fset_buffer (buffer
);
2105 return unbind_to (count
, Qnil
);
2108 DEFUN ("current-buffer", Fcurrent_buffer
, Scurrent_buffer
, 0, 0, 0,
2109 doc
: /* Return the current buffer as a Lisp object. */)
2112 register Lisp_Object buf
;
2113 XSETBUFFER (buf
, current_buffer
);
2117 /* Set the current buffer to B, and do not set windows_or_buffers_changed.
2118 This is used by redisplay. */
2121 set_buffer_internal_1 (register struct buffer
*b
)
2123 register struct buffer
*old_buf
;
2124 register Lisp_Object tail
;
2126 #ifdef USE_MMAP_FOR_BUFFERS
2127 if (b
->text
->beg
== NULL
)
2128 enlarge_buffer_text (b
, 0);
2129 #endif /* USE_MMAP_FOR_BUFFERS */
2131 if (current_buffer
== b
)
2134 BUFFER_CHECK_INDIRECTION (b
);
2136 old_buf
= current_buffer
;
2138 last_known_column_point
= -1; /* Invalidate indentation cache. */
2142 /* Put the undo list back in the base buffer, so that it appears
2143 that an indirect buffer shares the undo list of its base. */
2144 if (old_buf
->base_buffer
)
2145 bset_undo_list (old_buf
->base_buffer
, BVAR (old_buf
, undo_list
));
2147 /* If the old current buffer has markers to record PT, BEGV and ZV
2148 when it is not current, update them now. */
2149 record_buffer_markers (old_buf
);
2152 /* Get the undo list from the base buffer, so that it appears
2153 that an indirect buffer shares the undo list of its base. */
2155 bset_undo_list (b
, BVAR (b
->base_buffer
, undo_list
));
2157 /* If the new current buffer has markers to record PT, BEGV and ZV
2158 when it is not current, fetch them now. */
2159 fetch_buffer_markers (b
);
2161 /* Look down buffer's list of local Lisp variables
2162 to find and update any that forward into C variables. */
2166 for (tail
= BVAR (b
, local_var_alist
); CONSP (tail
); tail
= XCDR (tail
))
2168 Lisp_Object var
= XCAR (XCAR (tail
));
2169 struct Lisp_Symbol
*sym
= XSYMBOL (var
);
2170 if (sym
->redirect
== SYMBOL_LOCALIZED
/* Just to be sure. */
2171 && SYMBOL_BLV (sym
)->fwd
)
2172 /* Just reference the variable
2173 to cause it to become set for this buffer. */
2174 Fsymbol_value (var
);
2177 /* Do the same with any others that were local to the previous buffer */
2178 while (b
!= old_buf
&& (b
= old_buf
, b
));
2181 /* Switch to buffer B temporarily for redisplay purposes.
2182 This avoids certain things that don't need to be done within redisplay. */
2185 set_buffer_temp (struct buffer
*b
)
2187 register struct buffer
*old_buf
;
2189 if (current_buffer
== b
)
2192 old_buf
= current_buffer
;
2195 /* If the old current buffer has markers to record PT, BEGV and ZV
2196 when it is not current, update them now. */
2197 record_buffer_markers (old_buf
);
2199 /* If the new current buffer has markers to record PT, BEGV and ZV
2200 when it is not current, fetch them now. */
2201 fetch_buffer_markers (b
);
2204 DEFUN ("set-buffer", Fset_buffer
, Sset_buffer
, 1, 1, 0,
2205 doc
: /* Make buffer BUFFER-OR-NAME current for editing operations.
2206 BUFFER-OR-NAME may be a buffer or the name of an existing buffer.
2207 See also `with-current-buffer' when you want to make a buffer current
2208 temporarily. This function does not display the buffer, so its effect
2209 ends when the current command terminates. Use `switch-to-buffer' or
2210 `pop-to-buffer' to switch buffers permanently.
2211 The return value is the buffer made current. */)
2212 (register Lisp_Object buffer_or_name
)
2214 register Lisp_Object buffer
;
2215 buffer
= Fget_buffer (buffer_or_name
);
2217 nsberror (buffer_or_name
);
2218 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
2219 error ("Selecting deleted buffer");
2220 set_buffer_internal (XBUFFER (buffer
));
2225 restore_buffer (Lisp_Object buffer_or_name
)
2227 Fset_buffer (buffer_or_name
);
2230 /* Set the current buffer to BUFFER provided if it is alive. */
2233 set_buffer_if_live (Lisp_Object buffer
)
2235 if (BUFFER_LIVE_P (XBUFFER (buffer
)))
2236 set_buffer_internal (XBUFFER (buffer
));
2239 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only
,
2240 Sbarf_if_buffer_read_only
, 0, 0, 0,
2241 doc
: /* Signal a `buffer-read-only' error if the current buffer is read-only. */)
2244 if (!NILP (BVAR (current_buffer
, read_only
))
2245 && NILP (Vinhibit_read_only
))
2246 xsignal1 (Qbuffer_read_only
, Fcurrent_buffer ());
2250 DEFUN ("erase-buffer", Ferase_buffer
, Serase_buffer
, 0, 0, "*",
2251 doc
: /* Delete the entire contents of the current buffer.
2252 Any narrowing restriction in effect (see `narrow-to-region') is removed,
2253 so the buffer is truly empty after this. */)
2260 current_buffer
->last_window_start
= 1;
2261 /* Prevent warnings, or suspension of auto saving, that would happen
2262 if future size is less than past size. Use of erase-buffer
2263 implies that the future text is not really related to the past text. */
2264 XSETFASTINT (BVAR (current_buffer
, save_length
), 0);
2269 validate_region (register Lisp_Object
*b
, register Lisp_Object
*e
)
2271 CHECK_NUMBER_COERCE_MARKER (*b
);
2272 CHECK_NUMBER_COERCE_MARKER (*e
);
2274 if (XINT (*b
) > XINT (*e
))
2277 tem
= *b
; *b
= *e
; *e
= tem
;
2280 if (! (BEGV
<= XINT (*b
) && XINT (*e
) <= ZV
))
2281 args_out_of_range_3 (Fcurrent_buffer (), *b
, *e
);
2284 /* Advance BYTE_POS up to a character boundary
2285 and return the adjusted position. */
2288 advance_to_char_boundary (ptrdiff_t byte_pos
)
2292 if (byte_pos
== BEG
)
2293 /* Beginning of buffer is always a character boundary. */
2296 c
= FETCH_BYTE (byte_pos
);
2297 if (! CHAR_HEAD_P (c
))
2299 /* We should advance BYTE_POS only when C is a constituent of a
2300 multibyte sequence. */
2301 ptrdiff_t orig_byte_pos
= byte_pos
;
2306 c
= FETCH_BYTE (byte_pos
);
2308 while (! CHAR_HEAD_P (c
) && byte_pos
> BEG
);
2310 if (byte_pos
< orig_byte_pos
)
2311 byte_pos
= orig_byte_pos
;
2312 /* If C is a constituent of a multibyte sequence, BYTE_POS was
2313 surely advance to the correct character boundary. If C is
2314 not, BYTE_POS was unchanged. */
2320 DEFUN ("buffer-swap-text", Fbuffer_swap_text
, Sbuffer_swap_text
,
2322 doc
: /* Swap the text between current buffer and BUFFER. */)
2323 (Lisp_Object buffer
)
2325 struct buffer
*other_buffer
;
2326 CHECK_BUFFER (buffer
);
2327 other_buffer
= XBUFFER (buffer
);
2329 if (!BUFFER_LIVE_P (other_buffer
))
2330 error ("Cannot swap a dead buffer's text");
2332 /* Actually, it probably works just fine.
2333 * if (other_buffer == current_buffer)
2334 * error ("Cannot swap a buffer's text with itself"); */
2336 /* Actually, this may be workable as well, tho probably only if they're
2338 if (other_buffer
->base_buffer
2339 || current_buffer
->base_buffer
)
2340 error ("Cannot swap indirect buffers's text");
2342 { /* This is probably harder to make work. */
2343 struct buffer
*other
;
2344 FOR_EACH_BUFFER (other
)
2345 if (other
->base_buffer
== other_buffer
2346 || other
->base_buffer
== current_buffer
)
2347 error ("One of the buffers to swap has indirect buffers");
2350 #define swapfield(field, type) \
2352 type tmp##field = other_buffer->field; \
2353 other_buffer->field = current_buffer->field; \
2354 current_buffer->field = tmp##field; \
2356 #define swapfield_(field, type) \
2358 type tmp##field = BVAR (other_buffer, field); \
2359 bset_##field (other_buffer, BVAR (current_buffer, field)); \
2360 bset_##field (current_buffer, tmp##field); \
2363 swapfield (own_text
, struct buffer_text
);
2364 eassert (current_buffer
->text
== ¤t_buffer
->own_text
);
2365 eassert (other_buffer
->text
== &other_buffer
->own_text
);
2367 r_alloc_reset_variable ((void **) ¤t_buffer
->own_text
.beg
,
2368 (void **) &other_buffer
->own_text
.beg
);
2369 r_alloc_reset_variable ((void **) &other_buffer
->own_text
.beg
,
2370 (void **) ¤t_buffer
->own_text
.beg
);
2371 #endif /* REL_ALLOC */
2373 swapfield (pt
, ptrdiff_t);
2374 swapfield (pt_byte
, ptrdiff_t);
2375 swapfield (begv
, ptrdiff_t);
2376 swapfield (begv_byte
, ptrdiff_t);
2377 swapfield (zv
, ptrdiff_t);
2378 swapfield (zv_byte
, ptrdiff_t);
2379 eassert (!current_buffer
->base_buffer
);
2380 eassert (!other_buffer
->base_buffer
);
2381 swapfield (indirections
, ptrdiff_t);
2382 current_buffer
->clip_changed
= 1; other_buffer
->clip_changed
= 1;
2383 swapfield (newline_cache
, struct region_cache
*);
2384 swapfield (width_run_cache
, struct region_cache
*);
2385 swapfield (bidi_paragraph_cache
, struct region_cache
*);
2386 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2387 other_buffer
->prevent_redisplay_optimizations_p
= 1;
2388 swapfield (overlays_before
, struct Lisp_Overlay
*);
2389 swapfield (overlays_after
, struct Lisp_Overlay
*);
2390 swapfield (overlay_center
, ptrdiff_t);
2391 swapfield_ (undo_list
, Lisp_Object
);
2392 swapfield_ (mark
, Lisp_Object
);
2393 swapfield_ (enable_multibyte_characters
, Lisp_Object
);
2394 swapfield_ (bidi_display_reordering
, Lisp_Object
);
2395 swapfield_ (bidi_paragraph_direction
, Lisp_Object
);
2396 /* FIXME: Not sure what we should do with these *_marker fields.
2397 Hopefully they're just nil anyway. */
2398 swapfield_ (pt_marker
, Lisp_Object
);
2399 swapfield_ (begv_marker
, Lisp_Object
);
2400 swapfield_ (zv_marker
, Lisp_Object
);
2401 bset_point_before_scroll (current_buffer
, Qnil
);
2402 bset_point_before_scroll (other_buffer
, Qnil
);
2404 current_buffer
->text
->modiff
++; other_buffer
->text
->modiff
++;
2405 current_buffer
->text
->chars_modiff
++; other_buffer
->text
->chars_modiff
++;
2406 current_buffer
->text
->overlay_modiff
++; other_buffer
->text
->overlay_modiff
++;
2407 current_buffer
->text
->beg_unchanged
= current_buffer
->text
->gpt
;
2408 current_buffer
->text
->end_unchanged
= current_buffer
->text
->gpt
;
2409 other_buffer
->text
->beg_unchanged
= other_buffer
->text
->gpt
;
2410 other_buffer
->text
->end_unchanged
= other_buffer
->text
->gpt
;
2412 struct Lisp_Marker
*m
;
2413 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
2414 if (m
->buffer
== other_buffer
)
2415 m
->buffer
= current_buffer
;
2417 /* Since there's no indirect buffer in sight, markers on
2418 BUF_MARKERS(buf) should either be for `buf' or dead. */
2419 eassert (!m
->buffer
);
2420 for (m
= BUF_MARKERS (other_buffer
); m
; m
= m
->next
)
2421 if (m
->buffer
== current_buffer
)
2422 m
->buffer
= other_buffer
;
2424 /* Since there's no indirect buffer in sight, markers on
2425 BUF_MARKERS(buf) should either be for `buf' or dead. */
2426 eassert (!m
->buffer
);
2428 { /* Some of the C code expects that both window markers of a
2429 live window points to that window's buffer. So since we
2430 just swapped the markers between the two buffers, we need
2431 to undo the effect of this swap for window markers. */
2432 Lisp_Object w
= selected_window
, ws
= Qnil
;
2433 Lisp_Object buf1
, buf2
;
2434 XSETBUFFER (buf1
, current_buffer
); XSETBUFFER (buf2
, other_buffer
);
2436 while (NILP (Fmemq (w
, ws
)))
2439 if (MARKERP (XWINDOW (w
)->pointm
)
2440 && (EQ (XWINDOW (w
)->contents
, buf1
)
2441 || EQ (XWINDOW (w
)->contents
, buf2
)))
2442 Fset_marker (XWINDOW (w
)->pointm
,
2444 (BUF_BEGV (XBUFFER (XWINDOW (w
)->contents
))),
2445 XWINDOW (w
)->contents
);
2446 /* Blindly copied from pointm part. */
2447 if (MARKERP (XWINDOW (w
)->old_pointm
)
2448 && (EQ (XWINDOW (w
)->contents
, buf1
)
2449 || EQ (XWINDOW (w
)->contents
, buf2
)))
2450 Fset_marker (XWINDOW (w
)->old_pointm
,
2452 (BUF_BEGV (XBUFFER (XWINDOW (w
)->contents
))),
2453 XWINDOW (w
)->contents
);
2454 if (MARKERP (XWINDOW (w
)->start
)
2455 && (EQ (XWINDOW (w
)->contents
, buf1
)
2456 || EQ (XWINDOW (w
)->contents
, buf2
)))
2457 Fset_marker (XWINDOW (w
)->start
,
2459 (XBUFFER (XWINDOW (w
)->contents
)->last_window_start
),
2460 XWINDOW (w
)->contents
);
2461 w
= Fnext_window (w
, Qt
, Qt
);
2465 if (current_buffer
->text
->intervals
)
2466 (eassert (EQ (current_buffer
->text
->intervals
->up
.obj
, buffer
)),
2467 XSETBUFFER (current_buffer
->text
->intervals
->up
.obj
, current_buffer
));
2468 if (other_buffer
->text
->intervals
)
2469 (eassert (EQ (other_buffer
->text
->intervals
->up
.obj
, Fcurrent_buffer ())),
2470 XSETBUFFER (other_buffer
->text
->intervals
->up
.obj
, other_buffer
));
2475 DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte
, Sset_buffer_multibyte
,
2477 doc
: /* Set the multibyte flag of the current buffer to FLAG.
2478 If FLAG is t, this makes the buffer a multibyte buffer.
2479 If FLAG is nil, this makes the buffer a single-byte buffer.
2480 In these cases, the buffer contents remain unchanged as a sequence of
2481 bytes but the contents viewed as characters do change.
2482 If FLAG is `to', this makes the buffer a multibyte buffer by changing
2483 all eight-bit bytes to eight-bit characters.
2484 If the multibyte flag was really changed, undo information of the
2485 current buffer is cleared. */)
2488 struct Lisp_Marker
*tail
, *markers
;
2489 struct buffer
*other
;
2491 bool narrowed
= (BEG
!= BEGV
|| Z
!= ZV
);
2492 bool modified_p
= !NILP (Fbuffer_modified_p (Qnil
));
2493 Lisp_Object old_undo
= BVAR (current_buffer
, undo_list
);
2494 struct gcpro gcpro1
;
2496 if (current_buffer
->base_buffer
)
2497 error ("Cannot do `set-buffer-multibyte' on an indirect buffer");
2499 /* Do nothing if nothing actually changes. */
2500 if (NILP (flag
) == NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
2505 /* Don't record these buffer changes. We will put a special undo entry
2507 bset_undo_list (current_buffer
, Qt
);
2509 /* If the cached position is for this buffer, clear it out. */
2510 clear_charpos_cache (current_buffer
);
2513 begv
= BEGV_BYTE
, zv
= ZV_BYTE
;
2515 begv
= BEGV
, zv
= ZV
;
2518 error ("Changing multibyteness in a narrowed buffer");
2520 invalidate_buffer_caches (current_buffer
, BEGV
, ZV
);
2524 ptrdiff_t pos
, stop
;
2527 /* Do this first, so it can use CHAR_TO_BYTE
2528 to calculate the old correspondences. */
2529 set_intervals_multibyte (0);
2531 bset_enable_multibyte_characters (current_buffer
, Qnil
);
2537 TEMP_SET_PT_BOTH (PT_BYTE
, PT_BYTE
);
2540 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
2541 tail
->charpos
= tail
->bytepos
;
2543 /* Convert multibyte form of 8-bit characters to unibyte. */
2558 if (ASCII_CHAR_P (*p
))
2560 else if (CHAR_BYTE8_HEAD_P (*p
))
2562 c
= STRING_CHAR_AND_LENGTH (p
, bytes
);
2563 /* Delete all bytes for this 8-bit character but the
2564 last one, and change the last one to the character
2567 del_range_2 (pos
, pos
, pos
+ bytes
, pos
+ bytes
, 0);
2579 bytes
= BYTES_BY_CHAR_HEAD (*p
);
2580 p
+= bytes
, pos
+= bytes
;
2584 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2589 ptrdiff_t pos
, stop
;
2590 unsigned char *p
, *pend
;
2592 /* Be sure not to have a multibyte sequence striding over the GAP.
2593 Ex: We change this: "...abc\302 _GAP_ \241def..."
2594 to: "...abc _GAP_ \302\241def..." */
2597 && GPT_BYTE
> 1 && GPT_BYTE
< Z_BYTE
2598 && ! CHAR_HEAD_P (*(GAP_END_ADDR
)))
2600 unsigned char *q
= GPT_ADDR
- 1;
2602 while (! CHAR_HEAD_P (*q
) && q
> BEG_ADDR
) q
--;
2603 if (LEADING_CODE_P (*q
))
2605 ptrdiff_t new_gpt
= GPT_BYTE
- (GPT_ADDR
- q
);
2607 move_gap_both (new_gpt
, new_gpt
);
2611 /* Make the buffer contents valid as multibyte by converting
2612 8-bit characters to multibyte form. */
2630 if (ASCII_CHAR_P (*p
))
2632 else if (EQ (flag
, Qt
)
2633 && ! CHAR_BYTE8_HEAD_P (*p
)
2634 && (bytes
= MULTIBYTE_LENGTH (p
, pend
)) > 0)
2635 p
+= bytes
, pos
+= bytes
;
2638 unsigned char tmp
[MAX_MULTIBYTE_LENGTH
];
2641 c
= BYTE8_TO_CHAR (*p
);
2642 bytes
= CHAR_STRING (c
, tmp
);
2644 TEMP_SET_PT_BOTH (pos
+ 1, pos
+ 1);
2646 insert_1_both ((char *) tmp
+ 1, bytes
, bytes
, 1, 0, 0);
2647 /* Now the gap is after the just inserted data. */
2665 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2667 /* Do this first, so that chars_in_text asks the right question.
2668 set_intervals_multibyte needs it too. */
2669 bset_enable_multibyte_characters (current_buffer
, Qt
);
2671 GPT_BYTE
= advance_to_char_boundary (GPT_BYTE
);
2672 GPT
= chars_in_text (BEG_ADDR
, GPT_BYTE
- BEG_BYTE
) + BEG
;
2674 Z
= chars_in_text (GAP_END_ADDR
, Z_BYTE
- GPT_BYTE
) + GPT
;
2676 BEGV_BYTE
= advance_to_char_boundary (BEGV_BYTE
);
2677 if (BEGV_BYTE
> GPT_BYTE
)
2678 BEGV
= chars_in_text (GAP_END_ADDR
, BEGV_BYTE
- GPT_BYTE
) + GPT
;
2680 BEGV
= chars_in_text (BEG_ADDR
, BEGV_BYTE
- BEG_BYTE
) + BEG
;
2682 ZV_BYTE
= advance_to_char_boundary (ZV_BYTE
);
2683 if (ZV_BYTE
> GPT_BYTE
)
2684 ZV
= chars_in_text (GAP_END_ADDR
, ZV_BYTE
- GPT_BYTE
) + GPT
;
2686 ZV
= chars_in_text (BEG_ADDR
, ZV_BYTE
- BEG_BYTE
) + BEG
;
2689 ptrdiff_t byte
= advance_to_char_boundary (PT_BYTE
);
2692 if (byte
> GPT_BYTE
)
2693 position
= chars_in_text (GAP_END_ADDR
, byte
- GPT_BYTE
) + GPT
;
2695 position
= chars_in_text (BEG_ADDR
, byte
- BEG_BYTE
) + BEG
;
2696 TEMP_SET_PT_BOTH (position
, byte
);
2699 tail
= markers
= BUF_MARKERS (current_buffer
);
2701 /* This prevents BYTE_TO_CHAR (that is, buf_bytepos_to_charpos) from
2702 getting confused by the markers that have not yet been updated.
2703 It is also a signal that it should never create a marker. */
2704 BUF_MARKERS (current_buffer
) = NULL
;
2706 for (; tail
; tail
= tail
->next
)
2708 tail
->bytepos
= advance_to_char_boundary (tail
->bytepos
);
2709 tail
->charpos
= BYTE_TO_CHAR (tail
->bytepos
);
2712 /* Make sure no markers were put on the chain
2713 while the chain value was incorrect. */
2714 if (BUF_MARKERS (current_buffer
))
2717 BUF_MARKERS (current_buffer
) = markers
;
2719 /* Do this last, so it can calculate the new correspondences
2720 between chars and bytes. */
2721 set_intervals_multibyte (1);
2724 if (!EQ (old_undo
, Qt
))
2726 /* Represent all the above changes by a special undo entry. */
2727 bset_undo_list (current_buffer
,
2728 Fcons (list3 (Qapply
,
2729 intern ("set-buffer-multibyte"),
2730 NILP (flag
) ? Qt
: Qnil
),
2736 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2738 /* If buffer is shown in a window, let redisplay consider other windows. */
2739 if (buffer_window_count (current_buffer
))
2740 windows_or_buffers_changed
= 10;
2742 /* Copy this buffer's new multibyte status
2743 into all of its indirect buffers. */
2744 FOR_EACH_BUFFER (other
)
2745 if (other
->base_buffer
== current_buffer
&& BUFFER_LIVE_P (other
))
2747 BVAR (other
, enable_multibyte_characters
)
2748 = BVAR (current_buffer
, enable_multibyte_characters
);
2749 other
->prevent_redisplay_optimizations_p
= 1;
2752 /* Restore the modifiedness of the buffer. */
2753 if (!modified_p
&& !NILP (Fbuffer_modified_p (Qnil
)))
2754 Fset_buffer_modified_p (Qnil
);
2756 /* Update coding systems of this buffer's process (if any). */
2758 Lisp_Object process
;
2760 process
= Fget_buffer_process (Fcurrent_buffer ());
2761 if (PROCESSP (process
))
2762 setup_process_coding_systems (process
);
2768 DEFUN ("kill-all-local-variables", Fkill_all_local_variables
,
2769 Skill_all_local_variables
, 0, 0, 0,
2770 doc
: /* Switch to Fundamental mode by killing current buffer's local variables.
2771 Most local variable bindings are eliminated so that the default values
2772 become effective once more. Also, the syntax table is set from
2773 `standard-syntax-table', the local keymap is set to nil,
2774 and the abbrev table from `fundamental-mode-abbrev-table'.
2775 This function also forces redisplay of the mode line.
2777 Every function to select a new major mode starts by
2778 calling this function.
2780 As a special exception, local variables whose names have
2781 a non-nil `permanent-local' property are not eliminated by this function.
2783 The first thing this function does is run
2784 the normal hook `change-major-mode-hook'. */)
2787 Frun_hooks (1, &Qchange_major_mode_hook
);
2789 /* Make sure none of the bindings in local_var_alist
2790 remain swapped in, in their symbols. */
2792 swap_out_buffer_local_variables (current_buffer
);
2794 /* Actually eliminate all local bindings of this buffer. */
2796 reset_buffer_local_variables (current_buffer
, 0);
2798 /* Force mode-line redisplay. Useful here because all major mode
2799 commands call this function. */
2800 update_mode_lines
= 12;
2805 /* Make sure no local variables remain set up with buffer B
2806 for their current values. */
2809 swap_out_buffer_local_variables (struct buffer
*b
)
2811 Lisp_Object oalist
, alist
, buffer
;
2813 XSETBUFFER (buffer
, b
);
2814 oalist
= BVAR (b
, local_var_alist
);
2816 for (alist
= oalist
; CONSP (alist
); alist
= XCDR (alist
))
2818 Lisp_Object sym
= XCAR (XCAR (alist
));
2819 eassert (XSYMBOL (sym
)->redirect
== SYMBOL_LOCALIZED
);
2820 /* Need not do anything if some other buffer's binding is
2822 if (EQ (SYMBOL_BLV (XSYMBOL (sym
))->where
, buffer
))
2824 /* Symbol is set up for this buffer's old local value:
2826 swap_in_global_binding (XSYMBOL (sym
));
2831 /* Find all the overlays in the current buffer that contain position POS.
2832 Return the number found, and store them in a vector in *VEC_PTR.
2833 Store in *LEN_PTR the size allocated for the vector.
2834 Store in *NEXT_PTR the next position after POS where an overlay starts,
2835 or ZV if there are no more overlays between POS and ZV.
2836 Store in *PREV_PTR the previous position before POS where an overlay ends,
2837 or where an overlay starts which ends at or after POS;
2838 or BEGV if there are no such overlays from BEGV to POS.
2839 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2841 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2842 when this function is called.
2844 If EXTEND, make the vector bigger if necessary.
2845 If not, never extend the vector,
2846 and store only as many overlays as will fit.
2847 But still return the total number of overlays.
2849 If CHANGE_REQ, any position written into *PREV_PTR or
2850 *NEXT_PTR is guaranteed to be not equal to POS, unless it is the
2851 default (BEGV or ZV). */
2854 overlays_at (EMACS_INT pos
, bool extend
, Lisp_Object
**vec_ptr
,
2856 ptrdiff_t *next_ptr
, ptrdiff_t *prev_ptr
, bool change_req
)
2858 Lisp_Object overlay
, start
, end
;
2859 struct Lisp_Overlay
*tail
;
2861 ptrdiff_t len
= *len_ptr
;
2862 Lisp_Object
*vec
= *vec_ptr
;
2863 ptrdiff_t next
= ZV
;
2864 ptrdiff_t prev
= BEGV
;
2865 bool inhibit_storing
= 0;
2867 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2869 ptrdiff_t startpos
, endpos
;
2871 XSETMISC (overlay
, tail
);
2873 start
= OVERLAY_START (overlay
);
2874 end
= OVERLAY_END (overlay
);
2875 endpos
= OVERLAY_POSITION (end
);
2882 startpos
= OVERLAY_POSITION (start
);
2883 /* This one ends at or after POS
2884 so its start counts for PREV_PTR if it's before POS. */
2885 if (prev
< startpos
&& startpos
< pos
)
2889 if (startpos
<= pos
)
2893 /* The supplied vector is full.
2894 Either make it bigger, or don't store any more in it. */
2897 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2903 inhibit_storing
= 1;
2906 if (!inhibit_storing
)
2908 /* Keep counting overlays even if we can't return them all. */
2911 else if (startpos
< next
)
2915 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2917 ptrdiff_t startpos
, endpos
;
2919 XSETMISC (overlay
, tail
);
2921 start
= OVERLAY_START (overlay
);
2922 end
= OVERLAY_END (overlay
);
2923 startpos
= OVERLAY_POSITION (start
);
2926 if (startpos
< next
)
2930 endpos
= OVERLAY_POSITION (end
);
2937 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2943 inhibit_storing
= 1;
2946 if (!inhibit_storing
)
2950 if (startpos
< pos
&& startpos
> prev
)
2953 else if (endpos
< pos
&& endpos
> prev
)
2955 else if (endpos
== pos
&& startpos
> prev
2956 && (!change_req
|| startpos
< pos
))
2967 /* Find all the overlays in the current buffer that overlap the range
2968 BEG-END, or are empty at BEG, or are empty at END provided END
2969 denotes the position at the end of the current buffer.
2971 Return the number found, and store them in a vector in *VEC_PTR.
2972 Store in *LEN_PTR the size allocated for the vector.
2973 Store in *NEXT_PTR the next position after POS where an overlay starts,
2974 or ZV if there are no more overlays.
2975 Store in *PREV_PTR the previous position before POS where an overlay ends,
2976 or BEGV if there are no previous overlays.
2977 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2979 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2980 when this function is called.
2982 If EXTEND, make the vector bigger if necessary.
2983 If not, never extend the vector,
2984 and store only as many overlays as will fit.
2985 But still return the total number of overlays. */
2988 overlays_in (EMACS_INT beg
, EMACS_INT end
, bool extend
,
2989 Lisp_Object
**vec_ptr
, ptrdiff_t *len_ptr
,
2990 ptrdiff_t *next_ptr
, ptrdiff_t *prev_ptr
)
2992 Lisp_Object overlay
, ostart
, oend
;
2993 struct Lisp_Overlay
*tail
;
2995 ptrdiff_t len
= *len_ptr
;
2996 Lisp_Object
*vec
= *vec_ptr
;
2997 ptrdiff_t next
= ZV
;
2998 ptrdiff_t prev
= BEGV
;
2999 bool inhibit_storing
= 0;
3000 bool end_is_Z
= end
== Z
;
3002 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
3004 ptrdiff_t startpos
, endpos
;
3006 XSETMISC (overlay
, tail
);
3008 ostart
= OVERLAY_START (overlay
);
3009 oend
= OVERLAY_END (overlay
);
3010 endpos
= OVERLAY_POSITION (oend
);
3017 startpos
= OVERLAY_POSITION (ostart
);
3018 /* Count an interval if it overlaps the range, is empty at the
3019 start of the range, or is empty at END provided END denotes the
3020 end of the buffer. */
3021 if ((beg
< endpos
&& startpos
< end
)
3022 || (startpos
== endpos
3023 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
3027 /* The supplied vector is full.
3028 Either make it bigger, or don't store any more in it. */
3031 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
3037 inhibit_storing
= 1;
3040 if (!inhibit_storing
)
3042 /* Keep counting overlays even if we can't return them all. */
3045 else if (startpos
< next
)
3049 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
3051 ptrdiff_t startpos
, endpos
;
3053 XSETMISC (overlay
, tail
);
3055 ostart
= OVERLAY_START (overlay
);
3056 oend
= OVERLAY_END (overlay
);
3057 startpos
= OVERLAY_POSITION (ostart
);
3060 if (startpos
< next
)
3064 endpos
= OVERLAY_POSITION (oend
);
3065 /* Count an interval if it overlaps the range, is empty at the
3066 start of the range, or is empty at END provided END denotes the
3067 end of the buffer. */
3068 if ((beg
< endpos
&& startpos
< end
)
3069 || (startpos
== endpos
3070 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
3076 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
3082 inhibit_storing
= 1;
3085 if (!inhibit_storing
)
3089 else if (endpos
< beg
&& endpos
> prev
)
3101 /* Return true if there exists an overlay with a non-nil
3102 `mouse-face' property overlapping OVERLAY. */
3105 mouse_face_overlay_overlaps (Lisp_Object overlay
)
3107 ptrdiff_t start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3108 ptrdiff_t end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3109 ptrdiff_t n
, i
, size
;
3110 Lisp_Object
*v
, tem
;
3113 v
= alloca (size
* sizeof *v
);
3114 n
= overlays_in (start
, end
, 0, &v
, &size
, NULL
, NULL
);
3117 v
= alloca (n
* sizeof *v
);
3118 overlays_in (start
, end
, 0, &v
, &n
, NULL
, NULL
);
3121 for (i
= 0; i
< n
; ++i
)
3122 if (!EQ (v
[i
], overlay
)
3123 && (tem
= Foverlay_get (overlay
, Qmouse_face
),
3132 /* Fast function to just test if we're at an overlay boundary. */
3134 overlay_touches_p (ptrdiff_t pos
)
3136 Lisp_Object overlay
;
3137 struct Lisp_Overlay
*tail
;
3139 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
3143 XSETMISC (overlay
,tail
);
3144 eassert (OVERLAYP (overlay
));
3146 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3149 if (endpos
== pos
|| OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
)
3153 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
3157 XSETMISC (overlay
, tail
);
3158 eassert (OVERLAYP (overlay
));
3160 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3163 if (startpos
== pos
|| OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
)
3171 Lisp_Object overlay
;
3174 EMACS_INT spriority
; /* Secondary priority. */
3178 compare_overlays (const void *v1
, const void *v2
)
3180 const struct sortvec
*s1
= v1
;
3181 const struct sortvec
*s2
= v2
;
3182 /* Return 1 if s1 should take precedence, -1 if v2 should take precedence,
3183 and 0 if they're equal. */
3184 if (s1
->priority
!= s2
->priority
)
3185 return s1
->priority
< s2
->priority
? -1 : 1;
3186 /* If the priority is equal, give precedence to the one not covered by the
3187 other. If neither covers the other, obey spriority. */
3188 else if (s1
->beg
< s2
->beg
)
3189 return (s1
->end
< s2
->end
&& s1
->spriority
> s2
->spriority
? 1 : -1);
3190 else if (s1
->beg
> s2
->beg
)
3191 return (s1
->end
> s2
->end
&& s1
->spriority
< s2
->spriority
? -1 : 1);
3192 else if (s1
->end
!= s2
->end
)
3193 return s2
->end
< s1
->end
? -1 : 1;
3194 else if (s1
->spriority
!= s2
->spriority
)
3195 return (s1
->spriority
< s2
->spriority
? -1 : 1);
3196 else if (EQ (s1
->overlay
, s2
->overlay
))
3199 /* Avoid the non-determinism of qsort by choosing an arbitrary ordering
3200 between "equal" overlays. The result can still change between
3201 invocations of Emacs, but it won't change in the middle of
3202 `find_field' (bug#6830). */
3203 return XLI (s1
->overlay
) < XLI (s2
->overlay
) ? -1 : 1;
3206 /* Sort an array of overlays by priority. The array is modified in place.
3207 The return value is the new size; this may be smaller than the original
3208 size if some of the overlays were invalid or were window-specific. */
3210 sort_overlays (Lisp_Object
*overlay_vec
, ptrdiff_t noverlays
, struct window
*w
)
3214 struct sortvec
*sortvec
;
3216 SAFE_NALLOCA (sortvec
, 1, noverlays
);
3218 /* Put the valid and relevant overlays into sortvec. */
3220 for (i
= 0, j
= 0; i
< noverlays
; i
++)
3223 Lisp_Object overlay
;
3225 overlay
= overlay_vec
[i
];
3226 if (OVERLAYP (overlay
)
3227 && OVERLAY_POSITION (OVERLAY_START (overlay
)) > 0
3228 && OVERLAY_POSITION (OVERLAY_END (overlay
)) > 0)
3230 /* If we're interested in a specific window, then ignore
3231 overlays that are limited to some other window. */
3236 window
= Foverlay_get (overlay
, Qwindow
);
3237 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3241 /* This overlay is good and counts: put it into sortvec. */
3242 sortvec
[j
].overlay
= overlay
;
3243 sortvec
[j
].beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3244 sortvec
[j
].end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3245 tem
= Foverlay_get (overlay
, Qpriority
);
3248 sortvec
[j
].priority
= 0;
3249 sortvec
[j
].spriority
= 0;
3251 else if (INTEGERP (tem
))
3253 sortvec
[j
].priority
= XINT (tem
);
3254 sortvec
[j
].spriority
= 0;
3256 else if (CONSP (tem
))
3258 Lisp_Object car
= XCAR (tem
);
3259 Lisp_Object cdr
= XCDR (tem
);
3260 sortvec
[j
].priority
= INTEGERP (car
) ? XINT (car
) : 0;
3261 sortvec
[j
].spriority
= INTEGERP (cdr
) ? XINT (cdr
) : 0;
3268 /* Sort the overlays into the proper order: increasing priority. */
3271 qsort (sortvec
, noverlays
, sizeof (struct sortvec
), compare_overlays
);
3273 for (i
= 0; i
< noverlays
; i
++)
3274 overlay_vec
[i
] = sortvec
[i
].overlay
;
3282 Lisp_Object string
, string2
;
3289 struct sortstr
*buf
; /* An array that expands as needed; never freed. */
3290 ptrdiff_t size
; /* Allocated length of that array. */
3291 ptrdiff_t used
; /* How much of the array is currently in use. */
3292 ptrdiff_t bytes
; /* Total length of the strings in buf. */
3295 /* Buffers for storing information about the overlays touching a given
3296 position. These could be automatic variables in overlay_strings, but
3297 it's more efficient to hold onto the memory instead of repeatedly
3298 allocating and freeing it. */
3299 static struct sortstrlist overlay_heads
, overlay_tails
;
3300 static unsigned char *overlay_str_buf
;
3302 /* Allocated length of overlay_str_buf. */
3303 static ptrdiff_t overlay_str_len
;
3305 /* A comparison function suitable for passing to qsort. */
3307 cmp_for_strings (const void *as1
, const void *as2
)
3309 struct sortstr
const *s1
= as1
;
3310 struct sortstr
const *s2
= as2
;
3311 if (s1
->size
!= s2
->size
)
3312 return s2
->size
< s1
->size
? -1 : 1;
3313 if (s1
->priority
!= s2
->priority
)
3314 return s1
->priority
< s2
->priority
? -1 : 1;
3319 record_overlay_string (struct sortstrlist
*ssl
, Lisp_Object str
,
3320 Lisp_Object str2
, Lisp_Object pri
, ptrdiff_t size
)
3324 if (ssl
->used
== ssl
->size
)
3325 ssl
->buf
= xpalloc (ssl
->buf
, &ssl
->size
, 5, -1, sizeof *ssl
->buf
);
3326 ssl
->buf
[ssl
->used
].string
= str
;
3327 ssl
->buf
[ssl
->used
].string2
= str2
;
3328 ssl
->buf
[ssl
->used
].size
= size
;
3329 ssl
->buf
[ssl
->used
].priority
= (INTEGERP (pri
) ? XINT (pri
) : 0);
3332 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3333 nbytes
= SCHARS (str
);
3334 else if (! STRING_MULTIBYTE (str
))
3335 nbytes
= count_size_as_multibyte (SDATA (str
),
3338 nbytes
= SBYTES (str
);
3340 if (INT_ADD_OVERFLOW (ssl
->bytes
, nbytes
))
3341 memory_full (SIZE_MAX
);
3342 ssl
->bytes
+= nbytes
;
3346 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3347 nbytes
= SCHARS (str2
);
3348 else if (! STRING_MULTIBYTE (str2
))
3349 nbytes
= count_size_as_multibyte (SDATA (str2
),
3352 nbytes
= SBYTES (str2
);
3354 if (INT_ADD_OVERFLOW (ssl
->bytes
, nbytes
))
3355 memory_full (SIZE_MAX
);
3356 ssl
->bytes
+= nbytes
;
3360 /* Concatenate the strings associated with overlays that begin or end
3361 at POS, ignoring overlays that are specific to windows other than W.
3362 The strings are concatenated in the appropriate order: shorter
3363 overlays nest inside longer ones, and higher priority inside lower.
3364 Normally all of the after-strings come first, but zero-sized
3365 overlays have their after-strings ride along with the
3366 before-strings because it would look strange to print them
3369 Returns the concatenated string's length, and return the pointer to
3370 that string via PSTR, if that variable is non-NULL. The storage of
3371 the concatenated strings may be overwritten by subsequent calls. */
3374 overlay_strings (ptrdiff_t pos
, struct window
*w
, unsigned char **pstr
)
3376 Lisp_Object overlay
, window
, str
;
3377 struct Lisp_Overlay
*ov
;
3378 ptrdiff_t startpos
, endpos
;
3379 bool multibyte
= ! NILP (BVAR (current_buffer
, enable_multibyte_characters
));
3381 overlay_heads
.used
= overlay_heads
.bytes
= 0;
3382 overlay_tails
.used
= overlay_tails
.bytes
= 0;
3383 for (ov
= current_buffer
->overlays_before
; ov
; ov
= ov
->next
)
3385 XSETMISC (overlay
, ov
);
3386 eassert (OVERLAYP (overlay
));
3388 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3389 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3392 if (endpos
!= pos
&& startpos
!= pos
)
3394 window
= Foverlay_get (overlay
, Qwindow
);
3395 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3398 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3399 record_overlay_string (&overlay_heads
, str
,
3401 ? Foverlay_get (overlay
, Qafter_string
)
3403 Foverlay_get (overlay
, Qpriority
),
3405 else if (endpos
== pos
3406 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3407 record_overlay_string (&overlay_tails
, str
, Qnil
,
3408 Foverlay_get (overlay
, Qpriority
),
3411 for (ov
= current_buffer
->overlays_after
; ov
; ov
= ov
->next
)
3413 XSETMISC (overlay
, ov
);
3414 eassert (OVERLAYP (overlay
));
3416 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3417 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3420 if (endpos
!= pos
&& startpos
!= pos
)
3422 window
= Foverlay_get (overlay
, Qwindow
);
3423 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3426 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3427 record_overlay_string (&overlay_heads
, str
,
3429 ? Foverlay_get (overlay
, Qafter_string
)
3431 Foverlay_get (overlay
, Qpriority
),
3433 else if (endpos
== pos
3434 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3435 record_overlay_string (&overlay_tails
, str
, Qnil
,
3436 Foverlay_get (overlay
, Qpriority
),
3439 if (overlay_tails
.used
> 1)
3440 qsort (overlay_tails
.buf
, overlay_tails
.used
, sizeof (struct sortstr
),
3442 if (overlay_heads
.used
> 1)
3443 qsort (overlay_heads
.buf
, overlay_heads
.used
, sizeof (struct sortstr
),
3445 if (overlay_heads
.bytes
|| overlay_tails
.bytes
)
3452 if (INT_ADD_OVERFLOW (overlay_heads
.bytes
, overlay_tails
.bytes
))
3453 memory_full (SIZE_MAX
);
3454 total
= overlay_heads
.bytes
+ overlay_tails
.bytes
;
3455 if (total
> overlay_str_len
)
3456 overlay_str_buf
= xpalloc (overlay_str_buf
, &overlay_str_len
,
3457 total
- overlay_str_len
, -1, 1);
3459 p
= overlay_str_buf
;
3460 for (i
= overlay_tails
.used
; --i
>= 0;)
3463 tem
= overlay_tails
.buf
[i
].string
;
3464 nbytes
= copy_text (SDATA (tem
), p
,
3466 STRING_MULTIBYTE (tem
), multibyte
);
3469 for (i
= 0; i
< overlay_heads
.used
; ++i
)
3472 tem
= overlay_heads
.buf
[i
].string
;
3473 nbytes
= copy_text (SDATA (tem
), p
,
3475 STRING_MULTIBYTE (tem
), multibyte
);
3477 tem
= overlay_heads
.buf
[i
].string2
;
3480 nbytes
= copy_text (SDATA (tem
), p
,
3482 STRING_MULTIBYTE (tem
), multibyte
);
3486 if (p
!= overlay_str_buf
+ total
)
3489 *pstr
= overlay_str_buf
;
3495 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
3498 recenter_overlay_lists (struct buffer
*buf
, ptrdiff_t pos
)
3500 Lisp_Object overlay
, beg
, end
;
3501 struct Lisp_Overlay
*prev
, *tail
, *next
;
3503 /* See if anything in overlays_before should move to overlays_after. */
3505 /* We don't strictly need prev in this loop; it should always be nil.
3506 But we use it for symmetry and in case that should cease to be true
3507 with some future change. */
3509 for (tail
= buf
->overlays_before
; tail
; prev
= tail
, tail
= next
)
3512 XSETMISC (overlay
, tail
);
3513 eassert (OVERLAYP (overlay
));
3515 beg
= OVERLAY_START (overlay
);
3516 end
= OVERLAY_END (overlay
);
3518 if (OVERLAY_POSITION (end
) > pos
)
3520 /* OVERLAY needs to be moved. */
3521 ptrdiff_t where
= OVERLAY_POSITION (beg
);
3522 struct Lisp_Overlay
*other
, *other_prev
;
3524 /* Splice the cons cell TAIL out of overlays_before. */
3528 set_buffer_overlays_before (buf
, next
);
3530 /* Search thru overlays_after for where to put it. */
3532 for (other
= buf
->overlays_after
; other
;
3533 other_prev
= other
, other
= other
->next
)
3535 Lisp_Object otherbeg
, otheroverlay
;
3537 XSETMISC (otheroverlay
, other
);
3538 eassert (OVERLAYP (otheroverlay
));
3540 otherbeg
= OVERLAY_START (otheroverlay
);
3541 if (OVERLAY_POSITION (otherbeg
) >= where
)
3545 /* Add TAIL to overlays_after before OTHER. */
3548 other_prev
->next
= tail
;
3550 set_buffer_overlays_after (buf
, tail
);
3554 /* We've reached the things that should stay in overlays_before.
3555 All the rest of overlays_before must end even earlier,
3560 /* See if anything in overlays_after should be in overlays_before. */
3562 for (tail
= buf
->overlays_after
; tail
; prev
= tail
, tail
= next
)
3565 XSETMISC (overlay
, tail
);
3566 eassert (OVERLAYP (overlay
));
3568 beg
= OVERLAY_START (overlay
);
3569 end
= OVERLAY_END (overlay
);
3571 /* Stop looking, when we know that nothing further
3572 can possibly end before POS. */
3573 if (OVERLAY_POSITION (beg
) > pos
)
3576 if (OVERLAY_POSITION (end
) <= pos
)
3578 /* OVERLAY needs to be moved. */
3579 ptrdiff_t where
= OVERLAY_POSITION (end
);
3580 struct Lisp_Overlay
*other
, *other_prev
;
3582 /* Splice the cons cell TAIL out of overlays_after. */
3586 set_buffer_overlays_after (buf
, next
);
3588 /* Search thru overlays_before for where to put it. */
3590 for (other
= buf
->overlays_before
; other
;
3591 other_prev
= other
, other
= other
->next
)
3593 Lisp_Object otherend
, otheroverlay
;
3595 XSETMISC (otheroverlay
, other
);
3596 eassert (OVERLAYP (otheroverlay
));
3598 otherend
= OVERLAY_END (otheroverlay
);
3599 if (OVERLAY_POSITION (otherend
) <= where
)
3603 /* Add TAIL to overlays_before before OTHER. */
3606 other_prev
->next
= tail
;
3608 set_buffer_overlays_before (buf
, tail
);
3613 buf
->overlay_center
= pos
;
3617 adjust_overlays_for_insert (ptrdiff_t pos
, ptrdiff_t length
)
3619 /* After an insertion, the lists are still sorted properly,
3620 but we may need to update the value of the overlay center. */
3621 if (current_buffer
->overlay_center
>= pos
)
3622 current_buffer
->overlay_center
+= length
;
3626 adjust_overlays_for_delete (ptrdiff_t pos
, ptrdiff_t length
)
3628 if (current_buffer
->overlay_center
< pos
)
3629 /* The deletion was to our right. No change needed; the before- and
3630 after-lists are still consistent. */
3632 else if (current_buffer
->overlay_center
- pos
> length
)
3633 /* The deletion was to our left. We need to adjust the center value
3634 to account for the change in position, but the lists are consistent
3635 given the new value. */
3636 current_buffer
->overlay_center
-= length
;
3638 /* We're right in the middle. There might be things on the after-list
3639 that now belong on the before-list. Recentering will move them,
3640 and also update the center point. */
3641 recenter_overlay_lists (current_buffer
, pos
);
3644 /* Fix up overlays that were garbled as a result of permuting markers
3645 in the range START through END. Any overlay with at least one
3646 endpoint in this range will need to be unlinked from the overlay
3647 list and reinserted in its proper place.
3648 Such an overlay might even have negative size at this point.
3649 If so, we'll make the overlay empty. */
3651 fix_start_end_in_overlays (register ptrdiff_t start
, register ptrdiff_t end
)
3653 Lisp_Object overlay
;
3654 struct Lisp_Overlay
*before_list
IF_LINT (= NULL
);
3655 struct Lisp_Overlay
*after_list
IF_LINT (= NULL
);
3656 /* These are either nil, indicating that before_list or after_list
3657 should be assigned, or the cons cell the cdr of which should be
3659 struct Lisp_Overlay
*beforep
= NULL
, *afterp
= NULL
;
3660 /* 'Parent', likewise, indicates a cons cell or
3661 current_buffer->overlays_before or overlays_after, depending
3662 which loop we're in. */
3663 struct Lisp_Overlay
*tail
, *parent
;
3664 ptrdiff_t startpos
, endpos
;
3666 /* This algorithm shifts links around instead of consing and GCing.
3667 The loop invariant is that before_list (resp. after_list) is a
3668 well-formed list except that its last element, the CDR of beforep
3669 (resp. afterp) if beforep (afterp) isn't nil or before_list
3670 (after_list) if it is, is still uninitialized. So it's not a bug
3671 that before_list isn't initialized, although it may look
3673 for (parent
= NULL
, tail
= current_buffer
->overlays_before
; tail
;)
3675 XSETMISC (overlay
, tail
);
3677 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3678 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3680 /* If the overlay is backwards, make it empty. */
3681 if (endpos
< startpos
)
3684 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3692 || (startpos
>= start
&& startpos
< end
))
3694 /* Add it to the end of the wrong list. Later on,
3695 recenter_overlay_lists will move it to the right place. */
3696 if (endpos
< current_buffer
->overlay_center
)
3701 afterp
->next
= tail
;
3709 beforep
->next
= tail
;
3713 set_buffer_overlays_before (current_buffer
, tail
->next
);
3715 parent
->next
= tail
->next
;
3719 parent
= tail
, tail
= parent
->next
;
3721 for (parent
= NULL
, tail
= current_buffer
->overlays_after
; tail
;)
3723 XSETMISC (overlay
, tail
);
3725 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3726 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3728 /* If the overlay is backwards, make it empty. */
3729 if (endpos
< startpos
)
3732 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3736 if (startpos
>= end
)
3739 if (startpos
>= start
3740 || (endpos
>= start
&& endpos
< end
))
3742 if (endpos
< current_buffer
->overlay_center
)
3747 afterp
->next
= tail
;
3755 beforep
->next
= tail
;
3759 set_buffer_overlays_after (current_buffer
, tail
->next
);
3761 parent
->next
= tail
->next
;
3765 parent
= tail
, tail
= parent
->next
;
3768 /* Splice the constructed (wrong) lists into the buffer's lists,
3769 and let the recenter function make it sane again. */
3772 beforep
->next
= current_buffer
->overlays_before
;
3773 set_buffer_overlays_before (current_buffer
, before_list
);
3778 afterp
->next
= current_buffer
->overlays_after
;
3779 set_buffer_overlays_after (current_buffer
, after_list
);
3781 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3784 /* We have two types of overlay: the one whose ending marker is
3785 after-insertion-marker (this is the usual case) and the one whose
3786 ending marker is before-insertion-marker. When `overlays_before'
3787 contains overlays of the latter type and the former type in this
3788 order and both overlays end at inserting position, inserting a text
3789 increases only the ending marker of the latter type, which results
3790 in incorrect ordering of `overlays_before'.
3792 This function fixes ordering of overlays in the slot
3793 `overlays_before' of the buffer *BP. Before the insertion, `point'
3794 was at PREV, and now is at POS. */
3797 fix_overlays_before (struct buffer
*bp
, ptrdiff_t prev
, ptrdiff_t pos
)
3799 /* If parent is nil, replace overlays_before; otherwise, parent->next. */
3800 struct Lisp_Overlay
*tail
= bp
->overlays_before
, *parent
= NULL
, *right_pair
;
3802 ptrdiff_t end
IF_LINT (= 0);
3804 /* After the insertion, the several overlays may be in incorrect
3805 order. The possibility is that, in the list `overlays_before',
3806 an overlay which ends at POS appears after an overlay which ends
3807 at PREV. Since POS is greater than PREV, we must fix the
3808 ordering of these overlays, by moving overlays ends at POS before
3809 the overlays ends at PREV. */
3811 /* At first, find a place where disordered overlays should be linked
3812 in. It is where an overlay which end before POS exists. (i.e. an
3813 overlay whose ending marker is after-insertion-marker if disorder
3816 && (XSETMISC (tem
, tail
),
3817 (end
= OVERLAY_POSITION (OVERLAY_END (tem
))) >= pos
))
3823 /* If we don't find such an overlay,
3824 or the found one ends before PREV,
3825 or the found one is the last one in the list,
3826 we don't have to fix anything. */
3827 if (!tail
|| end
< prev
|| !tail
->next
)
3830 right_pair
= parent
;
3834 /* Now, end position of overlays in the list TAIL should be before
3835 or equal to PREV. In the loop, an overlay which ends at POS is
3836 moved ahead to the place indicated by the CDR of RIGHT_PAIR. If
3837 we found an overlay which ends before PREV, the remaining
3838 overlays are in correct order. */
3841 XSETMISC (tem
, tail
);
3842 end
= OVERLAY_POSITION (OVERLAY_END (tem
));
3845 { /* This overlay is disordered. */
3846 struct Lisp_Overlay
*found
= tail
;
3848 /* Unlink the found overlay. */
3850 parent
->next
= tail
;
3851 /* Move an overlay at RIGHT_PLACE to the next of the found one,
3852 and link it into the right place. */
3855 found
->next
= bp
->overlays_before
;
3856 set_buffer_overlays_before (bp
, found
);
3860 found
->next
= right_pair
->next
;
3861 right_pair
->next
= found
;
3864 else if (end
== prev
)
3869 else /* No more disordered overlay. */
3874 DEFUN ("overlayp", Foverlayp
, Soverlayp
, 1, 1, 0,
3875 doc
: /* Return t if OBJECT is an overlay. */)
3876 (Lisp_Object object
)
3878 return (OVERLAYP (object
) ? Qt
: Qnil
);
3881 DEFUN ("make-overlay", Fmake_overlay
, Smake_overlay
, 2, 5, 0,
3882 doc
: /* Create a new overlay with range BEG to END in BUFFER and return it.
3883 If omitted, BUFFER defaults to the current buffer.
3884 BEG and END may be integers or markers.
3885 The fourth arg FRONT-ADVANCE, if non-nil, makes the marker
3886 for the front of the overlay advance when text is inserted there
3887 \(which means the text *is not* included in the overlay).
3888 The fifth arg REAR-ADVANCE, if non-nil, makes the marker
3889 for the rear of the overlay advance when text is inserted there
3890 \(which means the text *is* included in the overlay). */)
3891 (Lisp_Object beg
, Lisp_Object end
, Lisp_Object buffer
,
3892 Lisp_Object front_advance
, Lisp_Object rear_advance
)
3894 Lisp_Object overlay
;
3898 XSETBUFFER (buffer
, current_buffer
);
3900 CHECK_BUFFER (buffer
);
3902 if (MARKERP (beg
) && !EQ (Fmarker_buffer (beg
), buffer
))
3903 signal_error ("Marker points into wrong buffer", beg
);
3904 if (MARKERP (end
) && !EQ (Fmarker_buffer (end
), buffer
))
3905 signal_error ("Marker points into wrong buffer", end
);
3907 CHECK_NUMBER_COERCE_MARKER (beg
);
3908 CHECK_NUMBER_COERCE_MARKER (end
);
3910 if (XINT (beg
) > XINT (end
))
3913 temp
= beg
; beg
= end
; end
= temp
;
3916 b
= XBUFFER (buffer
);
3918 beg
= Fset_marker (Fmake_marker (), beg
, buffer
);
3919 end
= Fset_marker (Fmake_marker (), end
, buffer
);
3921 if (!NILP (front_advance
))
3922 XMARKER (beg
)->insertion_type
= 1;
3923 if (!NILP (rear_advance
))
3924 XMARKER (end
)->insertion_type
= 1;
3926 overlay
= build_overlay (beg
, end
, Qnil
);
3928 /* Put the new overlay on the wrong list. */
3929 end
= OVERLAY_END (overlay
);
3930 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
3932 eassert (b
->overlays_after
|| (XOVERLAY (overlay
)->next
== NULL
));
3933 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3934 set_buffer_overlays_after (b
, XOVERLAY (overlay
));
3938 eassert (b
->overlays_before
|| (XOVERLAY (overlay
)->next
== NULL
));
3939 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3940 set_buffer_overlays_before (b
, XOVERLAY (overlay
));
3942 /* This puts it in the right list, and in the right order. */
3943 recenter_overlay_lists (b
, b
->overlay_center
);
3945 /* We don't need to redisplay the region covered by the overlay, because
3946 the overlay has no properties at the moment. */
3951 /* Mark a section of BUF as needing redisplay because of overlays changes. */
3954 modify_overlay (struct buffer
*buf
, ptrdiff_t start
, ptrdiff_t end
)
3958 ptrdiff_t temp
= start
;
3963 BUF_COMPUTE_UNCHANGED (buf
, start
, end
);
3965 bset_redisplay (buf
);
3967 ++BUF_OVERLAY_MODIFF (buf
);
3970 /* Remove OVERLAY from LIST. */
3972 static struct Lisp_Overlay
*
3973 unchain_overlay (struct Lisp_Overlay
*list
, struct Lisp_Overlay
*overlay
)
3975 register struct Lisp_Overlay
*tail
, **prev
= &list
;
3977 for (tail
= list
; tail
; prev
= &tail
->next
, tail
= *prev
)
3978 if (tail
== overlay
)
3980 *prev
= overlay
->next
;
3981 overlay
->next
= NULL
;
3987 /* Remove OVERLAY from both overlay lists of B. */
3990 unchain_both (struct buffer
*b
, Lisp_Object overlay
)
3992 struct Lisp_Overlay
*ov
= XOVERLAY (overlay
);
3994 set_buffer_overlays_before (b
, unchain_overlay (b
->overlays_before
, ov
));
3995 set_buffer_overlays_after (b
, unchain_overlay (b
->overlays_after
, ov
));
3996 eassert (XOVERLAY (overlay
)->next
== NULL
);
3999 DEFUN ("move-overlay", Fmove_overlay
, Smove_overlay
, 3, 4, 0,
4000 doc
: /* Set the endpoints of OVERLAY to BEG and END in BUFFER.
4001 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.
4002 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current
4004 (Lisp_Object overlay
, Lisp_Object beg
, Lisp_Object end
, Lisp_Object buffer
)
4006 struct buffer
*b
, *ob
= 0;
4007 Lisp_Object obuffer
;
4008 ptrdiff_t count
= SPECPDL_INDEX ();
4009 ptrdiff_t n_beg
, n_end
, o_beg
IF_LINT (= 0), o_end
IF_LINT (= 0);
4011 CHECK_OVERLAY (overlay
);
4013 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4015 XSETBUFFER (buffer
, current_buffer
);
4016 CHECK_BUFFER (buffer
);
4018 if (NILP (Fbuffer_live_p (buffer
)))
4019 error ("Attempt to move overlay to a dead buffer");
4021 if (MARKERP (beg
) && !EQ (Fmarker_buffer (beg
), buffer
))
4022 signal_error ("Marker points into wrong buffer", beg
);
4023 if (MARKERP (end
) && !EQ (Fmarker_buffer (end
), buffer
))
4024 signal_error ("Marker points into wrong buffer", end
);
4026 CHECK_NUMBER_COERCE_MARKER (beg
);
4027 CHECK_NUMBER_COERCE_MARKER (end
);
4029 if (XINT (beg
) > XINT (end
))
4032 temp
= beg
; beg
= end
; end
= temp
;
4035 specbind (Qinhibit_quit
, Qt
);
4037 obuffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4038 b
= XBUFFER (buffer
);
4040 if (!NILP (obuffer
))
4042 ob
= XBUFFER (obuffer
);
4044 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4045 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4047 unchain_both (ob
, overlay
);
4050 /* Set the overlay boundaries, which may clip them. */
4051 Fset_marker (OVERLAY_START (overlay
), beg
, buffer
);
4052 Fset_marker (OVERLAY_END (overlay
), end
, buffer
);
4054 n_beg
= marker_position (OVERLAY_START (overlay
));
4055 n_end
= marker_position (OVERLAY_END (overlay
));
4057 /* If the overlay has changed buffers, do a thorough redisplay. */
4058 if (!EQ (buffer
, obuffer
))
4060 /* Redisplay where the overlay was. */
4062 modify_overlay (ob
, o_beg
, o_end
);
4064 /* Redisplay where the overlay is going to be. */
4065 modify_overlay (b
, n_beg
, n_end
);
4068 /* Redisplay the area the overlay has just left, or just enclosed. */
4071 modify_overlay (b
, o_end
, n_end
);
4072 else if (o_end
== n_end
)
4073 modify_overlay (b
, o_beg
, n_beg
);
4075 modify_overlay (b
, min (o_beg
, n_beg
), max (o_end
, n_end
));
4078 /* Delete the overlay if it is empty after clipping and has the
4079 evaporate property. */
4080 if (n_beg
== n_end
&& !NILP (Foverlay_get (overlay
, Qevaporate
)))
4081 return unbind_to (count
, Fdelete_overlay (overlay
));
4083 /* Put the overlay into the new buffer's overlay lists, first on the
4085 if (n_end
< b
->overlay_center
)
4087 XOVERLAY (overlay
)->next
= b
->overlays_after
;
4088 set_buffer_overlays_after (b
, XOVERLAY (overlay
));
4092 XOVERLAY (overlay
)->next
= b
->overlays_before
;
4093 set_buffer_overlays_before (b
, XOVERLAY (overlay
));
4096 /* This puts it in the right list, and in the right order. */
4097 recenter_overlay_lists (b
, b
->overlay_center
);
4099 return unbind_to (count
, overlay
);
4102 DEFUN ("delete-overlay", Fdelete_overlay
, Sdelete_overlay
, 1, 1, 0,
4103 doc
: /* Delete the overlay OVERLAY from its buffer. */)
4104 (Lisp_Object overlay
)
4108 ptrdiff_t count
= SPECPDL_INDEX ();
4110 CHECK_OVERLAY (overlay
);
4112 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4116 b
= XBUFFER (buffer
);
4117 specbind (Qinhibit_quit
, Qt
);
4119 unchain_both (b
, overlay
);
4120 drop_overlay (b
, XOVERLAY (overlay
));
4122 /* When deleting an overlay with before or after strings, turn off
4123 display optimizations for the affected buffer, on the basis that
4124 these strings may contain newlines. This is easier to do than to
4125 check for that situation during redisplay. */
4126 if (!windows_or_buffers_changed
4127 && (!NILP (Foverlay_get (overlay
, Qbefore_string
))
4128 || !NILP (Foverlay_get (overlay
, Qafter_string
))))
4129 b
->prevent_redisplay_optimizations_p
= 1;
4131 return unbind_to (count
, Qnil
);
4134 DEFUN ("delete-all-overlays", Fdelete_all_overlays
, Sdelete_all_overlays
, 0, 1, 0,
4135 doc
: /* Delete all overlays of BUFFER.
4136 BUFFER omitted or nil means delete all overlays of the current
4138 (Lisp_Object buffer
)
4140 register struct buffer
*buf
;
4143 buf
= current_buffer
;
4146 CHECK_BUFFER (buffer
);
4147 buf
= XBUFFER (buffer
);
4150 delete_all_overlays (buf
);
4154 /* Overlay dissection functions. */
4156 DEFUN ("overlay-start", Foverlay_start
, Soverlay_start
, 1, 1, 0,
4157 doc
: /* Return the position at which OVERLAY starts. */)
4158 (Lisp_Object overlay
)
4160 CHECK_OVERLAY (overlay
);
4162 return (Fmarker_position (OVERLAY_START (overlay
)));
4165 DEFUN ("overlay-end", Foverlay_end
, Soverlay_end
, 1, 1, 0,
4166 doc
: /* Return the position at which OVERLAY ends. */)
4167 (Lisp_Object overlay
)
4169 CHECK_OVERLAY (overlay
);
4171 return (Fmarker_position (OVERLAY_END (overlay
)));
4174 DEFUN ("overlay-buffer", Foverlay_buffer
, Soverlay_buffer
, 1, 1, 0,
4175 doc
: /* Return the buffer OVERLAY belongs to.
4176 Return nil if OVERLAY has been deleted. */)
4177 (Lisp_Object overlay
)
4179 CHECK_OVERLAY (overlay
);
4181 return Fmarker_buffer (OVERLAY_START (overlay
));
4184 DEFUN ("overlay-properties", Foverlay_properties
, Soverlay_properties
, 1, 1, 0,
4185 doc
: /* Return a list of the properties on OVERLAY.
4186 This is a copy of OVERLAY's plist; modifying its conses has no effect on
4188 (Lisp_Object overlay
)
4190 CHECK_OVERLAY (overlay
);
4192 return Fcopy_sequence (XOVERLAY (overlay
)->plist
);
4196 DEFUN ("overlays-at", Foverlays_at
, Soverlays_at
, 1, 2, 0,
4197 doc
: /* Return a list of the overlays that contain the character at POS.
4198 If SORTED is non-nil, then sort them by decreasing priority. */)
4199 (Lisp_Object pos
, Lisp_Object sorted
)
4201 ptrdiff_t len
, noverlays
;
4202 Lisp_Object
*overlay_vec
;
4205 CHECK_NUMBER_COERCE_MARKER (pos
);
4207 if (!buffer_has_overlays ())
4211 /* We can't use alloca here because overlays_at can call xrealloc. */
4212 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4214 /* Put all the overlays we want in a vector in overlay_vec.
4215 Store the length in len. */
4216 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4220 noverlays
= sort_overlays (overlay_vec
, noverlays
,
4221 WINDOWP (sorted
) ? XWINDOW (sorted
) : NULL
);
4223 /* Make a list of them all. */
4224 result
= Flist (noverlays
, overlay_vec
);
4226 xfree (overlay_vec
);
4230 DEFUN ("overlays-in", Foverlays_in
, Soverlays_in
, 2, 2, 0,
4231 doc
: /* Return a list of the overlays that overlap the region BEG ... END.
4232 Overlap means that at least one character is contained within the overlay
4233 and also contained within the specified region.
4234 Empty overlays are included in the result if they are located at BEG,
4235 between BEG and END, or at END provided END denotes the position at the
4236 end of the buffer. */)
4237 (Lisp_Object beg
, Lisp_Object end
)
4239 ptrdiff_t len
, noverlays
;
4240 Lisp_Object
*overlay_vec
;
4243 CHECK_NUMBER_COERCE_MARKER (beg
);
4244 CHECK_NUMBER_COERCE_MARKER (end
);
4246 if (!buffer_has_overlays ())
4250 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4252 /* Put all the overlays we want in a vector in overlay_vec.
4253 Store the length in len. */
4254 noverlays
= overlays_in (XINT (beg
), XINT (end
), 1, &overlay_vec
, &len
,
4257 /* Make a list of them all. */
4258 result
= Flist (noverlays
, overlay_vec
);
4260 xfree (overlay_vec
);
4264 DEFUN ("next-overlay-change", Fnext_overlay_change
, Snext_overlay_change
,
4266 doc
: /* Return the next position after POS where an overlay starts or ends.
4267 If there are no overlay boundaries from POS to (point-max),
4268 the value is (point-max). */)
4271 ptrdiff_t i
, len
, noverlays
;
4273 Lisp_Object
*overlay_vec
;
4275 CHECK_NUMBER_COERCE_MARKER (pos
);
4277 if (!buffer_has_overlays ())
4278 return make_number (ZV
);
4281 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4283 /* Put all the overlays we want in a vector in overlay_vec.
4284 Store the length in len.
4285 endpos gets the position where the next overlay starts. */
4286 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4289 /* If any of these overlays ends before endpos,
4290 use its ending point instead. */
4291 for (i
= 0; i
< noverlays
; i
++)
4296 oend
= OVERLAY_END (overlay_vec
[i
]);
4297 oendpos
= OVERLAY_POSITION (oend
);
4298 if (oendpos
< endpos
)
4302 xfree (overlay_vec
);
4303 return make_number (endpos
);
4306 DEFUN ("previous-overlay-change", Fprevious_overlay_change
,
4307 Sprevious_overlay_change
, 1, 1, 0,
4308 doc
: /* Return the previous position before POS where an overlay starts or ends.
4309 If there are no overlay boundaries from (point-min) to POS,
4310 the value is (point-min). */)
4314 Lisp_Object
*overlay_vec
;
4317 CHECK_NUMBER_COERCE_MARKER (pos
);
4319 if (!buffer_has_overlays ())
4320 return make_number (BEGV
);
4322 /* At beginning of buffer, we know the answer;
4323 avoid bug subtracting 1 below. */
4324 if (XINT (pos
) == BEGV
)
4328 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4330 /* Put all the overlays we want in a vector in overlay_vec.
4331 Store the length in len.
4332 prevpos gets the position of the previous change. */
4333 overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4336 xfree (overlay_vec
);
4337 return make_number (prevpos
);
4340 /* These functions are for debugging overlays. */
4342 DEFUN ("overlay-lists", Foverlay_lists
, Soverlay_lists
, 0, 0, 0,
4343 doc
: /* Return a pair of lists giving all the overlays of the current buffer.
4344 The car has all the overlays before the overlay center;
4345 the cdr has all the overlays after the overlay center.
4346 Recentering overlays moves overlays between these lists.
4347 The lists you get are copies, so that changing them has no effect.
4348 However, the overlays you get are the real objects that the buffer uses. */)
4351 struct Lisp_Overlay
*ol
;
4352 Lisp_Object before
= Qnil
, after
= Qnil
, tmp
;
4354 for (ol
= current_buffer
->overlays_before
; ol
; ol
= ol
->next
)
4357 before
= Fcons (tmp
, before
);
4359 for (ol
= current_buffer
->overlays_after
; ol
; ol
= ol
->next
)
4362 after
= Fcons (tmp
, after
);
4365 return Fcons (Fnreverse (before
), Fnreverse (after
));
4368 DEFUN ("overlay-recenter", Foverlay_recenter
, Soverlay_recenter
, 1, 1, 0,
4369 doc
: /* Recenter the overlays of the current buffer around position POS.
4370 That makes overlay lookup faster for positions near POS (but perhaps slower
4371 for positions far away from POS). */)
4375 CHECK_NUMBER_COERCE_MARKER (pos
);
4377 p
= clip_to_bounds (PTRDIFF_MIN
, XINT (pos
), PTRDIFF_MAX
);
4378 recenter_overlay_lists (current_buffer
, p
);
4382 DEFUN ("overlay-get", Foverlay_get
, Soverlay_get
, 2, 2, 0,
4383 doc
: /* Get the property of overlay OVERLAY with property name PROP. */)
4384 (Lisp_Object overlay
, Lisp_Object prop
)
4386 CHECK_OVERLAY (overlay
);
4387 return lookup_char_property (XOVERLAY (overlay
)->plist
, prop
, 0);
4390 DEFUN ("overlay-put", Foverlay_put
, Soverlay_put
, 3, 3, 0,
4391 doc
: /* Set one property of overlay OVERLAY: give property PROP value VALUE.
4392 VALUE will be returned.*/)
4393 (Lisp_Object overlay
, Lisp_Object prop
, Lisp_Object value
)
4395 Lisp_Object tail
, buffer
;
4398 CHECK_OVERLAY (overlay
);
4400 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4402 for (tail
= XOVERLAY (overlay
)->plist
;
4403 CONSP (tail
) && CONSP (XCDR (tail
));
4404 tail
= XCDR (XCDR (tail
)))
4405 if (EQ (XCAR (tail
), prop
))
4407 changed
= !EQ (XCAR (XCDR (tail
)), value
);
4408 XSETCAR (XCDR (tail
), value
);
4411 /* It wasn't in the list, so add it to the front. */
4412 changed
= !NILP (value
);
4414 (overlay
, Fcons (prop
, Fcons (value
, XOVERLAY (overlay
)->plist
)));
4416 if (! NILP (buffer
))
4419 modify_overlay (XBUFFER (buffer
),
4420 marker_position (OVERLAY_START (overlay
)),
4421 marker_position (OVERLAY_END (overlay
)));
4422 if (EQ (prop
, Qevaporate
) && ! NILP (value
)
4423 && (OVERLAY_POSITION (OVERLAY_START (overlay
))
4424 == OVERLAY_POSITION (OVERLAY_END (overlay
))))
4425 Fdelete_overlay (overlay
);
4431 /* Subroutine of report_overlay_modification. */
4433 /* Lisp vector holding overlay hook functions to call.
4434 Vector elements come in pairs.
4435 Each even-index element is a list of hook functions.
4436 The following odd-index element is the overlay they came from.
4438 Before the buffer change, we fill in this vector
4439 as we call overlay hook functions.
4440 After the buffer change, we get the functions to call from this vector.
4441 This way we always call the same functions before and after the change. */
4442 static Lisp_Object last_overlay_modification_hooks
;
4444 /* Number of elements actually used in last_overlay_modification_hooks. */
4445 static ptrdiff_t last_overlay_modification_hooks_used
;
4447 /* Add one functionlist/overlay pair
4448 to the end of last_overlay_modification_hooks. */
4451 add_overlay_mod_hooklist (Lisp_Object functionlist
, Lisp_Object overlay
)
4453 ptrdiff_t oldsize
= ASIZE (last_overlay_modification_hooks
);
4455 if (oldsize
- 1 <= last_overlay_modification_hooks_used
)
4456 last_overlay_modification_hooks
=
4457 larger_vector (last_overlay_modification_hooks
, 2, -1);
4458 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4459 functionlist
); last_overlay_modification_hooks_used
++;
4460 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4461 overlay
); last_overlay_modification_hooks_used
++;
4464 /* Run the modification-hooks of overlays that include
4465 any part of the text in START to END.
4466 If this change is an insertion, also
4467 run the insert-before-hooks of overlay starting at END,
4468 and the insert-after-hooks of overlay ending at START.
4470 This is called both before and after the modification.
4471 AFTER is true when we call after the modification.
4473 ARG1, ARG2, ARG3 are arguments to pass to the hook functions.
4474 When AFTER is nonzero, they are the start position,
4475 the position after the inserted new text,
4476 and the length of deleted or replaced old text. */
4479 report_overlay_modification (Lisp_Object start
, Lisp_Object end
, bool after
,
4480 Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
)
4482 Lisp_Object prop
, overlay
;
4483 struct Lisp_Overlay
*tail
;
4484 /* True if this change is an insertion. */
4485 bool insertion
= (after
? XFASTINT (arg3
) == 0 : EQ (start
, end
));
4486 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4491 /* We used to run the functions as soon as we found them and only register
4492 them in last_overlay_modification_hooks for the purpose of the `after'
4493 case. But running elisp code as we traverse the list of overlays is
4494 painful because the list can be modified by the elisp code so we had to
4495 copy at several places. We now simply do a read-only traversal that
4496 only collects the functions to run and we run them afterwards. It's
4497 simpler, especially since all the code was already there. -stef */
4501 /* We are being called before a change.
4502 Scan the overlays to find the functions to call. */
4503 last_overlay_modification_hooks_used
= 0;
4504 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4506 ptrdiff_t startpos
, endpos
;
4507 Lisp_Object ostart
, oend
;
4509 XSETMISC (overlay
, tail
);
4511 ostart
= OVERLAY_START (overlay
);
4512 oend
= OVERLAY_END (overlay
);
4513 endpos
= OVERLAY_POSITION (oend
);
4514 if (XFASTINT (start
) > endpos
)
4516 startpos
= OVERLAY_POSITION (ostart
);
4517 if (insertion
&& (XFASTINT (start
) == startpos
4518 || XFASTINT (end
) == startpos
))
4520 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4522 add_overlay_mod_hooklist (prop
, overlay
);
4524 if (insertion
&& (XFASTINT (start
) == endpos
4525 || XFASTINT (end
) == endpos
))
4527 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4529 add_overlay_mod_hooklist (prop
, overlay
);
4531 /* Test for intersecting intervals. This does the right thing
4532 for both insertion and deletion. */
4533 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4535 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4537 add_overlay_mod_hooklist (prop
, overlay
);
4541 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4543 ptrdiff_t startpos
, endpos
;
4544 Lisp_Object ostart
, oend
;
4546 XSETMISC (overlay
, tail
);
4548 ostart
= OVERLAY_START (overlay
);
4549 oend
= OVERLAY_END (overlay
);
4550 startpos
= OVERLAY_POSITION (ostart
);
4551 endpos
= OVERLAY_POSITION (oend
);
4552 if (XFASTINT (end
) < startpos
)
4554 if (insertion
&& (XFASTINT (start
) == startpos
4555 || XFASTINT (end
) == startpos
))
4557 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4559 add_overlay_mod_hooklist (prop
, overlay
);
4561 if (insertion
&& (XFASTINT (start
) == endpos
4562 || XFASTINT (end
) == endpos
))
4564 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4566 add_overlay_mod_hooklist (prop
, overlay
);
4568 /* Test for intersecting intervals. This does the right thing
4569 for both insertion and deletion. */
4570 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4572 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4574 add_overlay_mod_hooklist (prop
, overlay
);
4579 GCPRO4 (overlay
, arg1
, arg2
, arg3
);
4581 /* Call the functions recorded in last_overlay_modification_hooks.
4582 First copy the vector contents, in case some of these hooks
4583 do subsequent modification of the buffer. */
4584 ptrdiff_t size
= last_overlay_modification_hooks_used
;
4585 Lisp_Object
*copy
= alloca (size
* sizeof *copy
);
4588 memcpy (copy
, XVECTOR (last_overlay_modification_hooks
)->contents
,
4591 gcpro1
.nvars
= size
;
4593 for (i
= 0; i
< size
;)
4595 Lisp_Object prop_i
, overlay_i
;
4597 overlay_i
= copy
[i
++];
4598 call_overlay_mod_hooks (prop_i
, overlay_i
, after
, arg1
, arg2
, arg3
);
4605 call_overlay_mod_hooks (Lisp_Object list
, Lisp_Object overlay
, bool after
,
4606 Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
)
4608 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4610 GCPRO4 (list
, arg1
, arg2
, arg3
);
4612 while (CONSP (list
))
4615 call4 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
);
4617 call5 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
, arg3
);
4623 /* Delete any zero-sized overlays at position POS, if the `evaporate'
4626 evaporate_overlays (ptrdiff_t pos
)
4628 Lisp_Object overlay
, hit_list
;
4629 struct Lisp_Overlay
*tail
;
4632 if (pos
<= current_buffer
->overlay_center
)
4633 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4636 XSETMISC (overlay
, tail
);
4637 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4640 if (endpos
== pos
&& OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
4641 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4642 hit_list
= Fcons (overlay
, hit_list
);
4645 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4648 XSETMISC (overlay
, tail
);
4649 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4652 if (startpos
== pos
&& OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
4653 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4654 hit_list
= Fcons (overlay
, hit_list
);
4656 for (; CONSP (hit_list
); hit_list
= XCDR (hit_list
))
4657 Fdelete_overlay (XCAR (hit_list
));
4660 /***********************************************************************
4661 Allocation with mmap
4662 ***********************************************************************/
4664 /* Note: WINDOWSNT implements this stuff on w32heap.c. */
4665 #if defined USE_MMAP_FOR_BUFFERS && !defined WINDOWSNT
4667 #include <sys/mman.h>
4670 #ifdef MAP_ANONYMOUS
4671 #define MAP_ANON MAP_ANONYMOUS
4678 #define MAP_FAILED ((void *) -1)
4688 /* Memory is allocated in regions which are mapped using mmap(2).
4689 The current implementation lets the system select mapped
4690 addresses; we're not using MAP_FIXED in general, except when
4691 trying to enlarge regions.
4693 Each mapped region starts with a mmap_region structure, the user
4694 area starts after that structure, aligned to MEM_ALIGN.
4696 +-----------------------+
4697 | struct mmap_info + |
4699 +-----------------------+
4703 +-----------------------+ */
4707 /* User-specified size. */
4708 size_t nbytes_specified
;
4710 /* Number of bytes mapped */
4711 size_t nbytes_mapped
;
4713 /* Pointer to the location holding the address of the memory
4714 allocated with the mmap'd block. The variable actually points
4715 after this structure. */
4718 /* Next and previous in list of all mmap'd regions. */
4719 struct mmap_region
*next
, *prev
;
4722 /* Doubly-linked list of mmap'd regions. */
4724 static struct mmap_region
*mmap_regions
;
4726 /* File descriptor for mmap. If we don't have anonymous mapping,
4727 /dev/zero will be opened on it. */
4731 /* Page size on this system. */
4733 static int mmap_page_size
;
4735 /* 1 means mmap has been initialized. */
4737 static bool mmap_initialized_p
;
4739 /* Value is X rounded up to the next multiple of N. */
4741 #define ROUND(X, N) (((X) + (N) - 1) / (N) * (N))
4743 /* Size of mmap_region structure plus padding. */
4745 #define MMAP_REGION_STRUCT_SIZE \
4746 ROUND (sizeof (struct mmap_region), MEM_ALIGN)
4748 /* Given a pointer P to the start of the user-visible part of a mapped
4749 region, return a pointer to the start of the region. */
4751 #define MMAP_REGION(P) \
4752 ((struct mmap_region *) ((char *) (P) - MMAP_REGION_STRUCT_SIZE))
4754 /* Given a pointer P to the start of a mapped region, return a pointer
4755 to the start of the user-visible part of the region. */
4757 #define MMAP_USER_AREA(P) \
4758 ((void *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
4760 #define MEM_ALIGN sizeof (double)
4762 /* Predicate returning true if part of the address range [START .. END]
4763 is currently mapped. Used to prevent overwriting an existing
4766 Default is to conservatively assume the address range is occupied by
4767 something else. This can be overridden by system configuration
4768 files if system-specific means to determine this exists. */
4770 #ifndef MMAP_ALLOCATED_P
4771 #define MMAP_ALLOCATED_P(start, end) 1
4774 /* Perform necessary initializations for the use of mmap. */
4780 /* The value of mmap_fd is initially 0 in temacs, and -1
4781 in a dumped Emacs. */
4784 /* No anonymous mmap -- we need the file descriptor. */
4785 mmap_fd
= emacs_open ("/dev/zero", O_RDONLY
, 0);
4787 fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno
));
4789 #endif /* MAP_ANON == 0 */
4791 if (mmap_initialized_p
)
4793 mmap_initialized_p
= 1;
4799 mmap_page_size
= getpagesize ();
4802 /* Unmap a region. P is a pointer to the start of the user-araa of
4806 mmap_free_1 (struct mmap_region
*r
)
4809 r
->next
->prev
= r
->prev
;
4811 r
->prev
->next
= r
->next
;
4813 mmap_regions
= r
->next
;
4815 if (munmap (r
, r
->nbytes_mapped
) == -1)
4816 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4820 /* Enlarge region R by NPAGES pages. NPAGES < 0 means shrink R.
4821 Value is true if successful. */
4824 mmap_enlarge (struct mmap_region
*r
, int npages
)
4826 char *region_end
= (char *) r
+ r
->nbytes_mapped
;
4832 /* Unmap pages at the end of the region. */
4833 nbytes
= - npages
* mmap_page_size
;
4834 if (munmap (region_end
- nbytes
, nbytes
) == -1)
4835 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4838 r
->nbytes_mapped
-= nbytes
;
4842 else if (npages
> 0)
4844 nbytes
= npages
* mmap_page_size
;
4846 /* Try to map additional pages at the end of the region. We
4847 cannot do this if the address range is already occupied by
4848 something else because mmap deletes any previous mapping.
4849 I'm not sure this is worth doing, let's see. */
4850 if (!MMAP_ALLOCATED_P (region_end
, region_end
+ nbytes
))
4854 p
= mmap (region_end
, nbytes
, PROT_READ
| PROT_WRITE
,
4855 MAP_ANON
| MAP_PRIVATE
| MAP_FIXED
, mmap_fd
, 0);
4856 if (p
== MAP_FAILED
)
4857 ; /* fprintf (stderr, "mmap: %s\n", emacs_strerror (errno)); */
4858 else if (p
!= region_end
)
4860 /* Kernels are free to choose a different address. In
4861 that case, unmap what we've mapped above; we have
4863 if (munmap (p
, nbytes
) == -1)
4864 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4868 r
->nbytes_mapped
+= nbytes
;
4878 /* Allocate a block of storage large enough to hold NBYTES bytes of
4879 data. A pointer to the data is returned in *VAR. VAR is thus the
4880 address of some variable which will use the data area.
4882 The allocation of 0 bytes is valid.
4884 If we can't allocate the necessary memory, set *VAR to null, and
4888 mmap_alloc (void **var
, size_t nbytes
)
4895 map
= ROUND (nbytes
+ MMAP_REGION_STRUCT_SIZE
, mmap_page_size
);
4896 p
= mmap (NULL
, map
, PROT_READ
| PROT_WRITE
, MAP_ANON
| MAP_PRIVATE
,
4899 if (p
== MAP_FAILED
)
4901 if (errno
!= ENOMEM
)
4902 fprintf (stderr
, "mmap: %s\n", emacs_strerror (errno
));
4907 struct mmap_region
*r
= p
;
4909 r
->nbytes_specified
= nbytes
;
4910 r
->nbytes_mapped
= map
;
4913 r
->next
= mmap_regions
;
4918 p
= MMAP_USER_AREA (p
);
4925 /* Free a block of relocatable storage whose data is pointed to by
4926 PTR. Store 0 in *PTR to show there's no block allocated. */
4929 mmap_free (void **var
)
4935 mmap_free_1 (MMAP_REGION (*var
));
4941 /* Given a pointer at address VAR to data allocated with mmap_alloc,
4942 resize it to size NBYTES. Change *VAR to reflect the new block,
4943 and return this value. If more memory cannot be allocated, then
4944 leave *VAR unchanged, and return null. */
4947 mmap_realloc (void **var
, size_t nbytes
)
4954 result
= mmap_alloc (var
, nbytes
);
4955 else if (nbytes
== 0)
4958 result
= mmap_alloc (var
, nbytes
);
4962 struct mmap_region
*r
= MMAP_REGION (*var
);
4963 size_t room
= r
->nbytes_mapped
- MMAP_REGION_STRUCT_SIZE
;
4968 void *old_ptr
= *var
;
4970 /* Try to map additional pages at the end of the region.
4971 If that fails, allocate a new region, copy data
4972 from the old region, then free it. */
4973 if (mmap_enlarge (r
, (ROUND (nbytes
- room
, mmap_page_size
)
4976 r
->nbytes_specified
= nbytes
;
4977 *var
= result
= old_ptr
;
4979 else if (mmap_alloc (var
, nbytes
))
4981 memcpy (*var
, old_ptr
, r
->nbytes_specified
);
4982 mmap_free_1 (MMAP_REGION (old_ptr
));
4984 r
= MMAP_REGION (result
);
4985 r
->nbytes_specified
= nbytes
;
4993 else if (room
- nbytes
>= mmap_page_size
)
4995 /* Shrinking by at least a page. Let's give some
4996 memory back to the system.
4998 The extra parens are to make the division happens first,
4999 on positive values, so we know it will round towards
5001 mmap_enlarge (r
, - ((room
- nbytes
) / mmap_page_size
));
5003 r
->nbytes_specified
= nbytes
;
5007 /* Leave it alone. */
5009 r
->nbytes_specified
= nbytes
;
5017 #endif /* USE_MMAP_FOR_BUFFERS */
5021 /***********************************************************************
5022 Buffer-text Allocation
5023 ***********************************************************************/
5025 /* Allocate NBYTES bytes for buffer B's text buffer. */
5028 alloc_buffer_text (struct buffer
*b
, ptrdiff_t nbytes
)
5033 #if defined USE_MMAP_FOR_BUFFERS
5034 p
= mmap_alloc ((void **) &b
->text
->beg
, nbytes
);
5035 #elif defined REL_ALLOC
5036 p
= r_alloc ((void **) &b
->text
->beg
, nbytes
);
5038 p
= xmalloc (nbytes
);
5044 memory_full (nbytes
);
5051 /* Enlarge buffer B's text buffer by DELTA bytes. DELTA < 0 means
5055 enlarge_buffer_text (struct buffer
*b
, ptrdiff_t delta
)
5058 ptrdiff_t nbytes
= (BUF_Z_BYTE (b
) - BUF_BEG_BYTE (b
) + BUF_GAP_SIZE (b
) + 1
5061 #if defined USE_MMAP_FOR_BUFFERS
5062 p
= mmap_realloc ((void **) &b
->text
->beg
, nbytes
);
5063 #elif defined REL_ALLOC
5064 p
= r_re_alloc ((void **) &b
->text
->beg
, nbytes
);
5066 p
= xrealloc (b
->text
->beg
, nbytes
);
5072 memory_full (nbytes
);
5075 BUF_BEG_ADDR (b
) = p
;
5080 /* Free buffer B's text buffer. */
5083 free_buffer_text (struct buffer
*b
)
5087 #if defined USE_MMAP_FOR_BUFFERS
5088 mmap_free ((void **) &b
->text
->beg
);
5089 #elif defined REL_ALLOC
5090 r_alloc_free ((void **) &b
->text
->beg
);
5092 xfree (b
->text
->beg
);
5095 BUF_BEG_ADDR (b
) = NULL
;
5101 /***********************************************************************
5103 ***********************************************************************/
5106 init_buffer_once (void)
5110 memset (buffer_permanent_local_flags
, 0, sizeof buffer_permanent_local_flags
);
5112 /* Make sure all markable slots in buffer_defaults
5113 are initialized reasonably, so mark_buffer won't choke. */
5114 reset_buffer (&buffer_defaults
);
5115 eassert (EQ (BVAR (&buffer_defaults
, name
), make_number (0)));
5116 reset_buffer_local_variables (&buffer_defaults
, 1);
5117 eassert (EQ (BVAR (&buffer_local_symbols
, name
), make_number (0)));
5118 reset_buffer (&buffer_local_symbols
);
5119 reset_buffer_local_variables (&buffer_local_symbols
, 1);
5120 /* Prevent GC from getting confused. */
5121 buffer_defaults
.text
= &buffer_defaults
.own_text
;
5122 buffer_local_symbols
.text
= &buffer_local_symbols
.own_text
;
5123 /* No one will share the text with these buffers, but let's play it safe. */
5124 buffer_defaults
.indirections
= 0;
5125 buffer_local_symbols
.indirections
= 0;
5126 /* Likewise no one will display them. */
5127 buffer_defaults
.window_count
= 0;
5128 buffer_local_symbols
.window_count
= 0;
5129 set_buffer_intervals (&buffer_defaults
, NULL
);
5130 set_buffer_intervals (&buffer_local_symbols
, NULL
);
5131 /* This is not strictly necessary, but let's make them initialized. */
5132 bset_name (&buffer_defaults
, build_pure_c_string (" *buffer-defaults*"));
5133 bset_name (&buffer_local_symbols
, build_pure_c_string (" *buffer-local-symbols*"));
5134 BUFFER_PVEC_INIT (&buffer_defaults
);
5135 BUFFER_PVEC_INIT (&buffer_local_symbols
);
5137 /* Set up the default values of various buffer slots. */
5138 /* Must do these before making the first buffer! */
5140 /* real setup is done in bindings.el */
5141 bset_mode_line_format (&buffer_defaults
, build_pure_c_string ("%-"));
5142 bset_header_line_format (&buffer_defaults
, Qnil
);
5143 bset_abbrev_mode (&buffer_defaults
, Qnil
);
5144 bset_overwrite_mode (&buffer_defaults
, Qnil
);
5145 bset_case_fold_search (&buffer_defaults
, Qt
);
5146 bset_auto_fill_function (&buffer_defaults
, Qnil
);
5147 bset_selective_display (&buffer_defaults
, Qnil
);
5148 bset_selective_display_ellipses (&buffer_defaults
, Qt
);
5149 bset_abbrev_table (&buffer_defaults
, Qnil
);
5150 bset_display_table (&buffer_defaults
, Qnil
);
5151 bset_undo_list (&buffer_defaults
, Qnil
);
5152 bset_mark_active (&buffer_defaults
, Qnil
);
5153 bset_file_format (&buffer_defaults
, Qnil
);
5154 bset_auto_save_file_format (&buffer_defaults
, Qt
);
5155 set_buffer_overlays_before (&buffer_defaults
, NULL
);
5156 set_buffer_overlays_after (&buffer_defaults
, NULL
);
5157 buffer_defaults
.overlay_center
= BEG
;
5159 XSETFASTINT (BVAR (&buffer_defaults
, tab_width
), 8);
5160 bset_truncate_lines (&buffer_defaults
, Qnil
);
5161 bset_word_wrap (&buffer_defaults
, Qnil
);
5162 bset_ctl_arrow (&buffer_defaults
, Qt
);
5163 bset_bidi_display_reordering (&buffer_defaults
, Qt
);
5164 bset_bidi_paragraph_direction (&buffer_defaults
, Qnil
);
5165 bset_cursor_type (&buffer_defaults
, Qt
);
5166 bset_extra_line_spacing (&buffer_defaults
, Qnil
);
5167 bset_cursor_in_non_selected_windows (&buffer_defaults
, Qt
);
5169 bset_enable_multibyte_characters (&buffer_defaults
, Qt
);
5170 bset_buffer_file_coding_system (&buffer_defaults
, Qnil
);
5171 XSETFASTINT (BVAR (&buffer_defaults
, fill_column
), 70);
5172 XSETFASTINT (BVAR (&buffer_defaults
, left_margin
), 0);
5173 bset_cache_long_scans (&buffer_defaults
, Qt
);
5174 bset_file_truename (&buffer_defaults
, Qnil
);
5175 XSETFASTINT (BVAR (&buffer_defaults
, display_count
), 0);
5176 XSETFASTINT (BVAR (&buffer_defaults
, left_margin_cols
), 0);
5177 XSETFASTINT (BVAR (&buffer_defaults
, right_margin_cols
), 0);
5178 bset_left_fringe_width (&buffer_defaults
, Qnil
);
5179 bset_right_fringe_width (&buffer_defaults
, Qnil
);
5180 bset_fringes_outside_margins (&buffer_defaults
, Qnil
);
5181 bset_scroll_bar_width (&buffer_defaults
, Qnil
);
5182 bset_scroll_bar_height (&buffer_defaults
, Qnil
);
5183 bset_vertical_scroll_bar_type (&buffer_defaults
, Qt
);
5184 bset_horizontal_scroll_bar_type (&buffer_defaults
, Qt
);
5185 bset_indicate_empty_lines (&buffer_defaults
, Qnil
);
5186 bset_indicate_buffer_boundaries (&buffer_defaults
, Qnil
);
5187 bset_fringe_indicator_alist (&buffer_defaults
, Qnil
);
5188 bset_fringe_cursor_alist (&buffer_defaults
, Qnil
);
5189 bset_scroll_up_aggressively (&buffer_defaults
, Qnil
);
5190 bset_scroll_down_aggressively (&buffer_defaults
, Qnil
);
5191 bset_display_time (&buffer_defaults
, Qnil
);
5193 /* Assign the local-flags to the slots that have default values.
5194 The local flag is a bit that is used in the buffer
5195 to say that it has its own local value for the slot.
5196 The local flag bits are in the local_var_flags slot of the buffer. */
5198 /* Nothing can work if this isn't true */
5199 { verify (sizeof (EMACS_INT
) == word_size
); }
5201 /* 0 means not a lisp var, -1 means always local, else mask */
5202 memset (&buffer_local_flags
, 0, sizeof buffer_local_flags
);
5203 bset_filename (&buffer_local_flags
, make_number (-1));
5204 bset_directory (&buffer_local_flags
, make_number (-1));
5205 bset_backed_up (&buffer_local_flags
, make_number (-1));
5206 bset_save_length (&buffer_local_flags
, make_number (-1));
5207 bset_auto_save_file_name (&buffer_local_flags
, make_number (-1));
5208 bset_read_only (&buffer_local_flags
, make_number (-1));
5209 bset_major_mode (&buffer_local_flags
, make_number (-1));
5210 bset_mode_name (&buffer_local_flags
, make_number (-1));
5211 bset_undo_list (&buffer_local_flags
, make_number (-1));
5212 bset_mark_active (&buffer_local_flags
, make_number (-1));
5213 bset_point_before_scroll (&buffer_local_flags
, make_number (-1));
5214 bset_file_truename (&buffer_local_flags
, make_number (-1));
5215 bset_invisibility_spec (&buffer_local_flags
, make_number (-1));
5216 bset_file_format (&buffer_local_flags
, make_number (-1));
5217 bset_auto_save_file_format (&buffer_local_flags
, make_number (-1));
5218 bset_display_count (&buffer_local_flags
, make_number (-1));
5219 bset_display_time (&buffer_local_flags
, make_number (-1));
5220 bset_enable_multibyte_characters (&buffer_local_flags
, make_number (-1));
5223 XSETFASTINT (BVAR (&buffer_local_flags
, mode_line_format
), idx
); ++idx
;
5224 XSETFASTINT (BVAR (&buffer_local_flags
, abbrev_mode
), idx
); ++idx
;
5225 XSETFASTINT (BVAR (&buffer_local_flags
, overwrite_mode
), idx
); ++idx
;
5226 XSETFASTINT (BVAR (&buffer_local_flags
, case_fold_search
), idx
); ++idx
;
5227 XSETFASTINT (BVAR (&buffer_local_flags
, auto_fill_function
), idx
); ++idx
;
5228 XSETFASTINT (BVAR (&buffer_local_flags
, selective_display
), idx
); ++idx
;
5229 XSETFASTINT (BVAR (&buffer_local_flags
, selective_display_ellipses
), idx
); ++idx
;
5230 XSETFASTINT (BVAR (&buffer_local_flags
, tab_width
), idx
); ++idx
;
5231 XSETFASTINT (BVAR (&buffer_local_flags
, truncate_lines
), idx
); ++idx
;
5232 XSETFASTINT (BVAR (&buffer_local_flags
, word_wrap
), idx
); ++idx
;
5233 XSETFASTINT (BVAR (&buffer_local_flags
, ctl_arrow
), idx
); ++idx
;
5234 XSETFASTINT (BVAR (&buffer_local_flags
, fill_column
), idx
); ++idx
;
5235 XSETFASTINT (BVAR (&buffer_local_flags
, left_margin
), idx
); ++idx
;
5236 XSETFASTINT (BVAR (&buffer_local_flags
, abbrev_table
), idx
); ++idx
;
5237 XSETFASTINT (BVAR (&buffer_local_flags
, display_table
), idx
); ++idx
;
5238 XSETFASTINT (BVAR (&buffer_local_flags
, syntax_table
), idx
); ++idx
;
5239 XSETFASTINT (BVAR (&buffer_local_flags
, cache_long_scans
), idx
); ++idx
;
5240 XSETFASTINT (BVAR (&buffer_local_flags
, category_table
), idx
); ++idx
;
5241 XSETFASTINT (BVAR (&buffer_local_flags
, bidi_display_reordering
), idx
); ++idx
;
5242 XSETFASTINT (BVAR (&buffer_local_flags
, bidi_paragraph_direction
), idx
); ++idx
;
5243 XSETFASTINT (BVAR (&buffer_local_flags
, buffer_file_coding_system
), idx
);
5244 /* Make this one a permanent local. */
5245 buffer_permanent_local_flags
[idx
++] = 1;
5246 XSETFASTINT (BVAR (&buffer_local_flags
, left_margin_cols
), idx
); ++idx
;
5247 XSETFASTINT (BVAR (&buffer_local_flags
, right_margin_cols
), idx
); ++idx
;
5248 XSETFASTINT (BVAR (&buffer_local_flags
, left_fringe_width
), idx
); ++idx
;
5249 XSETFASTINT (BVAR (&buffer_local_flags
, right_fringe_width
), idx
); ++idx
;
5250 XSETFASTINT (BVAR (&buffer_local_flags
, fringes_outside_margins
), idx
); ++idx
;
5251 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_bar_width
), idx
); ++idx
;
5252 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_bar_height
), idx
); ++idx
;
5253 XSETFASTINT (BVAR (&buffer_local_flags
, vertical_scroll_bar_type
), idx
); ++idx
;
5254 XSETFASTINT (BVAR (&buffer_local_flags
, horizontal_scroll_bar_type
), idx
); ++idx
;
5255 XSETFASTINT (BVAR (&buffer_local_flags
, indicate_empty_lines
), idx
); ++idx
;
5256 XSETFASTINT (BVAR (&buffer_local_flags
, indicate_buffer_boundaries
), idx
); ++idx
;
5257 XSETFASTINT (BVAR (&buffer_local_flags
, fringe_indicator_alist
), idx
); ++idx
;
5258 XSETFASTINT (BVAR (&buffer_local_flags
, fringe_cursor_alist
), idx
); ++idx
;
5259 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_up_aggressively
), idx
); ++idx
;
5260 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_down_aggressively
), idx
); ++idx
;
5261 XSETFASTINT (BVAR (&buffer_local_flags
, header_line_format
), idx
); ++idx
;
5262 XSETFASTINT (BVAR (&buffer_local_flags
, cursor_type
), idx
); ++idx
;
5263 XSETFASTINT (BVAR (&buffer_local_flags
, extra_line_spacing
), idx
); ++idx
;
5264 XSETFASTINT (BVAR (&buffer_local_flags
, cursor_in_non_selected_windows
), idx
); ++idx
;
5266 /* Need more room? */
5267 if (idx
>= MAX_PER_BUFFER_VARS
)
5269 last_per_buffer_idx
= idx
;
5271 Vbuffer_alist
= Qnil
;
5275 QSFundamental
= build_pure_c_string ("Fundamental");
5277 Qfundamental_mode
= intern_c_string ("fundamental-mode");
5278 bset_major_mode (&buffer_defaults
, Qfundamental_mode
);
5280 Qmode_class
= intern_c_string ("mode-class");
5282 Qprotected_field
= intern_c_string ("protected-field");
5284 Qpermanent_local
= intern_c_string ("permanent-local");
5286 Qkill_buffer_hook
= intern_c_string ("kill-buffer-hook");
5287 Fput (Qkill_buffer_hook
, Qpermanent_local
, Qt
);
5289 /* super-magic invisible buffer */
5290 Vprin1_to_string_buffer
= Fget_buffer_create (build_pure_c_string (" prin1"));
5291 Vbuffer_alist
= Qnil
;
5293 Fset_buffer (Fget_buffer_create (build_pure_c_string ("*scratch*")));
5295 inhibit_modification_hooks
= 0;
5299 init_buffer (int initialized
)
5305 #ifdef USE_MMAP_FOR_BUFFERS
5311 /* These must be reset in the dumped Emacs, to avoid stale
5312 references to mmap'ed memory from before the dump.
5314 WINDOWSNT doesn't need this because it doesn't track mmap'ed
5315 regions by hand (see w32heap.c, which uses system APIs for
5316 that purpose), and thus doesn't use mmap_regions. */
5317 mmap_regions
= NULL
;
5321 /* The dumped buffers reference addresses of buffer text
5322 recorded by temacs, that cannot be used by the dumped Emacs.
5323 We map new memory for their text here.
5325 Implementation note: the buffers we carry from temacs are:
5326 " prin1", "*scratch*", " *Minibuf-0*", "*Messages*", and
5327 " *code-conversion-work*". They are created by
5328 init_buffer_once and init_window_once (which are not called
5329 in the dumped Emacs), and by the first call to coding.c routines. */
5332 b
->text
->beg
= NULL
;
5333 enlarge_buffer_text (b
, 0);
5340 /* Only buffers with allocated buffer text should be present at
5341 this point in temacs. */
5344 eassert (b
->text
->beg
!= NULL
);
5347 #else /* not USE_MMAP_FOR_BUFFERS */
5348 /* Avoid compiler warnings. */
5349 initialized
= initialized
;
5350 #endif /* USE_MMAP_FOR_BUFFERS */
5352 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
5353 if (NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
)))
5354 Fset_buffer_multibyte (Qnil
);
5356 pwd
= get_current_dir_name ();
5359 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5361 /* Maybe this should really use some standard subroutine
5362 whose definition is filename syntax dependent. */
5364 if (!(IS_DIRECTORY_SEP (pwd
[len
- 1])))
5366 /* Grow buffer to add directory separator and '\0'. */
5367 pwd
= realloc (pwd
, len
+ 2);
5369 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5370 pwd
[len
] = DIRECTORY_SEP
;
5371 pwd
[len
+ 1] = '\0';
5375 /* At this moment, we still don't know how to decode the directory
5376 name. So, we keep the bytes in unibyte form so that file I/O
5377 routines correctly get the original bytes. */
5378 bset_directory (current_buffer
, make_unibyte_string (pwd
, len
));
5380 /* Add /: to the front of the name
5381 if it would otherwise be treated as magic. */
5382 temp
= Ffind_file_name_handler (BVAR (current_buffer
, directory
), Qt
);
5384 /* If the default dir is just /, TEMP is non-nil
5385 because of the ange-ftp completion handler.
5386 However, it is not necessary to turn / into /:/.
5387 So avoid doing that. */
5388 && strcmp ("/", SSDATA (BVAR (current_buffer
, directory
))))
5391 concat2 (build_string ("/:"), BVAR (current_buffer
, directory
)));
5393 temp
= get_minibuffer (0);
5394 bset_directory (XBUFFER (temp
), BVAR (current_buffer
, directory
));
5399 /* Similar to defvar_lisp but define a variable whose value is the
5400 Lisp_Object stored in the current buffer. LNAME is the Lisp-level
5401 variable name. VNAME is the name of the buffer slot. PREDICATE
5402 is nil for a general Lisp variable. If PREDICATE is non-nil, then
5403 only Lisp values that satisfies the PREDICATE are allowed (except
5404 that nil is allowed too). DOC is a dummy where you write the doc
5405 string as a comment. */
5407 #define DEFVAR_PER_BUFFER(lname, vname, predicate, doc) \
5409 static struct Lisp_Buffer_Objfwd bo_fwd; \
5410 defvar_per_buffer (&bo_fwd, lname, vname, predicate); \
5414 defvar_per_buffer (struct Lisp_Buffer_Objfwd
*bo_fwd
, const char *namestring
,
5415 Lisp_Object
*address
, Lisp_Object predicate
)
5417 struct Lisp_Symbol
*sym
;
5420 sym
= XSYMBOL (intern (namestring
));
5421 offset
= (char *)address
- (char *)current_buffer
;
5423 bo_fwd
->type
= Lisp_Fwd_Buffer_Obj
;
5424 bo_fwd
->offset
= offset
;
5425 bo_fwd
->predicate
= predicate
;
5426 sym
->declared_special
= 1;
5427 sym
->redirect
= SYMBOL_FORWARDED
;
5428 SET_SYMBOL_FWD (sym
, (union Lisp_Fwd
*) bo_fwd
);
5429 XSETSYMBOL (PER_BUFFER_SYMBOL (offset
), sym
);
5431 if (PER_BUFFER_IDX (offset
) == 0)
5432 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
5433 slot of buffer_local_flags. */
5438 /* Initialize the buffer routines. */
5440 syms_of_buffer (void)
5442 staticpro (&last_overlay_modification_hooks
);
5443 last_overlay_modification_hooks
5444 = Fmake_vector (make_number (10), Qnil
);
5446 staticpro (&Qfundamental_mode
);
5447 staticpro (&Qmode_class
);
5448 staticpro (&QSFundamental
);
5449 staticpro (&Vbuffer_alist
);
5450 staticpro (&Qprotected_field
);
5451 staticpro (&Qpermanent_local
);
5452 staticpro (&Qkill_buffer_hook
);
5454 DEFSYM (Qleft
, "left");
5455 DEFSYM (Qright
, "right");
5456 DEFSYM (Qrange
, "range");
5458 DEFSYM (Qpermanent_local_hook
, "permanent-local-hook");
5459 DEFSYM (Qoverlayp
, "overlayp");
5460 DEFSYM (Qevaporate
, "evaporate");
5461 DEFSYM (Qmodification_hooks
, "modification-hooks");
5462 DEFSYM (Qinsert_in_front_hooks
, "insert-in-front-hooks");
5463 DEFSYM (Qinsert_behind_hooks
, "insert-behind-hooks");
5464 DEFSYM (Qget_file_buffer
, "get-file-buffer");
5465 DEFSYM (Qpriority
, "priority");
5466 DEFSYM (Qbefore_string
, "before-string");
5467 DEFSYM (Qafter_string
, "after-string");
5468 DEFSYM (Qfirst_change_hook
, "first-change-hook");
5469 DEFSYM (Qbefore_change_functions
, "before-change-functions");
5470 DEFSYM (Qafter_change_functions
, "after-change-functions");
5471 DEFSYM (Qkill_buffer_query_functions
, "kill-buffer-query-functions");
5473 DEFSYM (Qvertical_scroll_bar
, "vertical-scroll-bar");
5474 Fput (Qvertical_scroll_bar
, Qchoice
, list4 (Qnil
, Qt
, Qleft
, Qright
));
5475 DEFSYM (Qhorizontal_scroll_bar
, "horizontal-scroll-bar");
5477 DEFSYM (Qfraction
, "fraction");
5478 Fput (Qfraction
, Qrange
, Fcons (make_float (0.0), make_float (1.0)));
5480 DEFSYM (Qoverwrite_mode
, "overwrite-mode");
5481 Fput (Qoverwrite_mode
, Qchoice
,
5482 list3 (Qnil
, intern ("overwrite-mode-textual"),
5483 intern ("overwrite-mode-binary")));
5485 Fput (Qprotected_field
, Qerror_conditions
,
5486 listn (CONSTYPE_PURE
, 2, Qprotected_field
, Qerror
));
5487 Fput (Qprotected_field
, Qerror_message
,
5488 build_pure_c_string ("Attempt to modify a protected field"));
5490 DEFVAR_BUFFER_DEFAULTS ("default-mode-line-format",
5492 doc
: /* Default value of `mode-line-format' for buffers that don't override it.
5493 This is the same as (default-value 'mode-line-format). */);
5495 DEFVAR_BUFFER_DEFAULTS ("default-header-line-format",
5497 doc
: /* Default value of `header-line-format' for buffers that don't override it.
5498 This is the same as (default-value 'header-line-format). */);
5500 DEFVAR_BUFFER_DEFAULTS ("default-cursor-type", cursor_type
,
5501 doc
: /* Default value of `cursor-type' for buffers that don't override it.
5502 This is the same as (default-value 'cursor-type). */);
5504 DEFVAR_BUFFER_DEFAULTS ("default-line-spacing",
5506 doc
: /* Default value of `line-spacing' for buffers that don't override it.
5507 This is the same as (default-value 'line-spacing). */);
5509 DEFVAR_BUFFER_DEFAULTS ("default-cursor-in-non-selected-windows",
5510 cursor_in_non_selected_windows
,
5511 doc
: /* Default value of `cursor-in-non-selected-windows'.
5512 This is the same as (default-value 'cursor-in-non-selected-windows). */);
5514 DEFVAR_BUFFER_DEFAULTS ("default-abbrev-mode",
5516 doc
: /* Default value of `abbrev-mode' for buffers that do not override it.
5517 This is the same as (default-value 'abbrev-mode). */);
5519 DEFVAR_BUFFER_DEFAULTS ("default-ctl-arrow",
5521 doc
: /* Default value of `ctl-arrow' for buffers that do not override it.
5522 This is the same as (default-value 'ctl-arrow). */);
5524 DEFVAR_BUFFER_DEFAULTS ("default-enable-multibyte-characters",
5525 enable_multibyte_characters
,
5526 doc
: /* Default value of `enable-multibyte-characters' for buffers not overriding it.
5527 This is the same as (default-value 'enable-multibyte-characters). */);
5529 DEFVAR_BUFFER_DEFAULTS ("default-buffer-file-coding-system",
5530 buffer_file_coding_system
,
5531 doc
: /* Default value of `buffer-file-coding-system' for buffers not overriding it.
5532 This is the same as (default-value 'buffer-file-coding-system). */);
5534 DEFVAR_BUFFER_DEFAULTS ("default-truncate-lines",
5536 doc
: /* Default value of `truncate-lines' for buffers that do not override it.
5537 This is the same as (default-value 'truncate-lines). */);
5539 DEFVAR_BUFFER_DEFAULTS ("default-fill-column",
5541 doc
: /* Default value of `fill-column' for buffers that do not override it.
5542 This is the same as (default-value 'fill-column). */);
5544 DEFVAR_BUFFER_DEFAULTS ("default-left-margin",
5546 doc
: /* Default value of `left-margin' for buffers that do not override it.
5547 This is the same as (default-value 'left-margin). */);
5549 DEFVAR_BUFFER_DEFAULTS ("default-tab-width",
5551 doc
: /* Default value of `tab-width' for buffers that do not override it.
5552 NOTE: This controls the display width of a TAB character, and not
5553 the size of an indentation step.
5554 This is the same as (default-value 'tab-width). */);
5556 DEFVAR_BUFFER_DEFAULTS ("default-case-fold-search",
5558 doc
: /* Default value of `case-fold-search' for buffers that don't override it.
5559 This is the same as (default-value 'case-fold-search). */);
5561 DEFVAR_BUFFER_DEFAULTS ("default-left-margin-width",
5563 doc
: /* Default value of `left-margin-width' for buffers that don't override it.
5564 This is the same as (default-value 'left-margin-width). */);
5566 DEFVAR_BUFFER_DEFAULTS ("default-right-margin-width",
5568 doc
: /* Default value of `right-margin-width' for buffers that don't override it.
5569 This is the same as (default-value 'right-margin-width). */);
5571 DEFVAR_BUFFER_DEFAULTS ("default-left-fringe-width",
5573 doc
: /* Default value of `left-fringe-width' for buffers that don't override it.
5574 This is the same as (default-value 'left-fringe-width). */);
5576 DEFVAR_BUFFER_DEFAULTS ("default-right-fringe-width",
5578 doc
: /* Default value of `right-fringe-width' for buffers that don't override it.
5579 This is the same as (default-value 'right-fringe-width). */);
5581 DEFVAR_BUFFER_DEFAULTS ("default-fringes-outside-margins",
5582 fringes_outside_margins
,
5583 doc
: /* Default value of `fringes-outside-margins' for buffers that don't override it.
5584 This is the same as (default-value 'fringes-outside-margins). */);
5586 DEFVAR_BUFFER_DEFAULTS ("default-scroll-bar-width",
5588 doc
: /* Default value of `scroll-bar-width' for buffers that don't override it.
5589 This is the same as (default-value 'scroll-bar-width). */);
5591 DEFVAR_BUFFER_DEFAULTS ("default-vertical-scroll-bar",
5592 vertical_scroll_bar_type
,
5593 doc
: /* Default value of `vertical-scroll-bar' for buffers that don't override it.
5594 This is the same as (default-value 'vertical-scroll-bar). */);
5596 DEFVAR_BUFFER_DEFAULTS ("default-indicate-empty-lines",
5597 indicate_empty_lines
,
5598 doc
: /* Default value of `indicate-empty-lines' for buffers that don't override it.
5599 This is the same as (default-value 'indicate-empty-lines). */);
5601 DEFVAR_BUFFER_DEFAULTS ("default-indicate-buffer-boundaries",
5602 indicate_buffer_boundaries
,
5603 doc
: /* Default value of `indicate-buffer-boundaries' for buffers that don't override it.
5604 This is the same as (default-value 'indicate-buffer-boundaries). */);
5606 DEFVAR_BUFFER_DEFAULTS ("default-fringe-indicator-alist",
5607 fringe_indicator_alist
,
5608 doc
: /* Default value of `fringe-indicator-alist' for buffers that don't override it.
5609 This is the same as (default-value 'fringe-indicator-alist'). */);
5611 DEFVAR_BUFFER_DEFAULTS ("default-fringe-cursor-alist",
5612 fringe_cursor_alist
,
5613 doc
: /* Default value of `fringe-cursor-alist' for buffers that don't override it.
5614 This is the same as (default-value 'fringe-cursor-alist'). */);
5616 DEFVAR_BUFFER_DEFAULTS ("default-scroll-up-aggressively",
5617 scroll_up_aggressively
,
5618 doc
: /* Default value of `scroll-up-aggressively'.
5619 This value applies in buffers that don't have their own local values.
5620 This is the same as (default-value 'scroll-up-aggressively). */);
5622 DEFVAR_BUFFER_DEFAULTS ("default-scroll-down-aggressively",
5623 scroll_down_aggressively
,
5624 doc
: /* Default value of `scroll-down-aggressively'.
5625 This value applies in buffers that don't have their own local values.
5626 This is the same as (default-value 'scroll-down-aggressively). */);
5628 DEFVAR_PER_BUFFER ("header-line-format",
5629 &BVAR (current_buffer
, header_line_format
),
5631 doc
: /* Analogous to `mode-line-format', but controls the header line.
5632 The header line appears, optionally, at the top of a window;
5633 the mode line appears at the bottom. */);
5635 DEFVAR_PER_BUFFER ("mode-line-format", &BVAR (current_buffer
, mode_line_format
),
5637 doc
: /* Template for displaying mode line for current buffer.
5639 The value may be nil, a string, a symbol or a list.
5641 A value of nil means don't display a mode line.
5643 For any symbol other than t or nil, the symbol's value is processed as
5644 a mode line construct. As a special exception, if that value is a
5645 string, the string is processed verbatim, without handling any
5646 %-constructs (see below). Also, unless the symbol has a non-nil
5647 `risky-local-variable' property, all properties in any strings, as
5648 well as all :eval and :propertize forms in the value, are ignored.
5650 A list whose car is a string or list is processed by processing each
5651 of the list elements recursively, as separate mode line constructs,
5652 and concatenating the results.
5654 A list of the form `(:eval FORM)' is processed by evaluating FORM and
5655 using the result as a mode line construct. Be careful--FORM should
5656 not load any files, because that can cause an infinite recursion.
5658 A list of the form `(:propertize ELT PROPS...)' is processed by
5659 processing ELT as the mode line construct, and adding the text
5660 properties PROPS to the result.
5662 A list whose car is a symbol is processed by examining the symbol's
5663 value, and, if that value is non-nil, processing the cadr of the list
5664 recursively; and if that value is nil, processing the caddr of the
5667 A list whose car is an integer is processed by processing the cadr of
5668 the list, and padding (if the number is positive) or truncating (if
5669 negative) to the width specified by that number.
5671 A string is printed verbatim in the mode line except for %-constructs:
5672 %b -- print buffer name. %f -- print visited file name.
5673 %F -- print frame name.
5674 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
5675 %& is like %*, but ignore read-only-ness.
5676 % means buffer is read-only and * means it is modified.
5677 For a modified read-only buffer, %* gives % and %+ gives *.
5678 %s -- print process status. %l -- print the current line number.
5679 %c -- print the current column number (this makes editing slower).
5680 To make the column number update correctly in all cases,
5681 `column-number-mode' must be non-nil.
5682 %i -- print the size of the buffer.
5683 %I -- like %i, but use k, M, G, etc., to abbreviate.
5684 %p -- print percent of buffer above top of window, or Top, Bot or All.
5685 %P -- print percent of buffer above bottom of window, perhaps plus Top,
5686 or print Bottom or All.
5687 %n -- print Narrow if appropriate.
5688 %t -- visited file is text or binary (if OS supports this distinction).
5689 %z -- print mnemonics of keyboard, terminal, and buffer coding systems.
5690 %Z -- like %z, but including the end-of-line format.
5691 %e -- print error message about full memory.
5692 %@ -- print @ or hyphen. @ means that default-directory is on a
5694 %[ -- print one [ for each recursive editing level. %] similar.
5695 %% -- print %. %- -- print infinitely many dashes.
5696 Decimal digits after the % specify field width to which to pad. */);
5698 DEFVAR_BUFFER_DEFAULTS ("default-major-mode", major_mode
,
5699 doc
: /* Value of `major-mode' for new buffers. */);
5701 DEFVAR_PER_BUFFER ("major-mode", &BVAR (current_buffer
, major_mode
),
5703 doc
: /* Symbol for current buffer's major mode.
5704 The default value (normally `fundamental-mode') affects new buffers.
5705 A value of nil means to use the current buffer's major mode, provided
5706 it is not marked as "special".
5708 When a mode is used by default, `find-file' switches to it before it
5709 reads the contents into the buffer and before it finishes setting up
5710 the buffer. Thus, the mode and its hooks should not expect certain
5711 variables such as `buffer-read-only' and `buffer-file-coding-system'
5714 DEFVAR_PER_BUFFER ("mode-name", &BVAR (current_buffer
, mode_name
),
5716 doc
: /* Pretty name of current buffer's major mode.
5717 Usually a string, but can use any of the constructs for `mode-line-format',
5719 Format with `format-mode-line' to produce a string value. */);
5721 DEFVAR_PER_BUFFER ("local-abbrev-table", &BVAR (current_buffer
, abbrev_table
), Qnil
,
5722 doc
: /* Local (mode-specific) abbrev table of current buffer. */);
5724 DEFVAR_PER_BUFFER ("abbrev-mode", &BVAR (current_buffer
, abbrev_mode
), Qnil
,
5725 doc
: /* Non-nil if Abbrev mode is enabled.
5726 Use the command `abbrev-mode' to change this variable. */);
5728 DEFVAR_PER_BUFFER ("case-fold-search", &BVAR (current_buffer
, case_fold_search
),
5730 doc
: /* Non-nil if searches and matches should ignore case. */);
5732 DEFVAR_PER_BUFFER ("fill-column", &BVAR (current_buffer
, fill_column
),
5734 doc
: /* Column beyond which automatic line-wrapping should happen.
5735 Interactively, you can set the buffer local value using \\[set-fill-column]. */);
5737 DEFVAR_PER_BUFFER ("left-margin", &BVAR (current_buffer
, left_margin
),
5739 doc
: /* Column for the default `indent-line-function' to indent to.
5740 Linefeed indents to this column in Fundamental mode. */);
5742 DEFVAR_PER_BUFFER ("tab-width", &BVAR (current_buffer
, tab_width
),
5744 doc
: /* Distance between tab stops (for display of tab characters), in columns.
5745 NOTE: This controls the display width of a TAB character, and not
5746 the size of an indentation step.
5747 This should be an integer greater than zero. */);
5749 DEFVAR_PER_BUFFER ("ctl-arrow", &BVAR (current_buffer
, ctl_arrow
), Qnil
,
5750 doc
: /* Non-nil means display control chars with uparrow.
5751 A value of nil means use backslash and octal digits.
5752 This variable does not apply to characters whose display is specified
5753 in the current display table (if there is one). */);
5755 DEFVAR_PER_BUFFER ("enable-multibyte-characters",
5756 &BVAR (current_buffer
, enable_multibyte_characters
),
5758 doc
: /* Non-nil means the buffer contents are regarded as multi-byte characters.
5759 Otherwise they are regarded as unibyte. This affects the display,
5760 file I/O and the behavior of various editing commands.
5762 This variable is buffer-local but you cannot set it directly;
5763 use the function `set-buffer-multibyte' to change a buffer's representation.
5764 See also Info node `(elisp)Text Representations'. */);
5765 XSYMBOL (intern_c_string ("enable-multibyte-characters"))->constant
= 1;
5767 DEFVAR_PER_BUFFER ("buffer-file-coding-system",
5768 &BVAR (current_buffer
, buffer_file_coding_system
), Qnil
,
5769 doc
: /* Coding system to be used for encoding the buffer contents on saving.
5770 This variable applies to saving the buffer, and also to `write-region'
5771 and other functions that use `write-region'.
5772 It does not apply to sending output to subprocesses, however.
5774 If this is nil, the buffer is saved without any code conversion
5775 unless some coding system is specified in `file-coding-system-alist'
5776 for the buffer file.
5778 If the text to be saved cannot be encoded as specified by this variable,
5779 an alternative encoding is selected by `select-safe-coding-system', which see.
5781 The variable `coding-system-for-write', if non-nil, overrides this variable.
5783 This variable is never applied to a way of decoding a file while reading it. */);
5785 DEFVAR_PER_BUFFER ("bidi-display-reordering",
5786 &BVAR (current_buffer
, bidi_display_reordering
), Qnil
,
5787 doc
: /* Non-nil means reorder bidirectional text for display in the visual order. */);
5789 DEFVAR_PER_BUFFER ("bidi-paragraph-direction",
5790 &BVAR (current_buffer
, bidi_paragraph_direction
), Qnil
,
5791 doc
: /* If non-nil, forces directionality of text paragraphs in the buffer.
5793 If this is nil (the default), the direction of each paragraph is
5794 determined by the first strong directional character of its text.
5795 The values of `right-to-left' and `left-to-right' override that.
5796 Any other value is treated as nil.
5798 This variable has no effect unless the buffer's value of
5799 \`bidi-display-reordering' is non-nil. */);
5801 DEFVAR_PER_BUFFER ("truncate-lines", &BVAR (current_buffer
, truncate_lines
), Qnil
,
5802 doc
: /* Non-nil means do not display continuation lines.
5803 Instead, give each line of text just one screen line.
5805 Note that this is overridden by the variable
5806 `truncate-partial-width-windows' if that variable is non-nil
5807 and this buffer is not full-frame width.
5809 Minibuffers set this variable to nil. */);
5811 DEFVAR_PER_BUFFER ("word-wrap", &BVAR (current_buffer
, word_wrap
), Qnil
,
5812 doc
: /* Non-nil means to use word-wrapping for continuation lines.
5813 When word-wrapping is on, continuation lines are wrapped at the space
5814 or tab character nearest to the right window edge.
5815 If nil, continuation lines are wrapped at the right screen edge.
5817 This variable has no effect if long lines are truncated (see
5818 `truncate-lines' and `truncate-partial-width-windows'). If you use
5819 word-wrapping, you might want to reduce the value of
5820 `truncate-partial-width-windows', since wrapping can make text readable
5821 in narrower windows.
5823 Instead of setting this variable directly, most users should use
5824 Visual Line mode . Visual Line mode, when enabled, sets `word-wrap'
5825 to t, and additionally redefines simple editing commands to act on
5826 visual lines rather than logical lines. See the documentation of
5827 `visual-line-mode'. */);
5829 DEFVAR_PER_BUFFER ("default-directory", &BVAR (current_buffer
, directory
),
5831 doc
: /* Name of default directory of current buffer. Should end with slash.
5832 To interactively change the default directory, use command `cd'. */);
5834 DEFVAR_PER_BUFFER ("auto-fill-function", &BVAR (current_buffer
, auto_fill_function
),
5836 doc
: /* Function called (if non-nil) to perform auto-fill.
5837 It is called after self-inserting any character specified in
5838 the `auto-fill-chars' table.
5839 NOTE: This variable is not a hook;
5840 its value may not be a list of functions. */);
5842 DEFVAR_PER_BUFFER ("buffer-file-name", &BVAR (current_buffer
, filename
),
5844 doc
: /* Name of file visited in current buffer, or nil if not visiting a file.
5845 This should be an absolute file name. */);
5847 DEFVAR_PER_BUFFER ("buffer-file-truename", &BVAR (current_buffer
, file_truename
),
5849 doc
: /* Abbreviated truename of file visited in current buffer, or nil if none.
5850 The truename of a file is calculated by `file-truename'
5851 and then abbreviated with `abbreviate-file-name'. */);
5853 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
5854 &BVAR (current_buffer
, auto_save_file_name
),
5856 doc
: /* Name of file for auto-saving current buffer.
5857 If it is nil, that means don't auto-save this buffer. */);
5859 DEFVAR_PER_BUFFER ("buffer-read-only", &BVAR (current_buffer
, read_only
), Qnil
,
5860 doc
: /* Non-nil if this buffer is read-only. */);
5862 DEFVAR_PER_BUFFER ("buffer-backed-up", &BVAR (current_buffer
, backed_up
), Qnil
,
5863 doc
: /* Non-nil if this buffer's file has been backed up.
5864 Backing up is done before the first time the file is saved. */);
5866 DEFVAR_PER_BUFFER ("buffer-saved-size", &BVAR (current_buffer
, save_length
),
5868 doc
: /* Length of current buffer when last read in, saved or auto-saved.
5870 -1 means auto-saving turned off until next real save.
5872 If you set this to -2, that means don't turn off auto-saving in this buffer
5873 if its text size shrinks. If you use `buffer-swap-text' on a buffer,
5874 you probably should set this to -2 in that buffer. */);
5876 DEFVAR_PER_BUFFER ("selective-display", &BVAR (current_buffer
, selective_display
),
5878 doc
: /* Non-nil enables selective display.
5879 An integer N as value means display only lines
5880 that start with less than N columns of space.
5881 A value of t means that the character ^M makes itself and
5882 all the rest of the line invisible; also, when saving the buffer
5883 in a file, save the ^M as a newline. */);
5885 DEFVAR_PER_BUFFER ("selective-display-ellipses",
5886 &BVAR (current_buffer
, selective_display_ellipses
),
5888 doc
: /* Non-nil means display ... on previous line when a line is invisible. */);
5890 DEFVAR_PER_BUFFER ("overwrite-mode", &BVAR (current_buffer
, overwrite_mode
),
5892 doc
: /* Non-nil if self-insertion should replace existing text.
5893 The value should be one of `overwrite-mode-textual',
5894 `overwrite-mode-binary', or nil.
5895 If it is `overwrite-mode-textual', self-insertion still
5896 inserts at the end of a line, and inserts when point is before a tab,
5897 until the tab is filled in.
5898 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too. */);
5900 DEFVAR_PER_BUFFER ("buffer-display-table", &BVAR (current_buffer
, display_table
),
5902 doc
: /* Display table that controls display of the contents of current buffer.
5904 If this variable is nil, the value of `standard-display-table' is used.
5905 Each window can have its own, overriding display table, see
5906 `set-window-display-table' and `window-display-table'.
5908 The display table is a char-table created with `make-display-table'.
5909 A char-table is an array indexed by character codes. Normal array
5910 primitives `aref' and `aset' can be used to access elements of a char-table.
5912 Each of the char-table elements control how to display the corresponding
5913 text character: the element at index C in the table says how to display
5914 the character whose code is C. Each element should be a vector of
5915 characters or nil. The value nil means display the character in the
5916 default fashion; otherwise, the characters from the vector are delivered
5917 to the screen instead of the original character.
5919 For example, (aset buffer-display-table ?X [?Y]) tells Emacs
5920 to display a capital Y instead of each X character.
5922 In addition, a char-table has six extra slots to control the display of:
5924 the end of a truncated screen line (extra-slot 0, a single character);
5925 the end of a continued line (extra-slot 1, a single character);
5926 the escape character used to display character codes in octal
5927 (extra-slot 2, a single character);
5928 the character used as an arrow for control characters (extra-slot 3,
5929 a single character);
5930 the decoration indicating the presence of invisible lines (extra-slot 4,
5931 a vector of characters);
5932 the character used to draw the border between side-by-side windows
5933 (extra-slot 5, a single character).
5935 See also the functions `display-table-slot' and `set-display-table-slot'. */);
5937 DEFVAR_PER_BUFFER ("left-margin-width", &BVAR (current_buffer
, left_margin_cols
),
5939 doc
: /* Width in columns of left marginal area for display of a buffer.
5940 A value of nil means no marginal area.
5942 Setting this variable does not take effect until a new buffer is displayed
5943 in a window. To make the change take effect, call `set-window-buffer'. */);
5945 DEFVAR_PER_BUFFER ("right-margin-width", &BVAR (current_buffer
, right_margin_cols
),
5947 doc
: /* Width in columns of right marginal area for display of a buffer.
5948 A value of nil means no marginal area.
5950 Setting this variable does not take effect until a new buffer is displayed
5951 in a window. To make the change take effect, call `set-window-buffer'. */);
5953 DEFVAR_PER_BUFFER ("left-fringe-width", &BVAR (current_buffer
, left_fringe_width
),
5955 doc
: /* Width of this buffer's left fringe (in pixels).
5956 A value of 0 means no left fringe is shown in this buffer's window.
5957 A value of nil means to use the left fringe width from the window's frame.
5959 Setting this variable does not take effect until a new buffer is displayed
5960 in a window. To make the change take effect, call `set-window-buffer'. */);
5962 DEFVAR_PER_BUFFER ("right-fringe-width", &BVAR (current_buffer
, right_fringe_width
),
5964 doc
: /* Width of this buffer's right fringe (in pixels).
5965 A value of 0 means no right fringe is shown in this buffer's window.
5966 A value of nil means to use the right fringe width from the window's frame.
5968 Setting this variable does not take effect until a new buffer is displayed
5969 in a window. To make the change take effect, call `set-window-buffer'. */);
5971 DEFVAR_PER_BUFFER ("fringes-outside-margins", &BVAR (current_buffer
, fringes_outside_margins
),
5973 doc
: /* Non-nil means to display fringes outside display margins.
5974 A value of nil means to display fringes between margins and buffer text.
5976 Setting this variable does not take effect until a new buffer is displayed
5977 in a window. To make the change take effect, call `set-window-buffer'. */);
5979 DEFVAR_PER_BUFFER ("scroll-bar-width", &BVAR (current_buffer
, scroll_bar_width
),
5981 doc
: /* Width of this buffer's scroll bars in pixels.
5982 A value of nil means to use the scroll bar width from the window's frame. */);
5984 DEFVAR_PER_BUFFER ("scroll-bar-height", &BVAR (current_buffer
, scroll_bar_height
),
5986 doc
: /* Height of this buffer's scroll bars in pixels.
5987 A value of nil means to use the scroll bar heiht from the window's frame. */);
5989 DEFVAR_PER_BUFFER ("vertical-scroll-bar", &BVAR (current_buffer
, vertical_scroll_bar_type
),
5990 Qvertical_scroll_bar
,
5991 doc
: /* Position of this buffer's vertical scroll bar.
5992 The value takes effect whenever you tell a window to display this buffer;
5993 for instance, with `set-window-buffer' or when `display-buffer' displays it.
5995 A value of `left' or `right' means put the vertical scroll bar at that side
5996 of the window; a value of nil means don't show any vertical scroll bars.
5997 A value of t (the default) means do whatever the window's frame specifies. */);
5999 DEFVAR_PER_BUFFER ("horizontal-scroll-bar", &BVAR (current_buffer
, horizontal_scroll_bar_type
),
6001 doc
: /* Position of this buffer's horizontal scroll bar.
6002 The value takes effect whenever you tell a window to display this buffer;
6003 for instance, with `set-window-buffer' or when `display-buffer' displays it.
6005 A value of `bottom' means put the horizontal scroll bar at the bottom of
6006 the window; a value of nil means don't show any horizonal scroll bars.
6007 A value of t (the default) means do whatever the window's frame
6010 DEFVAR_PER_BUFFER ("indicate-empty-lines",
6011 &BVAR (current_buffer
, indicate_empty_lines
), Qnil
,
6012 doc
: /* Visually indicate empty lines after the buffer end.
6013 If non-nil, a bitmap is displayed in the left fringe of a window on
6014 window-systems. */);
6016 DEFVAR_PER_BUFFER ("indicate-buffer-boundaries",
6017 &BVAR (current_buffer
, indicate_buffer_boundaries
), Qnil
,
6018 doc
: /* Visually indicate buffer boundaries and scrolling.
6019 If non-nil, the first and last line of the buffer are marked in the fringe
6020 of a window on window-systems with angle bitmaps, or if the window can be
6021 scrolled, the top and bottom line of the window are marked with up and down
6024 If value is a symbol `left' or `right', both angle and arrow bitmaps
6025 are displayed in the left or right fringe, resp. Any other value
6026 that doesn't look like an alist means display the angle bitmaps in
6027 the left fringe but no arrows.
6029 You can exercise more precise control by using an alist as the
6030 value. Each alist element (INDICATOR . POSITION) specifies
6031 where to show one of the indicators. INDICATOR is one of `top',
6032 `bottom', `up', `down', or t, which specifies the default position,
6033 and POSITION is one of `left', `right', or nil, meaning do not show
6036 For example, ((top . left) (t . right)) places the top angle bitmap in
6037 left fringe, the bottom angle bitmap in right fringe, and both arrow
6038 bitmaps in right fringe. To show just the angle bitmaps in the left
6039 fringe, but no arrow bitmaps, use ((top . left) (bottom . left)). */);
6041 DEFVAR_PER_BUFFER ("fringe-indicator-alist",
6042 &BVAR (current_buffer
, fringe_indicator_alist
), Qnil
,
6043 doc
: /* Mapping from logical to physical fringe indicator bitmaps.
6044 The value is an alist where each element (INDICATOR . BITMAPS)
6045 specifies the fringe bitmaps used to display a specific logical
6048 INDICATOR specifies the logical indicator type which is one of the
6049 following symbols: `truncation' , `continuation', `overlay-arrow',
6050 `top', `bottom', `top-bottom', `up', `down', empty-line', or `unknown'.
6052 BITMAPS is a list of symbols (LEFT RIGHT [LEFT1 RIGHT1]) which specifies
6053 the actual bitmap shown in the left or right fringe for the logical
6054 indicator. LEFT and RIGHT are the bitmaps shown in the left and/or
6055 right fringe for the specific indicator. The LEFT1 or RIGHT1 bitmaps
6056 are used only for the `bottom' and `top-bottom' indicators when the
6057 last (only) line has no final newline. BITMAPS may also be a single
6058 symbol which is used in both left and right fringes. */);
6060 DEFVAR_PER_BUFFER ("fringe-cursor-alist",
6061 &BVAR (current_buffer
, fringe_cursor_alist
), Qnil
,
6062 doc
: /* Mapping from logical to physical fringe cursor bitmaps.
6063 The value is an alist where each element (CURSOR . BITMAP)
6064 specifies the fringe bitmaps used to display a specific logical
6065 cursor type in the fringe.
6067 CURSOR specifies the logical cursor type which is one of the following
6068 symbols: `box' , `hollow', `bar', `hbar', or `hollow-small'. The last
6069 one is used to show a hollow cursor on narrow lines display lines
6070 where the normal hollow cursor will not fit.
6072 BITMAP is the corresponding fringe bitmap shown for the logical
6075 DEFVAR_PER_BUFFER ("scroll-up-aggressively",
6076 &BVAR (current_buffer
, scroll_up_aggressively
), Qfraction
,
6077 doc
: /* How far to scroll windows upward.
6078 If you move point off the bottom, the window scrolls automatically.
6079 This variable controls how far it scrolls. The value nil, the default,
6080 means scroll to center point. A fraction means scroll to put point
6081 that fraction of the window's height from the bottom of the window.
6082 When the value is 0.0, point goes at the bottom line, which in the
6083 simple case that you moved off with C-f means scrolling just one line.
6084 1.0 means point goes at the top, so that in that simple case, the
6085 window scrolls by a full window height. Meaningful values are
6086 between 0.0 and 1.0, inclusive. */);
6088 DEFVAR_PER_BUFFER ("scroll-down-aggressively",
6089 &BVAR (current_buffer
, scroll_down_aggressively
), Qfraction
,
6090 doc
: /* How far to scroll windows downward.
6091 If you move point off the top, the window scrolls automatically.
6092 This variable controls how far it scrolls. The value nil, the default,
6093 means scroll to center point. A fraction means scroll to put point
6094 that fraction of the window's height from the top of the window.
6095 When the value is 0.0, point goes at the top line, which in the
6096 simple case that you moved off with C-b means scrolling just one line.
6097 1.0 means point goes at the bottom, so that in that simple case, the
6098 window scrolls by a full window height. Meaningful values are
6099 between 0.0 and 1.0, inclusive. */);
6101 DEFVAR_LISP ("before-change-functions", Vbefore_change_functions
,
6102 doc
: /* List of functions to call before each text change.
6103 Two arguments are passed to each function: the positions of
6104 the beginning and end of the range of old text to be changed.
6105 \(For an insertion, the beginning and end are at the same place.)
6106 No information is given about the length of the text after the change.
6108 Buffer changes made while executing the `before-change-functions'
6109 don't call any before-change or after-change functions.
6110 That's because `inhibit-modification-hooks' is temporarily set non-nil.
6112 If an unhandled error happens in running these functions,
6113 the variable's value remains nil. That prevents the error
6114 from happening repeatedly and making Emacs nonfunctional. */);
6115 Vbefore_change_functions
= Qnil
;
6117 DEFVAR_LISP ("after-change-functions", Vafter_change_functions
,
6118 doc
: /* List of functions to call after each text change.
6119 Three arguments are passed to each function: the positions of
6120 the beginning and end of the range of changed text,
6121 and the length in bytes of the pre-change text replaced by that range.
6122 \(For an insertion, the pre-change length is zero;
6123 for a deletion, that length is the number of bytes deleted,
6124 and the post-change beginning and end are at the same place.)
6126 Buffer changes made while executing the `after-change-functions'
6127 don't call any before-change or after-change functions.
6128 That's because `inhibit-modification-hooks' is temporarily set non-nil.
6130 If an unhandled error happens in running these functions,
6131 the variable's value remains nil. That prevents the error
6132 from happening repeatedly and making Emacs nonfunctional. */);
6133 Vafter_change_functions
= Qnil
;
6135 DEFVAR_LISP ("first-change-hook", Vfirst_change_hook
,
6136 doc
: /* A list of functions to call before changing a buffer which is unmodified.
6137 The functions are run using the `run-hooks' function. */);
6138 Vfirst_change_hook
= Qnil
;
6140 DEFVAR_PER_BUFFER ("buffer-undo-list", &BVAR (current_buffer
, undo_list
), Qnil
,
6141 doc
: /* List of undo entries in current buffer.
6142 Recent changes come first; older changes follow newer.
6144 An entry (BEG . END) represents an insertion which begins at
6145 position BEG and ends at position END.
6147 An entry (TEXT . POSITION) represents the deletion of the string TEXT
6148 from (abs POSITION). If POSITION is positive, point was at the front
6149 of the text being deleted; if negative, point was at the end.
6151 An entry (t HIGH LOW USEC PSEC) indicates that the buffer was previously
6152 unmodified; (HIGH LOW USEC PSEC) is in the same style as (current-time)
6153 and is the visited file's modification time, as of that time. If the
6154 modification time of the most recent save is different, this entry is
6157 An entry (t . 0) means means the buffer was previously unmodified but
6158 its time stamp was unknown because it was not associated with a file.
6159 An entry (t . -1) is similar, except that it means the buffer's visited
6162 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
6163 was modified between BEG and END. PROPERTY is the property name,
6164 and VALUE is the old value.
6166 An entry (apply FUN-NAME . ARGS) means undo the change with
6167 \(apply FUN-NAME ARGS).
6169 An entry (apply DELTA BEG END FUN-NAME . ARGS) supports selective undo
6170 in the active region. BEG and END is the range affected by this entry
6171 and DELTA is the number of characters added or deleted in that range by
6174 An entry (MARKER . DISTANCE) indicates that the marker MARKER
6175 was adjusted in position by the offset DISTANCE (an integer).
6177 An entry of the form POSITION indicates that point was at the buffer
6178 location given by the integer. Undoing an entry of this form places
6181 Entries with value `nil' mark undo boundaries. The undo command treats
6182 the changes between two undo boundaries as a single step to be undone.
6184 If the value of the variable is t, undo information is not recorded. */);
6186 DEFVAR_PER_BUFFER ("mark-active", &BVAR (current_buffer
, mark_active
), Qnil
,
6187 doc
: /* Non-nil means the mark and region are currently active in this buffer. */);
6189 DEFVAR_PER_BUFFER ("cache-long-scans", &BVAR (current_buffer
, cache_long_scans
), Qnil
,
6190 doc
: /* Non-nil means that Emacs should use caches in attempt to speedup buffer scans.
6192 There is no reason to set this to nil except for debugging purposes.
6194 Normally, the line-motion functions work by scanning the buffer for
6195 newlines. Columnar operations (like `move-to-column' and
6196 `compute-motion') also work by scanning the buffer, summing character
6197 widths as they go. This works well for ordinary text, but if the
6198 buffer's lines are very long (say, more than 500 characters), these
6199 motion functions will take longer to execute. Emacs may also take
6200 longer to update the display.
6202 If `cache-long-scans' is non-nil, these motion functions cache the
6203 results of their scans, and consult the cache to avoid rescanning
6204 regions of the buffer until the text is modified. The caches are most
6205 beneficial when they prevent the most searching---that is, when the
6206 buffer contains long lines and large regions of characters with the
6207 same, fixed screen width.
6209 When `cache-long-scans' is non-nil, processing short lines will
6210 become slightly slower (because of the overhead of consulting the
6211 cache), and the caches will use memory roughly proportional to the
6212 number of newlines and characters whose screen width varies.
6214 Bidirectional editing also requires buffer scans to find paragraph
6215 separators. If you have large paragraphs or no paragraph separators
6216 at all, these scans may be slow. If `cache-long-scans' is non-nil,
6217 results of these scans are cached. This doesn't help too much if
6218 paragraphs are of the reasonable (few thousands of characters) size.
6220 The caches require no explicit maintenance; their accuracy is
6221 maintained internally by the Emacs primitives. Enabling or disabling
6222 the cache should not affect the behavior of any of the motion
6223 functions; it should only affect their performance. */);
6225 DEFVAR_PER_BUFFER ("point-before-scroll", &BVAR (current_buffer
, point_before_scroll
), Qnil
,
6226 doc
: /* Value of point before the last series of scroll operations, or nil. */);
6228 DEFVAR_PER_BUFFER ("buffer-file-format", &BVAR (current_buffer
, file_format
), Qnil
,
6229 doc
: /* List of formats to use when saving this buffer.
6230 Formats are defined by `format-alist'. This variable is
6231 set when a file is visited. */);
6233 DEFVAR_PER_BUFFER ("buffer-auto-save-file-format",
6234 &BVAR (current_buffer
, auto_save_file_format
), Qnil
,
6235 doc
: /* Format in which to write auto-save files.
6236 Should be a list of symbols naming formats that are defined in `format-alist'.
6237 If it is t, which is the default, auto-save files are written in the
6238 same format as a regular save would use. */);
6240 DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
6241 &BVAR (current_buffer
, invisibility_spec
), Qnil
,
6242 doc
: /* Invisibility spec of this buffer.
6243 The default is t, which means that text is invisible if it has a non-nil
6244 `invisible' property.
6245 This variable can also be a list. The list can have two kinds of elements:
6246 `ATOM' and `(ATOM . ELLIPSIS)'. A text character is invisible if its
6247 `invisible' property is `ATOM', or has an `invisible' property that is a list
6248 that contains `ATOM'.
6249 If the `(ATOM . ELLIPSIS)' form is used, and `ELLIPSIS' is non-nil, an
6250 ellipsis will be displayed after the invisible characters.
6251 Setting this variable is very fast, much faster than scanning all the text in
6252 the buffer looking for properties to change. */);
6254 DEFVAR_PER_BUFFER ("buffer-display-count",
6255 &BVAR (current_buffer
, display_count
), Qintegerp
,
6256 doc
: /* A number incremented each time this buffer is displayed in a window.
6257 The function `set-window-buffer' increments it. */);
6259 DEFVAR_PER_BUFFER ("buffer-display-time",
6260 &BVAR (current_buffer
, display_time
), Qnil
,
6261 doc
: /* Time stamp updated each time this buffer is displayed in a window.
6262 The function `set-window-buffer' updates this variable
6263 to the value obtained by calling `current-time'.
6264 If the buffer has never been shown in a window, the value is nil. */);
6266 DEFVAR_LISP ("transient-mark-mode", Vtransient_mark_mode
,
6267 doc
: /* Non-nil if Transient Mark mode is enabled.
6268 See the command `transient-mark-mode' for a description of this minor mode.
6270 Non-nil also enables highlighting of the region whenever the mark is active.
6271 The variable `highlight-nonselected-windows' controls whether to highlight
6272 all windows or just the selected window.
6274 Lisp programs may give this variable certain special values:
6276 - A value of `lambda' enables Transient Mark mode temporarily.
6277 It is disabled again after any subsequent action that would
6278 normally deactivate the mark (e.g. buffer modification).
6280 - A value of (only . OLDVAL) enables Transient Mark mode
6281 temporarily. After any subsequent point motion command that is
6282 not shift-translated, or any other action that would normally
6283 deactivate the mark (e.g. buffer modification), the value of
6284 `transient-mark-mode' is set to OLDVAL. */);
6285 Vtransient_mark_mode
= Qnil
;
6287 DEFVAR_LISP ("inhibit-read-only", Vinhibit_read_only
,
6288 doc
: /* Non-nil means disregard read-only status of buffers or characters.
6289 If the value is t, disregard `buffer-read-only' and all `read-only'
6290 text properties. If the value is a list, disregard `buffer-read-only'
6291 and disregard a `read-only' text property if the property value
6292 is a member of the list. */);
6293 Vinhibit_read_only
= Qnil
;
6295 DEFVAR_PER_BUFFER ("cursor-type", &BVAR (current_buffer
, cursor_type
), Qnil
,
6296 doc
: /* Cursor to use when this buffer is in the selected window.
6297 Values are interpreted as follows:
6299 t use the cursor specified for the frame
6300 nil don't display a cursor
6301 box display a filled box cursor
6302 hollow display a hollow box cursor
6303 bar display a vertical bar cursor with default width
6304 (bar . WIDTH) display a vertical bar cursor with width WIDTH
6305 hbar display a horizontal bar cursor with default height
6306 (hbar . HEIGHT) display a horizontal bar cursor with height HEIGHT
6307 ANYTHING ELSE display a hollow box cursor
6309 When the buffer is displayed in a non-selected window, the
6310 cursor's appearance is instead controlled by the variable
6311 `cursor-in-non-selected-windows'. */);
6313 DEFVAR_PER_BUFFER ("line-spacing",
6314 &BVAR (current_buffer
, extra_line_spacing
), Qnumberp
,
6315 doc
: /* Additional space to put between lines when displaying a buffer.
6316 The space is measured in pixels, and put below lines on graphic displays,
6317 see `display-graphic-p'.
6318 If value is a floating point number, it specifies the spacing relative
6319 to the default frame line height. A value of nil means add no extra space. */);
6321 DEFVAR_PER_BUFFER ("cursor-in-non-selected-windows",
6322 &BVAR (current_buffer
, cursor_in_non_selected_windows
), Qnil
,
6323 doc
: /* Non-nil means show a cursor in non-selected windows.
6324 If nil, only shows a cursor in the selected window.
6325 If t, displays a cursor related to the usual cursor type
6326 \(a solid box becomes hollow, a bar becomes a narrower bar).
6327 You can also specify the cursor type as in the `cursor-type' variable.
6328 Use Custom to set this variable and update the display." */);
6330 DEFVAR_LISP ("kill-buffer-query-functions", Vkill_buffer_query_functions
,
6331 doc
: /* List of functions called with no args to query before killing a buffer.
6332 The buffer being killed will be current while the functions are running.
6334 If any of them returns nil, the buffer is not killed. Functions run by
6335 this hook are supposed to not change the current buffer. */);
6336 Vkill_buffer_query_functions
= Qnil
;
6338 DEFVAR_LISP ("change-major-mode-hook", Vchange_major_mode_hook
,
6339 doc
: /* Normal hook run before changing the major mode of a buffer.
6340 The function `kill-all-local-variables' runs this before doing anything else. */);
6341 Vchange_major_mode_hook
= Qnil
;
6342 DEFSYM (Qchange_major_mode_hook
, "change-major-mode-hook");
6344 DEFVAR_LISP ("buffer-list-update-hook", Vbuffer_list_update_hook
,
6345 doc
: /* Hook run when the buffer list changes.
6346 Functions running this hook are, `get-buffer-create',
6347 `make-indirect-buffer', `rename-buffer', `kill-buffer',
6348 `bury-buffer-internal' and `select-window'. */);
6349 Vbuffer_list_update_hook
= Qnil
;
6350 DEFSYM (Qbuffer_list_update_hook
, "buffer-list-update-hook");
6352 defsubr (&Sbuffer_live_p
);
6353 defsubr (&Sbuffer_list
);
6354 defsubr (&Sget_buffer
);
6355 defsubr (&Sget_file_buffer
);
6356 defsubr (&Sget_buffer_create
);
6357 defsubr (&Smake_indirect_buffer
);
6358 defsubr (&Sgenerate_new_buffer_name
);
6359 defsubr (&Sbuffer_name
);
6360 defsubr (&Sbuffer_file_name
);
6361 defsubr (&Sbuffer_base_buffer
);
6362 defsubr (&Sbuffer_local_value
);
6363 defsubr (&Sbuffer_local_variables
);
6364 defsubr (&Sbuffer_modified_p
);
6365 defsubr (&Sforce_mode_line_update
);
6366 defsubr (&Sset_buffer_modified_p
);
6367 defsubr (&Sbuffer_modified_tick
);
6368 defsubr (&Sbuffer_chars_modified_tick
);
6369 defsubr (&Srename_buffer
);
6370 defsubr (&Sother_buffer
);
6371 defsubr (&Sbuffer_enable_undo
);
6372 defsubr (&Skill_buffer
);
6373 defsubr (&Sbury_buffer_internal
);
6374 defsubr (&Sset_buffer_major_mode
);
6375 defsubr (&Scurrent_buffer
);
6376 defsubr (&Sset_buffer
);
6377 defsubr (&Sbarf_if_buffer_read_only
);
6378 defsubr (&Serase_buffer
);
6379 defsubr (&Sbuffer_swap_text
);
6380 defsubr (&Sset_buffer_multibyte
);
6381 defsubr (&Skill_all_local_variables
);
6383 defsubr (&Soverlayp
);
6384 defsubr (&Smake_overlay
);
6385 defsubr (&Sdelete_overlay
);
6386 defsubr (&Sdelete_all_overlays
);
6387 defsubr (&Smove_overlay
);
6388 defsubr (&Soverlay_start
);
6389 defsubr (&Soverlay_end
);
6390 defsubr (&Soverlay_buffer
);
6391 defsubr (&Soverlay_properties
);
6392 defsubr (&Soverlays_at
);
6393 defsubr (&Soverlays_in
);
6394 defsubr (&Snext_overlay_change
);
6395 defsubr (&Sprevious_overlay_change
);
6396 defsubr (&Soverlay_recenter
);
6397 defsubr (&Soverlay_lists
);
6398 defsubr (&Soverlay_get
);
6399 defsubr (&Soverlay_put
);
6400 defsubr (&Srestore_buffer_modified_p
);
6404 keys_of_buffer (void)
6406 initial_define_key (control_x_map
, 'b', "switch-to-buffer");
6407 initial_define_key (control_x_map
, 'k', "kill-buffer");
6409 /* This must not be in syms_of_buffer, because Qdisabled is not
6410 initialized when that function gets called. */
6411 Fput (intern_c_string ("erase-buffer"), Qdisabled
, Qt
);