1 /* Buffer manipulation primitives for GNU Emacs.
3 Copyright (C) 1985-1989, 1993-1995, 1997-2015 Free Software Foundation,
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
23 #include <sys/types.h>
25 #include <sys/param.h>
33 #include "intervals.h"
36 #include "character.h"
38 #include "region-cache.h"
40 #include "blockinput.h"
46 #include "w32heap.h" /* for mmap_* */
49 struct buffer
*current_buffer
; /* The current buffer. */
51 /* First buffer in chain of all buffers (in reverse order of creation).
52 Threaded through ->header.next.buffer. */
54 struct buffer
*all_buffers
;
56 /* This structure holds the default values of the buffer-local variables
57 defined with DEFVAR_PER_BUFFER, that have special slots in each buffer.
58 The default value occupies the same slot in this structure
59 as an individual buffer's value occupies in that buffer.
60 Setting the default value also goes through the alist of buffers
61 and stores into each buffer that does not say it has a local value. */
63 struct buffer
alignas (GCALIGNMENT
) buffer_defaults
;
65 /* This structure marks which slots in a buffer have corresponding
66 default values in buffer_defaults.
67 Each such slot has a nonzero value in this structure.
68 The value has only one nonzero bit.
70 When a buffer has its own local value for a slot,
71 the entry for that slot (found in the same slot in this structure)
72 is turned on in the buffer's local_flags array.
74 If a slot in this structure is -1, then even though there may
75 be a DEFVAR_PER_BUFFER for the slot, there is no default value for it;
76 and the corresponding slot in buffer_defaults is not used.
78 If a slot in this structure corresponding to a DEFVAR_PER_BUFFER is
79 zero, that is a bug. */
81 struct buffer buffer_local_flags
;
83 /* This structure holds the names of symbols whose values may be
84 buffer-local. It is indexed and accessed in the same way as the above. */
86 struct buffer
alignas (GCALIGNMENT
) buffer_local_symbols
;
88 /* Return the symbol of the per-buffer variable at offset OFFSET in
89 the buffer structure. */
91 #define PER_BUFFER_SYMBOL(OFFSET) \
92 (*(Lisp_Object *)((OFFSET) + (char *) &buffer_local_symbols))
94 /* Maximum length of an overlay vector. */
95 #define OVERLAY_COUNT_MAX \
96 ((ptrdiff_t) min (MOST_POSITIVE_FIXNUM, \
97 min (PTRDIFF_MAX, SIZE_MAX) / word_size))
99 /* Flags indicating which built-in buffer-local variables
100 are permanent locals. */
101 static char buffer_permanent_local_flags
[MAX_PER_BUFFER_VARS
];
103 /* Number of per-buffer variables used. */
105 int last_per_buffer_idx
;
107 static void call_overlay_mod_hooks (Lisp_Object list
, Lisp_Object overlay
,
108 bool after
, Lisp_Object arg1
,
109 Lisp_Object arg2
, Lisp_Object arg3
);
110 static void swap_out_buffer_local_variables (struct buffer
*b
);
111 static void reset_buffer_local_variables (struct buffer
*, bool);
113 /* Alist of all buffer names vs the buffers. This used to be
114 a Lisp-visible variable, but is no longer, to prevent lossage
115 due to user rplac'ing this alist or its elements. */
116 Lisp_Object Vbuffer_alist
;
118 static Lisp_Object Qkill_buffer_query_functions
;
120 /* Hook run before changing a major mode. */
121 static Lisp_Object Qchange_major_mode_hook
;
123 Lisp_Object Qfirst_change_hook
;
124 Lisp_Object Qbefore_change_functions
;
125 Lisp_Object Qafter_change_functions
;
127 static Lisp_Object Qfundamental_mode
, Qmode_class
, Qpermanent_local
;
128 static Lisp_Object Qpermanent_local_hook
;
130 static Lisp_Object Qprotected_field
;
132 static Lisp_Object QSFundamental
; /* A string "Fundamental". */
134 static Lisp_Object Qkill_buffer_hook
;
135 static Lisp_Object Qbuffer_list_update_hook
;
137 static Lisp_Object Qget_file_buffer
;
139 static Lisp_Object Qoverlayp
;
141 Lisp_Object Qpriority
, Qbefore_string
, Qafter_string
;
143 static Lisp_Object Qevaporate
;
145 Lisp_Object Qmodification_hooks
;
146 Lisp_Object Qinsert_in_front_hooks
;
147 Lisp_Object Qinsert_behind_hooks
;
149 Lisp_Object Qchoice
, Qrange
, Qleft
, Qright
;
150 Lisp_Object Qvertical_scroll_bar
, Qhorizontal_scroll_bar
;
151 static Lisp_Object Qoverwrite_mode
, Qfraction
;
153 static void alloc_buffer_text (struct buffer
*, ptrdiff_t);
154 static void free_buffer_text (struct buffer
*b
);
155 static struct Lisp_Overlay
* copy_overlays (struct buffer
*, struct Lisp_Overlay
*);
156 static void modify_overlay (struct buffer
*, ptrdiff_t, ptrdiff_t);
157 static Lisp_Object
buffer_lisp_local_variables (struct buffer
*, bool);
160 CHECK_OVERLAY (Lisp_Object x
)
162 CHECK_TYPE (OVERLAYP (x
), Qoverlayp
, x
);
165 /* These setters are used only in this file, so they can be private.
166 The public setters are inline functions defined in buffer.h. */
168 bset_abbrev_mode (struct buffer
*b
, Lisp_Object val
)
170 b
->INTERNAL_FIELD (abbrev_mode
) = val
;
173 bset_abbrev_table (struct buffer
*b
, Lisp_Object val
)
175 b
->INTERNAL_FIELD (abbrev_table
) = val
;
178 bset_auto_fill_function (struct buffer
*b
, Lisp_Object val
)
180 b
->INTERNAL_FIELD (auto_fill_function
) = val
;
183 bset_auto_save_file_format (struct buffer
*b
, Lisp_Object val
)
185 b
->INTERNAL_FIELD (auto_save_file_format
) = val
;
188 bset_auto_save_file_name (struct buffer
*b
, Lisp_Object val
)
190 b
->INTERNAL_FIELD (auto_save_file_name
) = val
;
193 bset_backed_up (struct buffer
*b
, Lisp_Object val
)
195 b
->INTERNAL_FIELD (backed_up
) = val
;
198 bset_begv_marker (struct buffer
*b
, Lisp_Object val
)
200 b
->INTERNAL_FIELD (begv_marker
) = val
;
203 bset_bidi_display_reordering (struct buffer
*b
, Lisp_Object val
)
205 b
->INTERNAL_FIELD (bidi_display_reordering
) = val
;
208 bset_buffer_file_coding_system (struct buffer
*b
, Lisp_Object val
)
210 b
->INTERNAL_FIELD (buffer_file_coding_system
) = val
;
213 bset_case_fold_search (struct buffer
*b
, Lisp_Object val
)
215 b
->INTERNAL_FIELD (case_fold_search
) = val
;
218 bset_ctl_arrow (struct buffer
*b
, Lisp_Object val
)
220 b
->INTERNAL_FIELD (ctl_arrow
) = val
;
223 bset_cursor_in_non_selected_windows (struct buffer
*b
, Lisp_Object val
)
225 b
->INTERNAL_FIELD (cursor_in_non_selected_windows
) = val
;
228 bset_cursor_type (struct buffer
*b
, Lisp_Object val
)
230 b
->INTERNAL_FIELD (cursor_type
) = val
;
233 bset_display_table (struct buffer
*b
, Lisp_Object val
)
235 b
->INTERNAL_FIELD (display_table
) = val
;
238 bset_extra_line_spacing (struct buffer
*b
, Lisp_Object val
)
240 b
->INTERNAL_FIELD (extra_line_spacing
) = val
;
243 bset_file_format (struct buffer
*b
, Lisp_Object val
)
245 b
->INTERNAL_FIELD (file_format
) = val
;
248 bset_file_truename (struct buffer
*b
, Lisp_Object val
)
250 b
->INTERNAL_FIELD (file_truename
) = val
;
253 bset_fringe_cursor_alist (struct buffer
*b
, Lisp_Object val
)
255 b
->INTERNAL_FIELD (fringe_cursor_alist
) = val
;
258 bset_fringe_indicator_alist (struct buffer
*b
, Lisp_Object val
)
260 b
->INTERNAL_FIELD (fringe_indicator_alist
) = val
;
263 bset_fringes_outside_margins (struct buffer
*b
, Lisp_Object val
)
265 b
->INTERNAL_FIELD (fringes_outside_margins
) = val
;
268 bset_header_line_format (struct buffer
*b
, Lisp_Object val
)
270 b
->INTERNAL_FIELD (header_line_format
) = val
;
273 bset_indicate_buffer_boundaries (struct buffer
*b
, Lisp_Object val
)
275 b
->INTERNAL_FIELD (indicate_buffer_boundaries
) = val
;
278 bset_indicate_empty_lines (struct buffer
*b
, Lisp_Object val
)
280 b
->INTERNAL_FIELD (indicate_empty_lines
) = val
;
283 bset_invisibility_spec (struct buffer
*b
, Lisp_Object val
)
285 b
->INTERNAL_FIELD (invisibility_spec
) = val
;
288 bset_left_fringe_width (struct buffer
*b
, Lisp_Object val
)
290 b
->INTERNAL_FIELD (left_fringe_width
) = val
;
293 bset_major_mode (struct buffer
*b
, Lisp_Object val
)
295 b
->INTERNAL_FIELD (major_mode
) = val
;
298 bset_mark (struct buffer
*b
, Lisp_Object val
)
300 b
->INTERNAL_FIELD (mark
) = val
;
303 bset_minor_modes (struct buffer
*b
, Lisp_Object val
)
305 b
->INTERNAL_FIELD (minor_modes
) = val
;
308 bset_mode_line_format (struct buffer
*b
, Lisp_Object val
)
310 b
->INTERNAL_FIELD (mode_line_format
) = val
;
313 bset_mode_name (struct buffer
*b
, Lisp_Object val
)
315 b
->INTERNAL_FIELD (mode_name
) = val
;
318 bset_name (struct buffer
*b
, Lisp_Object val
)
320 b
->INTERNAL_FIELD (name
) = val
;
323 bset_overwrite_mode (struct buffer
*b
, Lisp_Object val
)
325 b
->INTERNAL_FIELD (overwrite_mode
) = val
;
328 bset_pt_marker (struct buffer
*b
, Lisp_Object val
)
330 b
->INTERNAL_FIELD (pt_marker
) = val
;
333 bset_right_fringe_width (struct buffer
*b
, Lisp_Object val
)
335 b
->INTERNAL_FIELD (right_fringe_width
) = val
;
338 bset_save_length (struct buffer
*b
, Lisp_Object val
)
340 b
->INTERNAL_FIELD (save_length
) = val
;
343 bset_scroll_bar_width (struct buffer
*b
, Lisp_Object val
)
345 b
->INTERNAL_FIELD (scroll_bar_width
) = val
;
348 bset_scroll_bar_height (struct buffer
*b
, Lisp_Object val
)
350 b
->INTERNAL_FIELD (scroll_bar_height
) = val
;
353 bset_scroll_down_aggressively (struct buffer
*b
, Lisp_Object val
)
355 b
->INTERNAL_FIELD (scroll_down_aggressively
) = val
;
358 bset_scroll_up_aggressively (struct buffer
*b
, Lisp_Object val
)
360 b
->INTERNAL_FIELD (scroll_up_aggressively
) = val
;
363 bset_selective_display (struct buffer
*b
, Lisp_Object val
)
365 b
->INTERNAL_FIELD (selective_display
) = val
;
368 bset_selective_display_ellipses (struct buffer
*b
, Lisp_Object val
)
370 b
->INTERNAL_FIELD (selective_display_ellipses
) = val
;
373 bset_vertical_scroll_bar_type (struct buffer
*b
, Lisp_Object val
)
375 b
->INTERNAL_FIELD (vertical_scroll_bar_type
) = val
;
378 bset_horizontal_scroll_bar_type (struct buffer
*b
, Lisp_Object val
)
380 b
->INTERNAL_FIELD (horizontal_scroll_bar_type
) = val
;
383 bset_word_wrap (struct buffer
*b
, Lisp_Object val
)
385 b
->INTERNAL_FIELD (word_wrap
) = val
;
388 bset_zv_marker (struct buffer
*b
, Lisp_Object val
)
390 b
->INTERNAL_FIELD (zv_marker
) = val
;
394 nsberror (Lisp_Object spec
)
397 error ("No buffer named %s", SDATA (spec
));
398 error ("Invalid buffer argument");
401 DEFUN ("buffer-live-p", Fbuffer_live_p
, Sbuffer_live_p
, 1, 1, 0,
402 doc
: /* Return non-nil if OBJECT is a buffer which has not been killed.
403 Value is nil if OBJECT is not a buffer or if it has been killed. */)
406 return ((BUFFERP (object
) && BUFFER_LIVE_P (XBUFFER (object
)))
410 DEFUN ("buffer-list", Fbuffer_list
, Sbuffer_list
, 0, 1, 0,
411 doc
: /* Return a list of all existing live buffers.
412 If the optional arg FRAME is a frame, we return the buffer list in the
413 proper order for that frame: the buffers show in FRAME come first,
414 followed by the rest of the buffers. */)
418 general
= Fmapcar (Qcdr
, Vbuffer_alist
);
422 Lisp_Object framelist
, prevlist
, tail
;
425 framelist
= Fcopy_sequence (XFRAME (frame
)->buffer_list
);
426 prevlist
= Fnreverse (Fcopy_sequence
427 (XFRAME (frame
)->buried_buffer_list
));
429 /* Remove from GENERAL any buffer that duplicates one in
430 FRAMELIST or PREVLIST. */
434 general
= Fdelq (XCAR (tail
), general
);
440 general
= Fdelq (XCAR (tail
), general
);
447 return Fnconc (3, args
);
453 /* Like Fassoc, but use Fstring_equal to compare
454 (which ignores text properties),
455 and don't ever QUIT. */
458 assoc_ignore_text_properties (register Lisp_Object key
, Lisp_Object list
)
460 register Lisp_Object tail
;
461 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
463 register Lisp_Object elt
, tem
;
465 tem
= Fstring_equal (Fcar (elt
), key
);
472 DEFUN ("get-buffer", Fget_buffer
, Sget_buffer
, 1, 1, 0,
473 doc
: /* Return the buffer named BUFFER-OR-NAME.
474 BUFFER-OR-NAME must be either a string or a buffer. If BUFFER-OR-NAME
475 is a string and there is no buffer with that name, return nil. If
476 BUFFER-OR-NAME is a buffer, return it as given. */)
477 (register Lisp_Object buffer_or_name
)
479 if (BUFFERP (buffer_or_name
))
480 return buffer_or_name
;
481 CHECK_STRING (buffer_or_name
);
483 return Fcdr (assoc_ignore_text_properties (buffer_or_name
, Vbuffer_alist
));
486 DEFUN ("get-file-buffer", Fget_file_buffer
, Sget_file_buffer
, 1, 1, 0,
487 doc
: /* Return the buffer visiting file FILENAME (a string).
488 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
489 If there is no such live buffer, return nil.
490 See also `find-buffer-visiting'. */)
491 (register Lisp_Object filename
)
493 register Lisp_Object tail
, buf
, handler
;
495 CHECK_STRING (filename
);
496 filename
= Fexpand_file_name (filename
, Qnil
);
498 /* If the file name has special constructs in it,
499 call the corresponding file handler. */
500 handler
= Ffind_file_name_handler (filename
, Qget_file_buffer
);
503 Lisp_Object handled_buf
= call2 (handler
, Qget_file_buffer
,
505 return BUFFERP (handled_buf
) ? handled_buf
: Qnil
;
508 FOR_EACH_LIVE_BUFFER (tail
, buf
)
510 if (!STRINGP (BVAR (XBUFFER (buf
), filename
))) continue;
511 if (!NILP (Fstring_equal (BVAR (XBUFFER (buf
), filename
), filename
)))
518 get_truename_buffer (register Lisp_Object filename
)
520 register Lisp_Object tail
, buf
;
522 FOR_EACH_LIVE_BUFFER (tail
, buf
)
524 if (!STRINGP (BVAR (XBUFFER (buf
), file_truename
))) continue;
525 if (!NILP (Fstring_equal (BVAR (XBUFFER (buf
), file_truename
), filename
)))
531 DEFUN ("get-buffer-create", Fget_buffer_create
, Sget_buffer_create
, 1, 1, 0,
532 doc
: /* Return the buffer specified by BUFFER-OR-NAME, creating a new one if needed.
533 If BUFFER-OR-NAME is a string and a live buffer with that name exists,
534 return that buffer. If no such buffer exists, create a new buffer with
535 that name and return it. If BUFFER-OR-NAME starts with a space, the new
536 buffer does not keep undo information.
538 If BUFFER-OR-NAME is a buffer instead of a string, return it as given,
539 even if it is dead. The return value is never nil. */)
540 (register Lisp_Object buffer_or_name
)
542 register Lisp_Object buffer
, name
;
543 register struct buffer
*b
;
545 buffer
= Fget_buffer (buffer_or_name
);
549 if (SCHARS (buffer_or_name
) == 0)
550 error ("Empty string for buffer name is not allowed");
552 b
= allocate_buffer ();
554 /* An ordinary buffer uses its own struct buffer_text. */
555 b
->text
= &b
->own_text
;
556 b
->base_buffer
= NULL
;
557 /* No one shares the text with us now. */
559 /* No one shows us now. */
562 BUF_GAP_SIZE (b
) = 20;
564 /* We allocate extra 1-byte at the tail and keep it always '\0' for
565 anchoring a search. */
566 alloc_buffer_text (b
, BUF_GAP_SIZE (b
) + 1);
568 if (! BUF_BEG_ADDR (b
))
569 buffer_memory_full (BUF_GAP_SIZE (b
) + 1);
574 b
->pt_byte
= BEG_BYTE
;
575 b
->begv_byte
= BEG_BYTE
;
576 b
->zv_byte
= BEG_BYTE
;
579 BUF_GPT_BYTE (b
) = BEG_BYTE
;
582 BUF_Z_BYTE (b
) = BEG_BYTE
;
584 BUF_CHARS_MODIFF (b
) = 1;
585 BUF_OVERLAY_MODIFF (b
) = 1;
586 BUF_SAVE_MODIFF (b
) = 1;
588 set_buffer_intervals (b
, NULL
);
589 BUF_UNCHANGED_MODIFIED (b
) = 1;
590 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = 1;
591 BUF_END_UNCHANGED (b
) = 0;
592 BUF_BEG_UNCHANGED (b
) = 0;
593 *(BUF_GPT_ADDR (b
)) = *(BUF_Z_ADDR (b
)) = 0; /* Put an anchor '\0'. */
594 b
->text
->inhibit_shrinking
= false;
595 b
->text
->redisplay
= false;
597 b
->newline_cache
= 0;
598 b
->width_run_cache
= 0;
599 b
->bidi_paragraph_cache
= 0;
600 bset_width_table (b
, Qnil
);
601 b
->prevent_redisplay_optimizations_p
= 1;
603 /* An ordinary buffer normally doesn't need markers
604 to handle BEGV and ZV. */
605 bset_pt_marker (b
, Qnil
);
606 bset_begv_marker (b
, Qnil
);
607 bset_zv_marker (b
, Qnil
);
609 name
= Fcopy_sequence (buffer_or_name
);
610 set_string_intervals (name
, NULL
);
613 bset_undo_list (b
, SREF (name
, 0) != ' ' ? Qnil
: Qt
);
616 reset_buffer_local_variables (b
, 1);
618 bset_mark (b
, Fmake_marker ());
619 BUF_MARKERS (b
) = NULL
;
621 /* Put this in the alist of all live buffers. */
622 XSETBUFFER (buffer
, b
);
623 Vbuffer_alist
= nconc2 (Vbuffer_alist
, list1 (Fcons (name
, buffer
)));
624 /* And run buffer-list-update-hook. */
625 if (!NILP (Vrun_hooks
))
626 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
632 /* Return a list of overlays which is a copy of the overlay list
633 LIST, but for buffer B. */
635 static struct Lisp_Overlay
*
636 copy_overlays (struct buffer
*b
, struct Lisp_Overlay
*list
)
638 struct Lisp_Overlay
*result
= NULL
, *tail
= NULL
;
640 for (; list
; list
= list
->next
)
642 Lisp_Object overlay
, start
, end
;
643 struct Lisp_Marker
*m
;
645 eassert (MARKERP (list
->start
));
646 m
= XMARKER (list
->start
);
647 start
= build_marker (b
, m
->charpos
, m
->bytepos
);
648 XMARKER (start
)->insertion_type
= m
->insertion_type
;
650 eassert (MARKERP (list
->end
));
651 m
= XMARKER (list
->end
);
652 end
= build_marker (b
, m
->charpos
, m
->bytepos
);
653 XMARKER (end
)->insertion_type
= m
->insertion_type
;
655 overlay
= build_overlay (start
, end
, Fcopy_sequence (list
->plist
));
657 tail
= tail
->next
= XOVERLAY (overlay
);
659 result
= tail
= XOVERLAY (overlay
);
665 /* Set an appropriate overlay of B. */
668 set_buffer_overlays_before (struct buffer
*b
, struct Lisp_Overlay
*o
)
670 b
->overlays_before
= o
;
674 set_buffer_overlays_after (struct buffer
*b
, struct Lisp_Overlay
*o
)
676 b
->overlays_after
= o
;
679 /* Clone per-buffer values of buffer FROM.
681 Buffer TO gets the same per-buffer values as FROM, with the
682 following exceptions: (1) TO's name is left untouched, (2) markers
683 are copied and made to refer to TO, and (3) overlay lists are
687 clone_per_buffer_values (struct buffer
*from
, struct buffer
*to
)
691 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
695 /* Don't touch the `name' which should be unique for every buffer. */
696 if (offset
== PER_BUFFER_VAR_OFFSET (name
))
699 obj
= per_buffer_value (from
, offset
);
700 if (MARKERP (obj
) && XMARKER (obj
)->buffer
== from
)
702 struct Lisp_Marker
*m
= XMARKER (obj
);
704 obj
= build_marker (to
, m
->charpos
, m
->bytepos
);
705 XMARKER (obj
)->insertion_type
= m
->insertion_type
;
708 set_per_buffer_value (to
, offset
, obj
);
711 memcpy (to
->local_flags
, from
->local_flags
, sizeof to
->local_flags
);
713 set_buffer_overlays_before (to
, copy_overlays (to
, from
->overlays_before
));
714 set_buffer_overlays_after (to
, copy_overlays (to
, from
->overlays_after
));
716 /* Get (a copy of) the alist of Lisp-level local variables of FROM
717 and install that in TO. */
718 bset_local_var_alist (to
, buffer_lisp_local_variables (from
, 1));
722 /* If buffer B has markers to record PT, BEGV and ZV when it is not
723 current, update these markers. */
726 record_buffer_markers (struct buffer
*b
)
728 if (! NILP (BVAR (b
, pt_marker
)))
732 eassert (!NILP (BVAR (b
, begv_marker
)));
733 eassert (!NILP (BVAR (b
, zv_marker
)));
735 XSETBUFFER (buffer
, b
);
736 set_marker_both (BVAR (b
, pt_marker
), buffer
, b
->pt
, b
->pt_byte
);
737 set_marker_both (BVAR (b
, begv_marker
), buffer
, b
->begv
, b
->begv_byte
);
738 set_marker_both (BVAR (b
, zv_marker
), buffer
, b
->zv
, b
->zv_byte
);
743 /* If buffer B has markers to record PT, BEGV and ZV when it is not
744 current, fetch these values into B->begv etc. */
747 fetch_buffer_markers (struct buffer
*b
)
749 if (! NILP (BVAR (b
, pt_marker
)))
753 eassert (!NILP (BVAR (b
, begv_marker
)));
754 eassert (!NILP (BVAR (b
, zv_marker
)));
756 m
= BVAR (b
, pt_marker
);
757 SET_BUF_PT_BOTH (b
, marker_position (m
), marker_byte_position (m
));
759 m
= BVAR (b
, begv_marker
);
760 SET_BUF_BEGV_BOTH (b
, marker_position (m
), marker_byte_position (m
));
762 m
= BVAR (b
, zv_marker
);
763 SET_BUF_ZV_BOTH (b
, marker_position (m
), marker_byte_position (m
));
768 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer
, Smake_indirect_buffer
,
770 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ",
771 doc
: /* Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.
772 BASE-BUFFER should be a live buffer, or the name of an existing buffer.
773 NAME should be a string which is not the name of an existing buffer.
774 Optional argument CLONE non-nil means preserve BASE-BUFFER's state,
775 such as major and minor modes, in the indirect buffer.
776 CLONE nil means the indirect buffer's state is reset to default values. */)
777 (Lisp_Object base_buffer
, Lisp_Object name
, Lisp_Object clone
)
779 Lisp_Object buf
, tem
;
783 buf
= Fget_buffer (name
);
785 error ("Buffer name `%s' is in use", SDATA (name
));
788 base_buffer
= Fget_buffer (base_buffer
);
789 if (NILP (base_buffer
))
790 error ("No such buffer: `%s'", SDATA (tem
));
791 if (!BUFFER_LIVE_P (XBUFFER (base_buffer
)))
792 error ("Base buffer has been killed");
794 if (SCHARS (name
) == 0)
795 error ("Empty string for buffer name is not allowed");
797 b
= allocate_buffer ();
799 /* No double indirection - if base buffer is indirect,
800 new buffer becomes an indirect to base's base. */
801 b
->base_buffer
= (XBUFFER (base_buffer
)->base_buffer
802 ? XBUFFER (base_buffer
)->base_buffer
803 : XBUFFER (base_buffer
));
805 /* Use the base buffer's text object. */
806 b
->text
= b
->base_buffer
->text
;
807 /* We have no own text. */
808 b
->indirections
= -1;
809 /* Notify base buffer that we share the text now. */
810 b
->base_buffer
->indirections
++;
811 /* Always -1 for an indirect buffer. */
812 b
->window_count
= -1;
814 b
->pt
= b
->base_buffer
->pt
;
815 b
->begv
= b
->base_buffer
->begv
;
816 b
->zv
= b
->base_buffer
->zv
;
817 b
->pt_byte
= b
->base_buffer
->pt_byte
;
818 b
->begv_byte
= b
->base_buffer
->begv_byte
;
819 b
->zv_byte
= b
->base_buffer
->zv_byte
;
821 b
->newline_cache
= 0;
822 b
->width_run_cache
= 0;
823 b
->bidi_paragraph_cache
= 0;
824 bset_width_table (b
, Qnil
);
826 name
= Fcopy_sequence (name
);
827 set_string_intervals (name
, NULL
);
830 /* An indirect buffer shares undo list of its base (Bug#18180). */
831 bset_undo_list (b
, BVAR (b
->base_buffer
, undo_list
));
834 reset_buffer_local_variables (b
, 1);
836 /* Put this in the alist of all live buffers. */
838 Vbuffer_alist
= nconc2 (Vbuffer_alist
, list1 (Fcons (name
, buf
)));
840 bset_mark (b
, Fmake_marker ());
842 /* The multibyte status belongs to the base buffer. */
843 bset_enable_multibyte_characters
844 (b
, BVAR (b
->base_buffer
, enable_multibyte_characters
));
846 /* Make sure the base buffer has markers for its narrowing. */
847 if (NILP (BVAR (b
->base_buffer
, pt_marker
)))
849 eassert (NILP (BVAR (b
->base_buffer
, begv_marker
)));
850 eassert (NILP (BVAR (b
->base_buffer
, zv_marker
)));
852 bset_pt_marker (b
->base_buffer
,
853 build_marker (b
->base_buffer
, b
->base_buffer
->pt
,
854 b
->base_buffer
->pt_byte
));
856 bset_begv_marker (b
->base_buffer
,
857 build_marker (b
->base_buffer
, b
->base_buffer
->begv
,
858 b
->base_buffer
->begv_byte
));
860 bset_zv_marker (b
->base_buffer
,
861 build_marker (b
->base_buffer
, b
->base_buffer
->zv
,
862 b
->base_buffer
->zv_byte
));
864 XMARKER (BVAR (b
->base_buffer
, zv_marker
))->insertion_type
= 1;
869 /* Give the indirect buffer markers for its narrowing. */
870 bset_pt_marker (b
, build_marker (b
, b
->pt
, b
->pt_byte
));
871 bset_begv_marker (b
, build_marker (b
, b
->begv
, b
->begv_byte
));
872 bset_zv_marker (b
, build_marker (b
, b
->zv
, b
->zv_byte
));
873 XMARKER (BVAR (b
, zv_marker
))->insertion_type
= 1;
877 struct buffer
*old_b
= current_buffer
;
879 clone_per_buffer_values (b
->base_buffer
, b
);
880 bset_filename (b
, Qnil
);
881 bset_file_truename (b
, Qnil
);
882 bset_display_count (b
, make_number (0));
883 bset_backed_up (b
, Qnil
);
884 bset_auto_save_file_name (b
, Qnil
);
885 set_buffer_internal_1 (b
);
886 Fset (intern ("buffer-save-without-query"), Qnil
);
887 Fset (intern ("buffer-file-number"), Qnil
);
888 Fset (intern ("buffer-stale-function"), Qnil
);
889 set_buffer_internal_1 (old_b
);
892 /* Run buffer-list-update-hook. */
893 if (!NILP (Vrun_hooks
))
894 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
899 /* Mark OV as no longer associated with B. */
902 drop_overlay (struct buffer
*b
, struct Lisp_Overlay
*ov
)
904 eassert (b
== XBUFFER (Fmarker_buffer (ov
->start
)));
905 modify_overlay (b
, marker_position (ov
->start
),
906 marker_position (ov
->end
));
907 unchain_marker (XMARKER (ov
->start
));
908 unchain_marker (XMARKER (ov
->end
));
912 /* Delete all overlays of B and reset it's overlay lists. */
915 delete_all_overlays (struct buffer
*b
)
917 struct Lisp_Overlay
*ov
, *next
;
919 /* FIXME: Since each drop_overlay will scan BUF_MARKERS to unlink its
920 markers, we have an unneeded O(N^2) behavior here. */
921 for (ov
= b
->overlays_before
; ov
; ov
= next
)
923 drop_overlay (b
, ov
);
928 for (ov
= b
->overlays_after
; ov
; ov
= next
)
930 drop_overlay (b
, ov
);
935 set_buffer_overlays_before (b
, NULL
);
936 set_buffer_overlays_after (b
, NULL
);
939 /* Reinitialize everything about a buffer except its name and contents
941 If called on an already-initialized buffer, the list of overlays
942 should be deleted before calling this function, otherwise we end up
943 with overlays that claim to belong to the buffer but the buffer
944 claims it doesn't belong to it. */
947 reset_buffer (register struct buffer
*b
)
949 bset_filename (b
, Qnil
);
950 bset_file_truename (b
, Qnil
);
951 bset_directory (b
, current_buffer
? BVAR (current_buffer
, directory
) : Qnil
);
952 b
->modtime
= make_timespec (0, UNKNOWN_MODTIME_NSECS
);
953 b
->modtime_size
= -1;
954 XSETFASTINT (BVAR (b
, save_length
), 0);
955 b
->last_window_start
= 1;
956 /* It is more conservative to start out "changed" than "unchanged". */
958 b
->prevent_redisplay_optimizations_p
= 1;
959 bset_backed_up (b
, Qnil
);
960 BUF_AUTOSAVE_MODIFF (b
) = 0;
961 b
->auto_save_failure_time
= 0;
962 bset_auto_save_file_name (b
, Qnil
);
963 bset_read_only (b
, Qnil
);
964 set_buffer_overlays_before (b
, NULL
);
965 set_buffer_overlays_after (b
, NULL
);
966 b
->overlay_center
= BEG
;
967 bset_mark_active (b
, Qnil
);
968 bset_point_before_scroll (b
, Qnil
);
969 bset_file_format (b
, Qnil
);
970 bset_auto_save_file_format (b
, Qt
);
971 bset_last_selected_window (b
, Qnil
);
972 bset_display_count (b
, make_number (0));
973 bset_display_time (b
, Qnil
);
974 bset_enable_multibyte_characters
975 (b
, BVAR (&buffer_defaults
, enable_multibyte_characters
));
976 bset_cursor_type (b
, BVAR (&buffer_defaults
, cursor_type
));
977 bset_extra_line_spacing (b
, BVAR (&buffer_defaults
, extra_line_spacing
));
979 b
->display_error_modiff
= 0;
982 /* Reset buffer B's local variables info.
983 Don't use this on a buffer that has already been in use;
984 it does not treat permanent locals consistently.
985 Instead, use Fkill_all_local_variables.
987 If PERMANENT_TOO, reset permanent buffer-local variables.
988 If not, preserve those. */
991 reset_buffer_local_variables (struct buffer
*b
, bool permanent_too
)
995 /* Reset the major mode to Fundamental, together with all the
996 things that depend on the major mode.
997 default-major-mode is handled at a higher level.
998 We ignore it here. */
999 bset_major_mode (b
, Qfundamental_mode
);
1000 bset_keymap (b
, Qnil
);
1001 bset_mode_name (b
, QSFundamental
);
1002 bset_minor_modes (b
, Qnil
);
1004 /* If the standard case table has been altered and invalidated,
1005 fix up its insides first. */
1006 if (! (CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[0])
1007 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[1])
1008 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[2])))
1009 Fset_standard_case_table (Vascii_downcase_table
);
1011 bset_downcase_table (b
, Vascii_downcase_table
);
1012 bset_upcase_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[0]);
1013 bset_case_canon_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[1]);
1014 bset_case_eqv_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[2]);
1015 bset_invisibility_spec (b
, Qt
);
1017 /* Reset all (or most) per-buffer variables to their defaults. */
1019 bset_local_var_alist (b
, Qnil
);
1022 Lisp_Object tmp
, prop
, last
= Qnil
;
1023 for (tmp
= BVAR (b
, local_var_alist
); CONSP (tmp
); tmp
= XCDR (tmp
))
1024 if (!NILP (prop
= Fget (XCAR (XCAR (tmp
)), Qpermanent_local
)))
1026 /* If permanent-local, keep it. */
1028 if (EQ (prop
, Qpermanent_local_hook
))
1030 /* This is a partially permanent hook variable.
1031 Preserve only the elements that want to be preserved. */
1032 Lisp_Object list
, newlist
;
1033 list
= XCDR (XCAR (tmp
));
1037 for (newlist
= Qnil
; CONSP (list
); list
= XCDR (list
))
1039 Lisp_Object elt
= XCAR (list
);
1040 /* Preserve element ELT if it's t,
1041 if it is a function with a `permanent-local-hook' property,
1042 or if it's not a symbol. */
1045 || !NILP (Fget (elt
, Qpermanent_local_hook
)))
1046 newlist
= Fcons (elt
, newlist
);
1048 XSETCDR (XCAR (tmp
), Fnreverse (newlist
));
1051 /* Delete this local variable. */
1052 else if (NILP (last
))
1053 bset_local_var_alist (b
, XCDR (tmp
));
1055 XSETCDR (last
, XCDR (tmp
));
1058 for (i
= 0; i
< last_per_buffer_idx
; ++i
)
1059 if (permanent_too
|| buffer_permanent_local_flags
[i
] == 0)
1060 SET_PER_BUFFER_VALUE_P (b
, i
, 0);
1062 /* For each slot that has a default value, copy that into the slot. */
1063 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
1065 int idx
= PER_BUFFER_IDX (offset
);
1068 || buffer_permanent_local_flags
[idx
] == 0)))
1069 set_per_buffer_value (b
, offset
, per_buffer_default (offset
));
1073 /* We split this away from generate-new-buffer, because rename-buffer
1074 and set-visited-file-name ought to be able to use this to really
1075 rename the buffer properly. */
1077 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name
,
1078 Sgenerate_new_buffer_name
, 1, 2, 0,
1079 doc
: /* Return a string that is the name of no existing buffer based on NAME.
1080 If there is no live buffer named NAME, then return NAME.
1081 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
1082 \(starting at 2) until an unused name is found, and then return that name.
1083 Optional second argument IGNORE specifies a name that is okay to use (if
1084 it is in the sequence to be tried) even if a buffer with that name exists.
1086 If NAME begins with a space (i.e., a buffer that is not normally
1087 visible to users), then if buffer NAME already exists a random number
1088 is first appended to NAME, to speed up finding a non-existent buffer. */)
1089 (register Lisp_Object name
, Lisp_Object ignore
)
1091 register Lisp_Object gentemp
, tem
, tem2
;
1093 char number
[INT_BUFSIZE_BOUND (ptrdiff_t) + sizeof "<>"];
1095 CHECK_STRING (name
);
1097 tem
= Fstring_equal (name
, ignore
);
1100 tem
= Fget_buffer (name
);
1104 if (!strncmp (SSDATA (name
), " ", 1)) /* see bug#1229 */
1106 /* Note fileio.c:make_temp_name does random differently. */
1107 tem2
= concat2 (name
, make_formatted_string
1109 XFASTINT (Frandom (make_number (999999)))));
1110 tem
= Fget_buffer (tem2
);
1120 gentemp
= concat2 (tem2
, make_formatted_string
1121 (number
, "<%"pD
"d>", ++count
));
1122 tem
= Fstring_equal (gentemp
, ignore
);
1125 tem
= Fget_buffer (gentemp
);
1132 DEFUN ("buffer-name", Fbuffer_name
, Sbuffer_name
, 0, 1, 0,
1133 doc
: /* Return the name of BUFFER, as a string.
1134 BUFFER defaults to the current buffer.
1135 Return nil if BUFFER has been killed. */)
1136 (register Lisp_Object buffer
)
1138 return BVAR (decode_buffer (buffer
), name
);
1141 DEFUN ("buffer-file-name", Fbuffer_file_name
, Sbuffer_file_name
, 0, 1, 0,
1142 doc
: /* Return name of file BUFFER is visiting, or nil if none.
1143 No argument or nil as argument means use the current buffer. */)
1144 (register Lisp_Object buffer
)
1146 return BVAR (decode_buffer (buffer
), filename
);
1149 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer
, Sbuffer_base_buffer
,
1151 doc
: /* Return the base buffer of indirect buffer BUFFER.
1152 If BUFFER is not indirect, return nil.
1153 BUFFER defaults to the current buffer. */)
1154 (register Lisp_Object buffer
)
1156 struct buffer
*base
= decode_buffer (buffer
)->base_buffer
;
1157 return base
? (XSETBUFFER (buffer
, base
), buffer
) : Qnil
;
1160 DEFUN ("buffer-local-value", Fbuffer_local_value
,
1161 Sbuffer_local_value
, 2, 2, 0,
1162 doc
: /* Return the value of VARIABLE in BUFFER.
1163 If VARIABLE does not have a buffer-local binding in BUFFER, the value
1164 is the default binding of the variable. */)
1165 (register Lisp_Object variable
, register Lisp_Object buffer
)
1167 register Lisp_Object result
= buffer_local_value (variable
, buffer
);
1169 if (EQ (result
, Qunbound
))
1170 xsignal1 (Qvoid_variable
, variable
);
1176 /* Like Fbuffer_local_value, but return Qunbound if the variable is
1180 buffer_local_value (Lisp_Object variable
, Lisp_Object buffer
)
1182 register struct buffer
*buf
;
1183 register Lisp_Object result
;
1184 struct Lisp_Symbol
*sym
;
1186 CHECK_SYMBOL (variable
);
1187 CHECK_BUFFER (buffer
);
1188 buf
= XBUFFER (buffer
);
1189 sym
= XSYMBOL (variable
);
1192 switch (sym
->redirect
)
1194 case SYMBOL_VARALIAS
: sym
= indirect_variable (sym
); goto start
;
1195 case SYMBOL_PLAINVAL
: result
= SYMBOL_VAL (sym
); break;
1196 case SYMBOL_LOCALIZED
:
1197 { /* Look in local_var_alist. */
1198 struct Lisp_Buffer_Local_Value
*blv
= SYMBOL_BLV (sym
);
1199 XSETSYMBOL (variable
, sym
); /* Update In case of aliasing. */
1200 result
= Fassoc (variable
, BVAR (buf
, local_var_alist
));
1204 { /* What binding is loaded right now? */
1205 Lisp_Object current_alist_element
= blv
->valcell
;
1207 /* The value of the currently loaded binding is not
1208 stored in it, but rather in the realvalue slot.
1209 Store that value into the binding it belongs to
1210 in case that is the one we are about to use. */
1212 XSETCDR (current_alist_element
,
1213 do_symval_forwarding (blv
->fwd
));
1215 /* Now get the (perhaps updated) value out of the binding. */
1216 result
= XCDR (result
);
1219 result
= Fdefault_value (variable
);
1222 case SYMBOL_FORWARDED
:
1224 union Lisp_Fwd
*fwd
= SYMBOL_FWD (sym
);
1225 if (BUFFER_OBJFWDP (fwd
))
1226 result
= per_buffer_value (buf
, XBUFFER_OBJFWD (fwd
)->offset
);
1228 result
= Fdefault_value (variable
);
1231 default: emacs_abort ();
1237 /* Return an alist of the Lisp-level buffer-local bindings of
1238 buffer BUF. That is, don't include the variables maintained
1239 in special slots in the buffer object.
1240 If not CLONE, replace elements of the form (VAR . unbound)
1244 buffer_lisp_local_variables (struct buffer
*buf
, bool clone
)
1246 Lisp_Object result
= Qnil
;
1248 for (tail
= BVAR (buf
, local_var_alist
); CONSP (tail
); tail
= XCDR (tail
))
1250 Lisp_Object val
, elt
;
1254 /* Reference each variable in the alist in buf.
1255 If inquiring about the current buffer, this gets the current values,
1256 so store them into the alist so the alist is up to date.
1257 If inquiring about some other buffer, this swaps out any values
1258 for that buffer, making the alist up to date automatically. */
1259 val
= find_symbol_value (XCAR (elt
));
1260 /* Use the current buffer value only if buf is the current buffer. */
1261 if (buf
!= current_buffer
)
1264 result
= Fcons (!clone
&& EQ (val
, Qunbound
)
1266 : Fcons (XCAR (elt
), val
),
1273 DEFUN ("buffer-local-variables", Fbuffer_local_variables
,
1274 Sbuffer_local_variables
, 0, 1, 0,
1275 doc
: /* Return an alist of variables that are buffer-local in BUFFER.
1276 Most elements look like (SYMBOL . VALUE), describing one variable.
1277 For a symbol that is locally unbound, just the symbol appears in the value.
1278 Note that storing new VALUEs in these elements doesn't change the variables.
1279 No argument or nil as argument means use current buffer as BUFFER. */)
1280 (Lisp_Object buffer
)
1282 struct buffer
*buf
= decode_buffer (buffer
);
1283 Lisp_Object result
= buffer_lisp_local_variables (buf
, 0);
1285 /* Add on all the variables stored in special slots. */
1289 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
1291 idx
= PER_BUFFER_IDX (offset
);
1292 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
1293 && SYMBOLP (PER_BUFFER_SYMBOL (offset
)))
1295 Lisp_Object sym
= PER_BUFFER_SYMBOL (offset
);
1296 Lisp_Object val
= per_buffer_value (buf
, offset
);
1297 result
= Fcons (EQ (val
, Qunbound
) ? sym
: Fcons (sym
, val
),
1306 DEFUN ("buffer-modified-p", Fbuffer_modified_p
, Sbuffer_modified_p
,
1308 doc
: /* Return t if BUFFER was modified since its file was last read or saved.
1309 No argument or nil as argument means use current buffer as BUFFER. */)
1310 (Lisp_Object buffer
)
1312 struct buffer
*buf
= decode_buffer (buffer
);
1313 return BUF_SAVE_MODIFF (buf
) < BUF_MODIFF (buf
) ? Qt
: Qnil
;
1316 DEFUN ("force-mode-line-update", Fforce_mode_line_update
,
1317 Sforce_mode_line_update
, 0, 1, 0,
1318 doc
: /* Force redisplay of the current buffer's mode line and header line.
1319 With optional non-nil ALL, force redisplay of all mode lines and
1320 header lines. This function also forces recomputation of the
1321 menu bar menus and the frame title. */)
1326 update_mode_lines
= 10;
1327 /* FIXME: This can't be right. */
1328 current_buffer
->prevent_redisplay_optimizations_p
= true;
1330 else if (buffer_window_count (current_buffer
))
1332 bset_update_mode_line (current_buffer
);
1333 current_buffer
->prevent_redisplay_optimizations_p
= true;
1338 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p
, Sset_buffer_modified_p
,
1340 doc
: /* Mark current buffer as modified or unmodified according to FLAG.
1341 A non-nil FLAG means mark the buffer modified. */)
1344 Frestore_buffer_modified_p (flag
);
1346 /* Set update_mode_lines only if buffer is displayed in some window.
1347 Packages like jit-lock or lazy-lock preserve a buffer's modified
1348 state by recording/restoring the state around blocks of code.
1349 Setting update_mode_lines makes redisplay consider all windows
1350 (on all frames). Stealth fontification of buffers not displayed
1351 would incur additional redisplay costs if we'd set
1352 update_modes_lines unconditionally.
1354 Ideally, I think there should be another mechanism for fontifying
1355 buffers without "modifying" buffers, or redisplay should be
1356 smarter about updating the `*' in mode lines. --gerd */
1357 return Fforce_mode_line_update (Qnil
);
1360 DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p
,
1361 Srestore_buffer_modified_p
, 1, 1, 0,
1362 doc
: /* Like `set-buffer-modified-p', with a difference concerning redisplay.
1363 It is not ensured that mode lines will be updated to show the modified
1364 state of the current buffer. Use with care. */)
1369 /* If buffer becoming modified, lock the file.
1370 If buffer becoming unmodified, unlock the file. */
1372 struct buffer
*b
= current_buffer
->base_buffer
1373 ? current_buffer
->base_buffer
1376 fn
= BVAR (b
, file_truename
);
1377 /* Test buffer-file-name so that binding it to nil is effective. */
1378 if (!NILP (fn
) && ! NILP (BVAR (b
, filename
)))
1380 bool already
= SAVE_MODIFF
< MODIFF
;
1381 if (!already
&& !NILP (flag
))
1383 else if (already
&& NILP (flag
))
1387 /* Here we have a problem. SAVE_MODIFF is used here to encode
1388 buffer-modified-p (as SAVE_MODIFF<MODIFF) as well as
1389 recent-auto-save-p (as SAVE_MODIFF<auto_save_modified). So if we
1390 modify SAVE_MODIFF to affect one, we may affect the other
1392 E.g. if FLAG is nil we need to set SAVE_MODIFF to MODIFF, but
1393 if SAVE_MODIFF<auto_save_modified that means we risk changing
1394 recent-auto-save-p from t to nil.
1395 Vice versa, if FLAG is non-nil and SAVE_MODIFF>=auto_save_modified
1396 we risk changing recent-auto-save-p from nil to t. */
1397 SAVE_MODIFF
= (NILP (flag
)
1398 /* FIXME: This unavoidably sets recent-auto-save-p to nil. */
1400 /* Let's try to preserve recent-auto-save-p. */
1401 : SAVE_MODIFF
< MODIFF
? SAVE_MODIFF
1402 /* If SAVE_MODIFF == auto_save_modified == MODIFF,
1403 we can either decrease SAVE_MODIFF and auto_save_modified
1404 or increase MODIFF. */
1410 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick
, Sbuffer_modified_tick
,
1412 doc
: /* Return BUFFER's tick counter, incremented for each change in text.
1413 Each buffer has a tick counter which is incremented each time the
1414 text in that buffer is changed. It wraps around occasionally.
1415 No argument or nil as argument means use current buffer as BUFFER. */)
1416 (register Lisp_Object buffer
)
1418 return make_number (BUF_MODIFF (decode_buffer (buffer
)));
1421 DEFUN ("buffer-chars-modified-tick", Fbuffer_chars_modified_tick
,
1422 Sbuffer_chars_modified_tick
, 0, 1, 0,
1423 doc
: /* Return BUFFER's character-change tick counter.
1424 Each buffer has a character-change tick counter, which is set to the
1425 value of the buffer's tick counter \(see `buffer-modified-tick'), each
1426 time text in that buffer is inserted or deleted. By comparing the
1427 values returned by two individual calls of `buffer-chars-modified-tick',
1428 you can tell whether a character change occurred in that buffer in
1429 between these calls. No argument or nil as argument means use current
1430 buffer as BUFFER. */)
1431 (register Lisp_Object buffer
)
1433 return make_number (BUF_CHARS_MODIFF (decode_buffer (buffer
)));
1436 DEFUN ("rename-buffer", Frename_buffer
, Srename_buffer
, 1, 2,
1437 "(list (read-string \"Rename buffer (to new name): \" \
1438 nil 'buffer-name-history (buffer-name (current-buffer))) \
1439 current-prefix-arg)",
1440 doc
: /* Change current buffer's name to NEWNAME (a string).
1441 If second arg UNIQUE is nil or omitted, it is an error if a
1442 buffer named NEWNAME already exists.
1443 If UNIQUE is non-nil, come up with a new name using
1444 `generate-new-buffer-name'.
1445 Interactively, you can set UNIQUE with a prefix argument.
1446 We return the name we actually gave the buffer.
1447 This does not change the name of the visited file (if any). */)
1448 (register Lisp_Object newname
, Lisp_Object unique
)
1450 register Lisp_Object tem
, buf
;
1452 CHECK_STRING (newname
);
1454 if (SCHARS (newname
) == 0)
1455 error ("Empty string is invalid as a buffer name");
1457 tem
= Fget_buffer (newname
);
1460 /* Don't short-circuit if UNIQUE is t. That is a useful way to
1461 rename the buffer automatically so you can create another
1462 with the original name. It makes UNIQUE equivalent to
1463 (rename-buffer (generate-new-buffer-name NEWNAME)). */
1464 if (NILP (unique
) && XBUFFER (tem
) == current_buffer
)
1465 return BVAR (current_buffer
, name
);
1467 newname
= Fgenerate_new_buffer_name (newname
, BVAR (current_buffer
, name
));
1469 error ("Buffer name `%s' is in use", SDATA (newname
));
1472 bset_name (current_buffer
, newname
);
1474 /* Catch redisplay's attention. Unless we do this, the mode lines for
1475 any windows displaying current_buffer will stay unchanged. */
1476 update_mode_lines
= 11;
1478 XSETBUFFER (buf
, current_buffer
);
1479 Fsetcar (Frassq (buf
, Vbuffer_alist
), newname
);
1480 if (NILP (BVAR (current_buffer
, filename
))
1481 && !NILP (BVAR (current_buffer
, auto_save_file_name
)))
1482 call0 (intern ("rename-auto-save-file"));
1484 /* Run buffer-list-update-hook. */
1485 if (!NILP (Vrun_hooks
))
1486 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1488 /* Refetch since that last call may have done GC. */
1489 return BVAR (current_buffer
, name
);
1492 /* True if B can be used as 'other-than-BUFFER' buffer. */
1495 candidate_buffer (Lisp_Object b
, Lisp_Object buffer
)
1497 return (BUFFERP (b
) && !EQ (b
, buffer
)
1498 && BUFFER_LIVE_P (XBUFFER (b
))
1499 && !BUFFER_HIDDEN_P (XBUFFER (b
)));
1502 DEFUN ("other-buffer", Fother_buffer
, Sother_buffer
, 0, 3, 0,
1503 doc
: /* Return most recently selected buffer other than BUFFER.
1504 Buffers not visible in windows are preferred to visible buffers, unless
1505 optional second argument VISIBLE-OK is non-nil. Ignore the argument
1506 BUFFER unless it denotes a live buffer. If the optional third argument
1507 FRAME is non-nil, use that frame's buffer list instead of the selected
1508 frame's buffer list.
1510 The buffer is found by scanning the selected or specified frame's buffer
1511 list first, followed by the list of all buffers. If no other buffer
1512 exists, return the buffer `*scratch*' (creating it if necessary). */)
1513 (Lisp_Object buffer
, Lisp_Object visible_ok
, Lisp_Object frame
)
1515 struct frame
*f
= decode_any_frame (frame
);
1516 Lisp_Object tail
= f
->buffer_list
, pred
= f
->buffer_predicate
;
1517 Lisp_Object buf
, notsogood
= Qnil
;
1519 /* Consider buffers that have been seen in the frame first. */
1520 for (; CONSP (tail
); tail
= XCDR (tail
))
1523 if (candidate_buffer (buf
, buffer
)
1524 /* If the frame has a buffer_predicate, disregard buffers that
1525 don't fit the predicate. */
1526 && (NILP (pred
) || !NILP (call1 (pred
, buf
))))
1528 if (!NILP (visible_ok
)
1529 || NILP (Fget_buffer_window (buf
, Qvisible
)))
1531 else if (NILP (notsogood
))
1536 /* Consider alist of all buffers next. */
1537 FOR_EACH_LIVE_BUFFER (tail
, buf
)
1539 if (candidate_buffer (buf
, buffer
)
1540 /* If the frame has a buffer_predicate, disregard buffers that
1541 don't fit the predicate. */
1542 && (NILP (pred
) || !NILP (call1 (pred
, buf
))))
1544 if (!NILP (visible_ok
)
1545 || NILP (Fget_buffer_window (buf
, Qvisible
)))
1547 else if (NILP (notsogood
))
1552 if (!NILP (notsogood
))
1556 AUTO_STRING (scratch
, "*scratch*");
1557 buf
= Fget_buffer (scratch
);
1560 buf
= Fget_buffer_create (scratch
);
1561 Fset_buffer_major_mode (buf
);
1567 /* The following function is a safe variant of Fother_buffer: It doesn't
1568 pay attention to any frame-local buffer lists, doesn't care about
1569 visibility of buffers, and doesn't evaluate any frame predicates. */
1572 other_buffer_safely (Lisp_Object buffer
)
1574 Lisp_Object tail
, buf
;
1576 FOR_EACH_LIVE_BUFFER (tail
, buf
)
1577 if (candidate_buffer (buf
, buffer
))
1580 AUTO_STRING (scratch
, "*scratch*");
1581 buf
= Fget_buffer (scratch
);
1584 buf
= Fget_buffer_create (scratch
);
1585 Fset_buffer_major_mode (buf
);
1591 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo
, Sbuffer_enable_undo
,
1593 doc
: /* Start keeping undo information for buffer BUFFER.
1594 No argument or nil as argument means do this for the current buffer. */)
1595 (register Lisp_Object buffer
)
1597 Lisp_Object real_buffer
;
1600 XSETBUFFER (real_buffer
, current_buffer
);
1603 real_buffer
= Fget_buffer (buffer
);
1604 if (NILP (real_buffer
))
1608 if (EQ (BVAR (XBUFFER (real_buffer
), undo_list
), Qt
))
1609 bset_undo_list (XBUFFER (real_buffer
), Qnil
);
1614 /* Truncate undo list and shrink the gap of BUFFER. */
1617 compact_buffer (struct buffer
*buffer
)
1619 BUFFER_CHECK_INDIRECTION (buffer
);
1621 /* Skip dead buffers, indirect buffers and buffers
1622 which aren't changed since last compaction. */
1623 if (BUFFER_LIVE_P (buffer
)
1624 && (buffer
->base_buffer
== NULL
)
1625 && (BUF_COMPACT (buffer
) != BUF_MODIFF (buffer
)))
1627 /* If a buffer's undo list is Qt, that means that undo is
1628 turned off in that buffer. Calling truncate_undo_list on
1629 Qt tends to return NULL, which effectively turns undo back on.
1630 So don't call truncate_undo_list if undo_list is Qt. */
1631 if (!EQ (buffer
->INTERNAL_FIELD (undo_list
), Qt
))
1632 truncate_undo_list (buffer
);
1634 /* Shrink buffer gaps. */
1635 if (!buffer
->text
->inhibit_shrinking
)
1637 /* If a buffer's gap size is more than 10% of the buffer
1638 size, or larger than GAP_BYTES_DFL bytes, then shrink it
1639 accordingly. Keep a minimum size of GAP_BYTES_MIN bytes. */
1640 ptrdiff_t size
= clip_to_bounds (GAP_BYTES_MIN
,
1641 BUF_Z_BYTE (buffer
) / 10,
1643 if (BUF_GAP_SIZE (buffer
) > size
)
1644 make_gap_1 (buffer
, -(BUF_GAP_SIZE (buffer
) - size
));
1646 BUF_COMPACT (buffer
) = BUF_MODIFF (buffer
);
1650 DEFUN ("kill-buffer", Fkill_buffer
, Skill_buffer
, 0, 1, "bKill buffer: ",
1651 doc
: /* Kill the buffer specified by BUFFER-OR-NAME.
1652 The argument may be a buffer or the name of an existing buffer.
1653 Argument nil or omitted means kill the current buffer. Return t if the
1654 buffer is actually killed, nil otherwise.
1656 The functions in `kill-buffer-query-functions' are called with the
1657 buffer to be killed as the current buffer. If any of them returns nil,
1658 the buffer is not killed. The hook `kill-buffer-hook' is run before the
1659 buffer is actually killed. The buffer being killed will be current
1660 while the hook is running. Functions called by any of these hooks are
1661 supposed to not change the current buffer.
1663 Any processes that have this buffer as the `process-buffer' are killed
1664 with SIGHUP. This function calls `replace-buffer-in-windows' for
1665 cleaning up all windows currently displaying the buffer to be killed. */)
1666 (Lisp_Object buffer_or_name
)
1669 register struct buffer
*b
;
1670 register Lisp_Object tem
;
1671 register struct Lisp_Marker
*m
;
1672 struct gcpro gcpro1
;
1674 if (NILP (buffer_or_name
))
1675 buffer
= Fcurrent_buffer ();
1677 buffer
= Fget_buffer (buffer_or_name
);
1679 nsberror (buffer_or_name
);
1681 b
= XBUFFER (buffer
);
1683 /* Avoid trouble for buffer already dead. */
1684 if (!BUFFER_LIVE_P (b
))
1687 /* Run hooks with the buffer to be killed the current buffer. */
1689 ptrdiff_t count
= SPECPDL_INDEX ();
1690 Lisp_Object arglist
[1];
1692 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1693 set_buffer_internal (b
);
1695 /* First run the query functions; if any query is answered no,
1696 don't kill the buffer. */
1697 arglist
[0] = Qkill_buffer_query_functions
;
1698 tem
= Frun_hook_with_args_until_failure (1, arglist
);
1700 return unbind_to (count
, Qnil
);
1702 /* Query if the buffer is still modified. */
1703 if (INTERACTIVE
&& !NILP (BVAR (b
, filename
))
1704 && BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
1707 tem
= do_yes_or_no_p (format2 ("Buffer %s modified; kill anyway? ",
1708 BVAR (b
, name
), make_number (0)));
1711 return unbind_to (count
, Qnil
);
1714 /* If the hooks have killed the buffer, exit now. */
1715 if (!BUFFER_LIVE_P (b
))
1716 return unbind_to (count
, Qt
);
1718 /* Then run the hooks. */
1719 Frun_hooks (1, &Qkill_buffer_hook
);
1720 unbind_to (count
, Qnil
);
1723 /* If the hooks have killed the buffer, exit now. */
1724 if (!BUFFER_LIVE_P (b
))
1727 /* We have no more questions to ask. Verify that it is valid
1728 to kill the buffer. This must be done after the questions
1729 since anything can happen within do_yes_or_no_p. */
1731 /* Don't kill the minibuffer now current. */
1732 if (EQ (buffer
, XWINDOW (minibuf_window
)->contents
))
1735 /* When we kill an ordinary buffer which shares it's buffer text
1736 with indirect buffer(s), we must kill indirect buffer(s) too.
1737 We do it at this stage so nothing terrible happens if they
1738 ask questions or their hooks get errors. */
1739 if (!b
->base_buffer
&& b
->indirections
> 0)
1741 struct buffer
*other
;
1745 FOR_EACH_BUFFER (other
)
1746 if (other
->base_buffer
== b
)
1749 XSETBUFFER (buf
, other
);
1755 /* Exit if we now have killed the base buffer (Bug#11665). */
1756 if (!BUFFER_LIVE_P (b
))
1760 /* Run replace_buffer_in_windows before making another buffer current
1761 since set-window-buffer-start-and-point will refuse to make another
1762 buffer current if the selected window does not show the current
1763 buffer (bug#10114). */
1764 replace_buffer_in_windows (buffer
);
1766 /* Exit if replacing the buffer in windows has killed our buffer. */
1767 if (!BUFFER_LIVE_P (b
))
1770 /* Make this buffer not be current. Exit if it is the sole visible
1772 if (b
== current_buffer
)
1774 tem
= Fother_buffer (buffer
, Qnil
, Qnil
);
1776 if (b
== current_buffer
)
1780 /* If the buffer now current is shown in the minibuffer and our buffer
1781 is the sole other buffer give up. */
1782 XSETBUFFER (tem
, current_buffer
);
1783 if (EQ (tem
, XWINDOW (minibuf_window
)->contents
)
1784 && EQ (buffer
, Fother_buffer (buffer
, Qnil
, Qnil
)))
1787 /* Now there is no question: we can kill the buffer. */
1789 /* Unlock this buffer's file, if it is locked. */
1793 kill_buffer_processes (buffer
);
1796 /* Killing buffer processes may run sentinels which may have killed
1798 if (!BUFFER_LIVE_P (b
))
1801 /* These may run Lisp code and into infinite loops (if someone
1802 insisted on circular lists) so allow quitting here. */
1803 frames_discard_buffer (buffer
);
1805 clear_charpos_cache (b
);
1807 tem
= Vinhibit_quit
;
1809 /* Remove the buffer from the list of all buffers. */
1810 Vbuffer_alist
= Fdelq (Frassq (buffer
, Vbuffer_alist
), Vbuffer_alist
);
1811 /* If replace_buffer_in_windows didn't do its job fix that now. */
1812 replace_buffer_in_windows_safely (buffer
);
1813 Vinhibit_quit
= tem
;
1815 /* Delete any auto-save file, if we saved it in this session.
1816 But not if the buffer is modified. */
1817 if (STRINGP (BVAR (b
, auto_save_file_name
))
1818 && BUF_AUTOSAVE_MODIFF (b
) != 0
1819 && BUF_SAVE_MODIFF (b
) < BUF_AUTOSAVE_MODIFF (b
)
1820 && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
)
1821 && NILP (Fsymbol_value (intern ("auto-save-visited-file-name"))))
1824 delete = Fsymbol_value (intern ("delete-auto-save-files"));
1825 if (! NILP (delete))
1826 internal_delete_file (BVAR (b
, auto_save_file_name
));
1829 /* Deleting an auto-save file could have killed our buffer. */
1830 if (!BUFFER_LIVE_P (b
))
1836 /* Unchain all markers that belong to this indirect buffer.
1837 Don't unchain the markers that belong to the base buffer
1838 or its other indirect buffers. */
1839 struct Lisp_Marker
**mp
= &BUF_MARKERS (b
);
1850 /* Intervals should be owned by the base buffer (Bug#16502). */
1851 i
= buffer_intervals (b
);
1855 XSETBUFFER (owner
, b
->base_buffer
);
1856 set_interval_object (i
, owner
);
1861 /* Unchain all markers of this buffer and its indirect buffers.
1862 and leave them pointing nowhere. */
1863 for (m
= BUF_MARKERS (b
); m
; )
1865 struct Lisp_Marker
*next
= m
->next
;
1870 BUF_MARKERS (b
) = NULL
;
1871 set_buffer_intervals (b
, NULL
);
1873 /* Perhaps we should explicitly free the interval tree here... */
1875 /* Since we've unlinked the markers, the overlays can't be here any more
1877 b
->overlays_before
= NULL
;
1878 b
->overlays_after
= NULL
;
1880 /* Reset the local variables, so that this buffer's local values
1881 won't be protected from GC. They would be protected
1882 if they happened to remain cached in their symbols.
1883 This gets rid of them for certain. */
1884 swap_out_buffer_local_variables (b
);
1885 reset_buffer_local_variables (b
, 1);
1887 bset_name (b
, Qnil
);
1892 /* Notify our base buffer that we don't share the text anymore. */
1893 eassert (b
->indirections
== -1);
1894 b
->base_buffer
->indirections
--;
1895 eassert (b
->base_buffer
->indirections
>= 0);
1896 /* Make sure that we wasn't confused. */
1897 eassert (b
->window_count
== -1);
1901 /* Make sure that no one shows us. */
1902 eassert (b
->window_count
== 0);
1903 /* No one shares our buffer text, can free it. */
1904 free_buffer_text (b
);
1907 if (b
->newline_cache
)
1909 free_region_cache (b
->newline_cache
);
1910 b
->newline_cache
= 0;
1912 if (b
->width_run_cache
)
1914 free_region_cache (b
->width_run_cache
);
1915 b
->width_run_cache
= 0;
1917 if (b
->bidi_paragraph_cache
)
1919 free_region_cache (b
->bidi_paragraph_cache
);
1920 b
->bidi_paragraph_cache
= 0;
1922 bset_width_table (b
, Qnil
);
1924 bset_undo_list (b
, Qnil
);
1926 /* Run buffer-list-update-hook. */
1927 if (!NILP (Vrun_hooks
))
1928 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1933 /* Move association for BUFFER to the front of buffer (a)lists. Since
1934 we do this each time BUFFER is selected visibly, the more recently
1935 selected buffers are always closer to the front of those lists. This
1936 means that other_buffer is more likely to choose a relevant buffer.
1938 Note that this moves BUFFER to the front of the buffer lists of the
1939 selected frame even if BUFFER is not shown there. If BUFFER is not
1940 shown in the selected frame, consider the present behavior a feature.
1941 `select-window' gets this right since it shows BUFFER in the selected
1942 window when calling us. */
1945 record_buffer (Lisp_Object buffer
)
1947 Lisp_Object aelt
, aelt_cons
, tem
;
1948 register struct frame
*f
= XFRAME (selected_frame
);
1950 CHECK_BUFFER (buffer
);
1952 /* Update Vbuffer_alist (we know that it has an entry for BUFFER).
1953 Don't allow quitting since this might leave the buffer list in an
1954 inconsistent state. */
1955 tem
= Vinhibit_quit
;
1957 aelt
= Frassq (buffer
, Vbuffer_alist
);
1958 aelt_cons
= Fmemq (aelt
, Vbuffer_alist
);
1959 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
1960 XSETCDR (aelt_cons
, Vbuffer_alist
);
1961 Vbuffer_alist
= aelt_cons
;
1962 Vinhibit_quit
= tem
;
1964 /* Update buffer list of selected frame. */
1965 fset_buffer_list (f
, Fcons (buffer
, Fdelq (buffer
, f
->buffer_list
)));
1966 fset_buried_buffer_list (f
, Fdelq (buffer
, f
->buried_buffer_list
));
1968 /* Run buffer-list-update-hook. */
1969 if (!NILP (Vrun_hooks
))
1970 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1974 /* Move BUFFER to the end of the buffer (a)lists. Do nothing if the
1975 buffer is killed. For the selected frame's buffer list this moves
1976 BUFFER to its end even if it was never shown in that frame. If
1977 this happens we have a feature, hence `bury-buffer-internal' should be
1978 called only when BUFFER was shown in the selected frame. */
1980 DEFUN ("bury-buffer-internal", Fbury_buffer_internal
, Sbury_buffer_internal
,
1982 doc
: /* Move BUFFER to the end of the buffer list. */)
1983 (Lisp_Object buffer
)
1985 Lisp_Object aelt
, aelt_cons
, tem
;
1986 register struct frame
*f
= XFRAME (selected_frame
);
1988 CHECK_BUFFER (buffer
);
1990 /* Update Vbuffer_alist (we know that it has an entry for BUFFER).
1991 Don't allow quitting since this might leave the buffer list in an
1992 inconsistent state. */
1993 tem
= Vinhibit_quit
;
1995 aelt
= Frassq (buffer
, Vbuffer_alist
);
1996 aelt_cons
= Fmemq (aelt
, Vbuffer_alist
);
1997 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
1998 XSETCDR (aelt_cons
, Qnil
);
1999 Vbuffer_alist
= nconc2 (Vbuffer_alist
, aelt_cons
);
2000 Vinhibit_quit
= tem
;
2002 /* Update buffer lists of selected frame. */
2003 fset_buffer_list (f
, Fdelq (buffer
, f
->buffer_list
));
2004 fset_buried_buffer_list
2005 (f
, Fcons (buffer
, Fdelq (buffer
, f
->buried_buffer_list
)));
2007 /* Run buffer-list-update-hook. */
2008 if (!NILP (Vrun_hooks
))
2009 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
2014 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode
, Sset_buffer_major_mode
, 1, 1, 0,
2015 doc
: /* Set an appropriate major mode for BUFFER.
2016 For the *scratch* buffer, use `initial-major-mode', otherwise choose a mode
2017 according to the default value of `major-mode'.
2018 Use this function before selecting the buffer, since it may need to inspect
2019 the current buffer's major mode. */)
2020 (Lisp_Object buffer
)
2023 Lisp_Object function
;
2025 CHECK_BUFFER (buffer
);
2027 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
2028 error ("Attempt to set major mode for a dead buffer");
2030 if (strcmp (SSDATA (BVAR (XBUFFER (buffer
), name
)), "*scratch*") == 0)
2031 function
= find_symbol_value (intern ("initial-major-mode"));
2034 function
= BVAR (&buffer_defaults
, major_mode
);
2036 && NILP (Fget (BVAR (current_buffer
, major_mode
), Qmode_class
)))
2037 function
= BVAR (current_buffer
, major_mode
);
2040 if (NILP (function
) || EQ (function
, Qfundamental_mode
))
2043 count
= SPECPDL_INDEX ();
2045 /* To select a nonfundamental mode,
2046 select the buffer temporarily and then call the mode function. */
2048 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2050 Fset_buffer (buffer
);
2053 return unbind_to (count
, Qnil
);
2056 DEFUN ("current-buffer", Fcurrent_buffer
, Scurrent_buffer
, 0, 0, 0,
2057 doc
: /* Return the current buffer as a Lisp object. */)
2060 register Lisp_Object buf
;
2061 XSETBUFFER (buf
, current_buffer
);
2065 /* Set the current buffer to B, and do not set windows_or_buffers_changed.
2066 This is used by redisplay. */
2069 set_buffer_internal_1 (register struct buffer
*b
)
2071 register struct buffer
*old_buf
;
2072 register Lisp_Object tail
;
2074 #ifdef USE_MMAP_FOR_BUFFERS
2075 if (b
->text
->beg
== NULL
)
2076 enlarge_buffer_text (b
, 0);
2077 #endif /* USE_MMAP_FOR_BUFFERS */
2079 if (current_buffer
== b
)
2082 BUFFER_CHECK_INDIRECTION (b
);
2084 old_buf
= current_buffer
;
2086 last_known_column_point
= -1; /* Invalidate indentation cache. */
2090 /* Put the undo list back in the base buffer, so that it appears
2091 that an indirect buffer shares the undo list of its base. */
2092 if (old_buf
->base_buffer
)
2093 bset_undo_list (old_buf
->base_buffer
, BVAR (old_buf
, undo_list
));
2095 /* If the old current buffer has markers to record PT, BEGV and ZV
2096 when it is not current, update them now. */
2097 record_buffer_markers (old_buf
);
2100 /* Get the undo list from the base buffer, so that it appears
2101 that an indirect buffer shares the undo list of its base. */
2103 bset_undo_list (b
, BVAR (b
->base_buffer
, undo_list
));
2105 /* If the new current buffer has markers to record PT, BEGV and ZV
2106 when it is not current, fetch them now. */
2107 fetch_buffer_markers (b
);
2109 /* Look down buffer's list of local Lisp variables
2110 to find and update any that forward into C variables. */
2114 for (tail
= BVAR (b
, local_var_alist
); CONSP (tail
); tail
= XCDR (tail
))
2116 Lisp_Object var
= XCAR (XCAR (tail
));
2117 struct Lisp_Symbol
*sym
= XSYMBOL (var
);
2118 if (sym
->redirect
== SYMBOL_LOCALIZED
/* Just to be sure. */
2119 && SYMBOL_BLV (sym
)->fwd
)
2120 /* Just reference the variable
2121 to cause it to become set for this buffer. */
2122 Fsymbol_value (var
);
2125 /* Do the same with any others that were local to the previous buffer */
2126 while (b
!= old_buf
&& (b
= old_buf
, b
));
2129 /* Switch to buffer B temporarily for redisplay purposes.
2130 This avoids certain things that don't need to be done within redisplay. */
2133 set_buffer_temp (struct buffer
*b
)
2135 register struct buffer
*old_buf
;
2137 if (current_buffer
== b
)
2140 old_buf
= current_buffer
;
2143 /* If the old current buffer has markers to record PT, BEGV and ZV
2144 when it is not current, update them now. */
2145 record_buffer_markers (old_buf
);
2147 /* If the new current buffer has markers to record PT, BEGV and ZV
2148 when it is not current, fetch them now. */
2149 fetch_buffer_markers (b
);
2152 DEFUN ("set-buffer", Fset_buffer
, Sset_buffer
, 1, 1, 0,
2153 doc
: /* Make buffer BUFFER-OR-NAME current for editing operations.
2154 BUFFER-OR-NAME may be a buffer or the name of an existing buffer.
2155 See also `with-current-buffer' when you want to make a buffer current
2156 temporarily. This function does not display the buffer, so its effect
2157 ends when the current command terminates. Use `switch-to-buffer' or
2158 `pop-to-buffer' to switch buffers permanently.
2159 The return value is the buffer made current. */)
2160 (register Lisp_Object buffer_or_name
)
2162 register Lisp_Object buffer
;
2163 buffer
= Fget_buffer (buffer_or_name
);
2165 nsberror (buffer_or_name
);
2166 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
2167 error ("Selecting deleted buffer");
2168 set_buffer_internal (XBUFFER (buffer
));
2173 restore_buffer (Lisp_Object buffer_or_name
)
2175 Fset_buffer (buffer_or_name
);
2178 /* Set the current buffer to BUFFER provided if it is alive. */
2181 set_buffer_if_live (Lisp_Object buffer
)
2183 if (BUFFER_LIVE_P (XBUFFER (buffer
)))
2184 set_buffer_internal (XBUFFER (buffer
));
2187 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only
,
2188 Sbarf_if_buffer_read_only
, 0, 1, 0,
2189 doc
: /* Signal a `buffer-read-only' error if the current buffer is read-only.
2190 If the text under POSITION (which defaults to point) has the
2191 `inhibit-read-only' text property set, the error will not be raised. */)
2195 XSETFASTINT (pos
, PT
);
2199 if (!NILP (BVAR (current_buffer
, read_only
))
2200 && NILP (Vinhibit_read_only
)
2201 && NILP (Fget_text_property (pos
, Qinhibit_read_only
, Qnil
)))
2202 xsignal1 (Qbuffer_read_only
, Fcurrent_buffer ());
2206 DEFUN ("erase-buffer", Ferase_buffer
, Serase_buffer
, 0, 0, "*",
2207 doc
: /* Delete the entire contents of the current buffer.
2208 Any narrowing restriction in effect (see `narrow-to-region') is removed,
2209 so the buffer is truly empty after this. */)
2216 current_buffer
->last_window_start
= 1;
2217 /* Prevent warnings, or suspension of auto saving, that would happen
2218 if future size is less than past size. Use of erase-buffer
2219 implies that the future text is not really related to the past text. */
2220 XSETFASTINT (BVAR (current_buffer
, save_length
), 0);
2225 validate_region (register Lisp_Object
*b
, register Lisp_Object
*e
)
2227 CHECK_NUMBER_COERCE_MARKER (*b
);
2228 CHECK_NUMBER_COERCE_MARKER (*e
);
2230 if (XINT (*b
) > XINT (*e
))
2233 tem
= *b
; *b
= *e
; *e
= tem
;
2236 if (! (BEGV
<= XINT (*b
) && XINT (*e
) <= ZV
))
2237 args_out_of_range_3 (Fcurrent_buffer (), *b
, *e
);
2240 /* Advance BYTE_POS up to a character boundary
2241 and return the adjusted position. */
2244 advance_to_char_boundary (ptrdiff_t byte_pos
)
2248 if (byte_pos
== BEG
)
2249 /* Beginning of buffer is always a character boundary. */
2252 c
= FETCH_BYTE (byte_pos
);
2253 if (! CHAR_HEAD_P (c
))
2255 /* We should advance BYTE_POS only when C is a constituent of a
2256 multibyte sequence. */
2257 ptrdiff_t orig_byte_pos
= byte_pos
;
2262 c
= FETCH_BYTE (byte_pos
);
2264 while (! CHAR_HEAD_P (c
) && byte_pos
> BEG
);
2266 if (byte_pos
< orig_byte_pos
)
2267 byte_pos
= orig_byte_pos
;
2268 /* If C is a constituent of a multibyte sequence, BYTE_POS was
2269 surely advance to the correct character boundary. If C is
2270 not, BYTE_POS was unchanged. */
2276 DEFUN ("buffer-swap-text", Fbuffer_swap_text
, Sbuffer_swap_text
,
2278 doc
: /* Swap the text between current buffer and BUFFER. */)
2279 (Lisp_Object buffer
)
2281 struct buffer
*other_buffer
;
2282 CHECK_BUFFER (buffer
);
2283 other_buffer
= XBUFFER (buffer
);
2285 if (!BUFFER_LIVE_P (other_buffer
))
2286 error ("Cannot swap a dead buffer's text");
2288 /* Actually, it probably works just fine.
2289 * if (other_buffer == current_buffer)
2290 * error ("Cannot swap a buffer's text with itself"); */
2292 /* Actually, this may be workable as well, tho probably only if they're
2294 if (other_buffer
->base_buffer
2295 || current_buffer
->base_buffer
)
2296 error ("Cannot swap indirect buffers's text");
2298 { /* This is probably harder to make work. */
2299 struct buffer
*other
;
2300 FOR_EACH_BUFFER (other
)
2301 if (other
->base_buffer
== other_buffer
2302 || other
->base_buffer
== current_buffer
)
2303 error ("One of the buffers to swap has indirect buffers");
2306 #define swapfield(field, type) \
2308 type tmp##field = other_buffer->field; \
2309 other_buffer->field = current_buffer->field; \
2310 current_buffer->field = tmp##field; \
2312 #define swapfield_(field, type) \
2314 type tmp##field = BVAR (other_buffer, field); \
2315 bset_##field (other_buffer, BVAR (current_buffer, field)); \
2316 bset_##field (current_buffer, tmp##field); \
2319 swapfield (own_text
, struct buffer_text
);
2320 eassert (current_buffer
->text
== ¤t_buffer
->own_text
);
2321 eassert (other_buffer
->text
== &other_buffer
->own_text
);
2323 r_alloc_reset_variable ((void **) ¤t_buffer
->own_text
.beg
,
2324 (void **) &other_buffer
->own_text
.beg
);
2325 r_alloc_reset_variable ((void **) &other_buffer
->own_text
.beg
,
2326 (void **) ¤t_buffer
->own_text
.beg
);
2327 #endif /* REL_ALLOC */
2329 swapfield (pt
, ptrdiff_t);
2330 swapfield (pt_byte
, ptrdiff_t);
2331 swapfield (begv
, ptrdiff_t);
2332 swapfield (begv_byte
, ptrdiff_t);
2333 swapfield (zv
, ptrdiff_t);
2334 swapfield (zv_byte
, ptrdiff_t);
2335 eassert (!current_buffer
->base_buffer
);
2336 eassert (!other_buffer
->base_buffer
);
2337 swapfield (indirections
, ptrdiff_t);
2338 current_buffer
->clip_changed
= 1; other_buffer
->clip_changed
= 1;
2339 swapfield (newline_cache
, struct region_cache
*);
2340 swapfield (width_run_cache
, struct region_cache
*);
2341 swapfield (bidi_paragraph_cache
, struct region_cache
*);
2342 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2343 other_buffer
->prevent_redisplay_optimizations_p
= 1;
2344 swapfield (overlays_before
, struct Lisp_Overlay
*);
2345 swapfield (overlays_after
, struct Lisp_Overlay
*);
2346 swapfield (overlay_center
, ptrdiff_t);
2347 swapfield_ (undo_list
, Lisp_Object
);
2348 swapfield_ (mark
, Lisp_Object
);
2349 swapfield_ (enable_multibyte_characters
, Lisp_Object
);
2350 swapfield_ (bidi_display_reordering
, Lisp_Object
);
2351 swapfield_ (bidi_paragraph_direction
, Lisp_Object
);
2352 /* FIXME: Not sure what we should do with these *_marker fields.
2353 Hopefully they're just nil anyway. */
2354 swapfield_ (pt_marker
, Lisp_Object
);
2355 swapfield_ (begv_marker
, Lisp_Object
);
2356 swapfield_ (zv_marker
, Lisp_Object
);
2357 bset_point_before_scroll (current_buffer
, Qnil
);
2358 bset_point_before_scroll (other_buffer
, Qnil
);
2360 current_buffer
->text
->modiff
++; other_buffer
->text
->modiff
++;
2361 current_buffer
->text
->chars_modiff
++; other_buffer
->text
->chars_modiff
++;
2362 current_buffer
->text
->overlay_modiff
++; other_buffer
->text
->overlay_modiff
++;
2363 current_buffer
->text
->beg_unchanged
= current_buffer
->text
->gpt
;
2364 current_buffer
->text
->end_unchanged
= current_buffer
->text
->gpt
;
2365 other_buffer
->text
->beg_unchanged
= other_buffer
->text
->gpt
;
2366 other_buffer
->text
->end_unchanged
= other_buffer
->text
->gpt
;
2368 struct Lisp_Marker
*m
;
2369 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
2370 if (m
->buffer
== other_buffer
)
2371 m
->buffer
= current_buffer
;
2373 /* Since there's no indirect buffer in sight, markers on
2374 BUF_MARKERS(buf) should either be for `buf' or dead. */
2375 eassert (!m
->buffer
);
2376 for (m
= BUF_MARKERS (other_buffer
); m
; m
= m
->next
)
2377 if (m
->buffer
== current_buffer
)
2378 m
->buffer
= other_buffer
;
2380 /* Since there's no indirect buffer in sight, markers on
2381 BUF_MARKERS(buf) should either be for `buf' or dead. */
2382 eassert (!m
->buffer
);
2384 { /* Some of the C code expects that both window markers of a
2385 live window points to that window's buffer. So since we
2386 just swapped the markers between the two buffers, we need
2387 to undo the effect of this swap for window markers. */
2388 Lisp_Object w
= selected_window
, ws
= Qnil
;
2389 Lisp_Object buf1
, buf2
;
2390 XSETBUFFER (buf1
, current_buffer
); XSETBUFFER (buf2
, other_buffer
);
2392 while (NILP (Fmemq (w
, ws
)))
2395 if (MARKERP (XWINDOW (w
)->pointm
)
2396 && (EQ (XWINDOW (w
)->contents
, buf1
)
2397 || EQ (XWINDOW (w
)->contents
, buf2
)))
2398 Fset_marker (XWINDOW (w
)->pointm
,
2400 (BUF_BEGV (XBUFFER (XWINDOW (w
)->contents
))),
2401 XWINDOW (w
)->contents
);
2402 /* Blindly copied from pointm part. */
2403 if (MARKERP (XWINDOW (w
)->old_pointm
)
2404 && (EQ (XWINDOW (w
)->contents
, buf1
)
2405 || EQ (XWINDOW (w
)->contents
, buf2
)))
2406 Fset_marker (XWINDOW (w
)->old_pointm
,
2408 (BUF_BEGV (XBUFFER (XWINDOW (w
)->contents
))),
2409 XWINDOW (w
)->contents
);
2410 if (MARKERP (XWINDOW (w
)->start
)
2411 && (EQ (XWINDOW (w
)->contents
, buf1
)
2412 || EQ (XWINDOW (w
)->contents
, buf2
)))
2413 Fset_marker (XWINDOW (w
)->start
,
2415 (XBUFFER (XWINDOW (w
)->contents
)->last_window_start
),
2416 XWINDOW (w
)->contents
);
2417 w
= Fnext_window (w
, Qt
, Qt
);
2421 if (current_buffer
->text
->intervals
)
2422 (eassert (EQ (current_buffer
->text
->intervals
->up
.obj
, buffer
)),
2423 XSETBUFFER (current_buffer
->text
->intervals
->up
.obj
, current_buffer
));
2424 if (other_buffer
->text
->intervals
)
2425 (eassert (EQ (other_buffer
->text
->intervals
->up
.obj
, Fcurrent_buffer ())),
2426 XSETBUFFER (other_buffer
->text
->intervals
->up
.obj
, other_buffer
));
2431 DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte
, Sset_buffer_multibyte
,
2433 doc
: /* Set the multibyte flag of the current buffer to FLAG.
2434 If FLAG is t, this makes the buffer a multibyte buffer.
2435 If FLAG is nil, this makes the buffer a single-byte buffer.
2436 In these cases, the buffer contents remain unchanged as a sequence of
2437 bytes but the contents viewed as characters do change.
2438 If FLAG is `to', this makes the buffer a multibyte buffer by changing
2439 all eight-bit bytes to eight-bit characters.
2440 If the multibyte flag was really changed, undo information of the
2441 current buffer is cleared. */)
2444 struct Lisp_Marker
*tail
, *markers
;
2445 struct buffer
*other
;
2447 bool narrowed
= (BEG
!= BEGV
|| Z
!= ZV
);
2448 bool modified_p
= !NILP (Fbuffer_modified_p (Qnil
));
2449 Lisp_Object old_undo
= BVAR (current_buffer
, undo_list
);
2450 struct gcpro gcpro1
;
2452 if (current_buffer
->base_buffer
)
2453 error ("Cannot do `set-buffer-multibyte' on an indirect buffer");
2455 /* Do nothing if nothing actually changes. */
2456 if (NILP (flag
) == NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
2461 /* Don't record these buffer changes. We will put a special undo entry
2463 bset_undo_list (current_buffer
, Qt
);
2465 /* If the cached position is for this buffer, clear it out. */
2466 clear_charpos_cache (current_buffer
);
2469 begv
= BEGV_BYTE
, zv
= ZV_BYTE
;
2471 begv
= BEGV
, zv
= ZV
;
2474 error ("Changing multibyteness in a narrowed buffer");
2476 invalidate_buffer_caches (current_buffer
, BEGV
, ZV
);
2480 ptrdiff_t pos
, stop
;
2483 /* Do this first, so it can use CHAR_TO_BYTE
2484 to calculate the old correspondences. */
2485 set_intervals_multibyte (0);
2487 bset_enable_multibyte_characters (current_buffer
, Qnil
);
2493 TEMP_SET_PT_BOTH (PT_BYTE
, PT_BYTE
);
2496 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
2497 tail
->charpos
= tail
->bytepos
;
2499 /* Convert multibyte form of 8-bit characters to unibyte. */
2514 if (ASCII_CHAR_P (*p
))
2516 else if (CHAR_BYTE8_HEAD_P (*p
))
2518 c
= STRING_CHAR_AND_LENGTH (p
, bytes
);
2519 /* Delete all bytes for this 8-bit character but the
2520 last one, and change the last one to the character
2523 del_range_2 (pos
, pos
, pos
+ bytes
, pos
+ bytes
, 0);
2535 bytes
= BYTES_BY_CHAR_HEAD (*p
);
2536 p
+= bytes
, pos
+= bytes
;
2540 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2545 ptrdiff_t pos
, stop
;
2546 unsigned char *p
, *pend
;
2548 /* Be sure not to have a multibyte sequence striding over the GAP.
2549 Ex: We change this: "...abc\302 _GAP_ \241def..."
2550 to: "...abc _GAP_ \302\241def..." */
2553 && GPT_BYTE
> 1 && GPT_BYTE
< Z_BYTE
2554 && ! CHAR_HEAD_P (*(GAP_END_ADDR
)))
2556 unsigned char *q
= GPT_ADDR
- 1;
2558 while (! CHAR_HEAD_P (*q
) && q
> BEG_ADDR
) q
--;
2559 if (LEADING_CODE_P (*q
))
2561 ptrdiff_t new_gpt
= GPT_BYTE
- (GPT_ADDR
- q
);
2563 move_gap_both (new_gpt
, new_gpt
);
2567 /* Make the buffer contents valid as multibyte by converting
2568 8-bit characters to multibyte form. */
2586 if (ASCII_CHAR_P (*p
))
2588 else if (EQ (flag
, Qt
)
2589 && ! CHAR_BYTE8_HEAD_P (*p
)
2590 && (bytes
= MULTIBYTE_LENGTH (p
, pend
)) > 0)
2591 p
+= bytes
, pos
+= bytes
;
2594 unsigned char tmp
[MAX_MULTIBYTE_LENGTH
];
2597 c
= BYTE8_TO_CHAR (*p
);
2598 bytes
= CHAR_STRING (c
, tmp
);
2600 TEMP_SET_PT_BOTH (pos
+ 1, pos
+ 1);
2602 insert_1_both ((char *) tmp
+ 1, bytes
, bytes
, 1, 0, 0);
2603 /* Now the gap is after the just inserted data. */
2621 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2623 /* Do this first, so that chars_in_text asks the right question.
2624 set_intervals_multibyte needs it too. */
2625 bset_enable_multibyte_characters (current_buffer
, Qt
);
2627 GPT_BYTE
= advance_to_char_boundary (GPT_BYTE
);
2628 GPT
= chars_in_text (BEG_ADDR
, GPT_BYTE
- BEG_BYTE
) + BEG
;
2630 Z
= chars_in_text (GAP_END_ADDR
, Z_BYTE
- GPT_BYTE
) + GPT
;
2632 BEGV_BYTE
= advance_to_char_boundary (BEGV_BYTE
);
2633 if (BEGV_BYTE
> GPT_BYTE
)
2634 BEGV
= chars_in_text (GAP_END_ADDR
, BEGV_BYTE
- GPT_BYTE
) + GPT
;
2636 BEGV
= chars_in_text (BEG_ADDR
, BEGV_BYTE
- BEG_BYTE
) + BEG
;
2638 ZV_BYTE
= advance_to_char_boundary (ZV_BYTE
);
2639 if (ZV_BYTE
> GPT_BYTE
)
2640 ZV
= chars_in_text (GAP_END_ADDR
, ZV_BYTE
- GPT_BYTE
) + GPT
;
2642 ZV
= chars_in_text (BEG_ADDR
, ZV_BYTE
- BEG_BYTE
) + BEG
;
2645 ptrdiff_t byte
= advance_to_char_boundary (PT_BYTE
);
2648 if (byte
> GPT_BYTE
)
2649 position
= chars_in_text (GAP_END_ADDR
, byte
- GPT_BYTE
) + GPT
;
2651 position
= chars_in_text (BEG_ADDR
, byte
- BEG_BYTE
) + BEG
;
2652 TEMP_SET_PT_BOTH (position
, byte
);
2655 tail
= markers
= BUF_MARKERS (current_buffer
);
2657 /* This prevents BYTE_TO_CHAR (that is, buf_bytepos_to_charpos) from
2658 getting confused by the markers that have not yet been updated.
2659 It is also a signal that it should never create a marker. */
2660 BUF_MARKERS (current_buffer
) = NULL
;
2662 for (; tail
; tail
= tail
->next
)
2664 tail
->bytepos
= advance_to_char_boundary (tail
->bytepos
);
2665 tail
->charpos
= BYTE_TO_CHAR (tail
->bytepos
);
2668 /* Make sure no markers were put on the chain
2669 while the chain value was incorrect. */
2670 if (BUF_MARKERS (current_buffer
))
2673 BUF_MARKERS (current_buffer
) = markers
;
2675 /* Do this last, so it can calculate the new correspondences
2676 between chars and bytes. */
2677 set_intervals_multibyte (1);
2680 if (!EQ (old_undo
, Qt
))
2682 /* Represent all the above changes by a special undo entry. */
2683 bset_undo_list (current_buffer
,
2684 Fcons (list3 (Qapply
,
2685 intern ("set-buffer-multibyte"),
2686 NILP (flag
) ? Qt
: Qnil
),
2692 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2694 /* If buffer is shown in a window, let redisplay consider other windows. */
2695 if (buffer_window_count (current_buffer
))
2696 windows_or_buffers_changed
= 10;
2698 /* Copy this buffer's new multibyte status
2699 into all of its indirect buffers. */
2700 FOR_EACH_BUFFER (other
)
2701 if (other
->base_buffer
== current_buffer
&& BUFFER_LIVE_P (other
))
2703 BVAR (other
, enable_multibyte_characters
)
2704 = BVAR (current_buffer
, enable_multibyte_characters
);
2705 other
->prevent_redisplay_optimizations_p
= 1;
2708 /* Restore the modifiedness of the buffer. */
2709 if (!modified_p
&& !NILP (Fbuffer_modified_p (Qnil
)))
2710 Fset_buffer_modified_p (Qnil
);
2712 /* Update coding systems of this buffer's process (if any). */
2714 Lisp_Object process
;
2716 process
= Fget_buffer_process (Fcurrent_buffer ());
2717 if (PROCESSP (process
))
2718 setup_process_coding_systems (process
);
2724 DEFUN ("kill-all-local-variables", Fkill_all_local_variables
,
2725 Skill_all_local_variables
, 0, 0, 0,
2726 doc
: /* Switch to Fundamental mode by killing current buffer's local variables.
2727 Most local variable bindings are eliminated so that the default values
2728 become effective once more. Also, the syntax table is set from
2729 `standard-syntax-table', the local keymap is set to nil,
2730 and the abbrev table from `fundamental-mode-abbrev-table'.
2731 This function also forces redisplay of the mode line.
2733 Every function to select a new major mode starts by
2734 calling this function.
2736 As a special exception, local variables whose names have
2737 a non-nil `permanent-local' property are not eliminated by this function.
2739 The first thing this function does is run
2740 the normal hook `change-major-mode-hook'. */)
2743 Frun_hooks (1, &Qchange_major_mode_hook
);
2745 /* Make sure none of the bindings in local_var_alist
2746 remain swapped in, in their symbols. */
2748 swap_out_buffer_local_variables (current_buffer
);
2750 /* Actually eliminate all local bindings of this buffer. */
2752 reset_buffer_local_variables (current_buffer
, 0);
2754 /* Force mode-line redisplay. Useful here because all major mode
2755 commands call this function. */
2756 update_mode_lines
= 12;
2761 /* Make sure no local variables remain set up with buffer B
2762 for their current values. */
2765 swap_out_buffer_local_variables (struct buffer
*b
)
2767 Lisp_Object oalist
, alist
, buffer
;
2769 XSETBUFFER (buffer
, b
);
2770 oalist
= BVAR (b
, local_var_alist
);
2772 for (alist
= oalist
; CONSP (alist
); alist
= XCDR (alist
))
2774 Lisp_Object sym
= XCAR (XCAR (alist
));
2775 eassert (XSYMBOL (sym
)->redirect
== SYMBOL_LOCALIZED
);
2776 /* Need not do anything if some other buffer's binding is
2778 if (EQ (SYMBOL_BLV (XSYMBOL (sym
))->where
, buffer
))
2780 /* Symbol is set up for this buffer's old local value:
2782 swap_in_global_binding (XSYMBOL (sym
));
2787 /* Find all the overlays in the current buffer that contain position POS.
2788 Return the number found, and store them in a vector in *VEC_PTR.
2789 Store in *LEN_PTR the size allocated for the vector.
2790 Store in *NEXT_PTR the next position after POS where an overlay starts,
2791 or ZV if there are no more overlays between POS and ZV.
2792 Store in *PREV_PTR the previous position before POS where an overlay ends,
2793 or where an overlay starts which ends at or after POS;
2794 or BEGV if there are no such overlays from BEGV to POS.
2795 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2797 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2798 when this function is called.
2800 If EXTEND, make the vector bigger if necessary.
2801 If not, never extend the vector,
2802 and store only as many overlays as will fit.
2803 But still return the total number of overlays.
2805 If CHANGE_REQ, any position written into *PREV_PTR or
2806 *NEXT_PTR is guaranteed to be not equal to POS, unless it is the
2807 default (BEGV or ZV). */
2810 overlays_at (EMACS_INT pos
, bool extend
, Lisp_Object
**vec_ptr
,
2812 ptrdiff_t *next_ptr
, ptrdiff_t *prev_ptr
, bool change_req
)
2814 Lisp_Object overlay
, start
, end
;
2815 struct Lisp_Overlay
*tail
;
2817 ptrdiff_t len
= *len_ptr
;
2818 Lisp_Object
*vec
= *vec_ptr
;
2819 ptrdiff_t next
= ZV
;
2820 ptrdiff_t prev
= BEGV
;
2821 bool inhibit_storing
= 0;
2823 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2825 ptrdiff_t startpos
, endpos
;
2827 XSETMISC (overlay
, tail
);
2829 start
= OVERLAY_START (overlay
);
2830 end
= OVERLAY_END (overlay
);
2831 endpos
= OVERLAY_POSITION (end
);
2838 startpos
= OVERLAY_POSITION (start
);
2839 /* This one ends at or after POS
2840 so its start counts for PREV_PTR if it's before POS. */
2841 if (prev
< startpos
&& startpos
< pos
)
2845 if (startpos
<= pos
)
2849 /* The supplied vector is full.
2850 Either make it bigger, or don't store any more in it. */
2853 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2859 inhibit_storing
= 1;
2862 if (!inhibit_storing
)
2864 /* Keep counting overlays even if we can't return them all. */
2867 else if (startpos
< next
)
2871 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2873 ptrdiff_t startpos
, endpos
;
2875 XSETMISC (overlay
, tail
);
2877 start
= OVERLAY_START (overlay
);
2878 end
= OVERLAY_END (overlay
);
2879 startpos
= OVERLAY_POSITION (start
);
2882 if (startpos
< next
)
2886 endpos
= OVERLAY_POSITION (end
);
2893 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2899 inhibit_storing
= 1;
2902 if (!inhibit_storing
)
2906 if (startpos
< pos
&& startpos
> prev
)
2909 else if (endpos
< pos
&& endpos
> prev
)
2911 else if (endpos
== pos
&& startpos
> prev
2912 && (!change_req
|| startpos
< pos
))
2923 /* Find all the overlays in the current buffer that overlap the range
2924 BEG-END, or are empty at BEG, or are empty at END provided END
2925 denotes the position at the end of the current buffer.
2927 Return the number found, and store them in a vector in *VEC_PTR.
2928 Store in *LEN_PTR the size allocated for the vector.
2929 Store in *NEXT_PTR the next position after POS where an overlay starts,
2930 or ZV if there are no more overlays.
2931 Store in *PREV_PTR the previous position before POS where an overlay ends,
2932 or BEGV if there are no previous overlays.
2933 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2935 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2936 when this function is called.
2938 If EXTEND, make the vector bigger if necessary.
2939 If not, never extend the vector,
2940 and store only as many overlays as will fit.
2941 But still return the total number of overlays. */
2944 overlays_in (EMACS_INT beg
, EMACS_INT end
, bool extend
,
2945 Lisp_Object
**vec_ptr
, ptrdiff_t *len_ptr
,
2946 ptrdiff_t *next_ptr
, ptrdiff_t *prev_ptr
)
2948 Lisp_Object overlay
, ostart
, oend
;
2949 struct Lisp_Overlay
*tail
;
2951 ptrdiff_t len
= *len_ptr
;
2952 Lisp_Object
*vec
= *vec_ptr
;
2953 ptrdiff_t next
= ZV
;
2954 ptrdiff_t prev
= BEGV
;
2955 bool inhibit_storing
= 0;
2956 bool end_is_Z
= end
== Z
;
2958 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2960 ptrdiff_t startpos
, endpos
;
2962 XSETMISC (overlay
, tail
);
2964 ostart
= OVERLAY_START (overlay
);
2965 oend
= OVERLAY_END (overlay
);
2966 endpos
= OVERLAY_POSITION (oend
);
2973 startpos
= OVERLAY_POSITION (ostart
);
2974 /* Count an interval if it overlaps the range, is empty at the
2975 start of the range, or is empty at END provided END denotes the
2976 end of the buffer. */
2977 if ((beg
< endpos
&& startpos
< end
)
2978 || (startpos
== endpos
2979 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
2983 /* The supplied vector is full.
2984 Either make it bigger, or don't store any more in it. */
2987 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2993 inhibit_storing
= 1;
2996 if (!inhibit_storing
)
2998 /* Keep counting overlays even if we can't return them all. */
3001 else if (startpos
< next
)
3005 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
3007 ptrdiff_t startpos
, endpos
;
3009 XSETMISC (overlay
, tail
);
3011 ostart
= OVERLAY_START (overlay
);
3012 oend
= OVERLAY_END (overlay
);
3013 startpos
= OVERLAY_POSITION (ostart
);
3016 if (startpos
< next
)
3020 endpos
= OVERLAY_POSITION (oend
);
3021 /* Count an interval if it overlaps the range, is empty at the
3022 start of the range, or is empty at END provided END denotes the
3023 end of the buffer. */
3024 if ((beg
< endpos
&& startpos
< end
)
3025 || (startpos
== endpos
3026 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
3032 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
3038 inhibit_storing
= 1;
3041 if (!inhibit_storing
)
3045 else if (endpos
< beg
&& endpos
> prev
)
3057 /* Return true if there exists an overlay with a non-nil
3058 `mouse-face' property overlapping OVERLAY. */
3061 mouse_face_overlay_overlaps (Lisp_Object overlay
)
3063 ptrdiff_t start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3064 ptrdiff_t end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3065 ptrdiff_t n
, i
, size
;
3066 Lisp_Object
*v
, tem
;
3067 Lisp_Object vbuf
[10];
3070 size
= ARRAYELTS (vbuf
);
3072 n
= overlays_in (start
, end
, 0, &v
, &size
, NULL
, NULL
);
3075 SAFE_NALLOCA (v
, 1, n
);
3076 overlays_in (start
, end
, 0, &v
, &n
, NULL
, NULL
);
3079 for (i
= 0; i
< n
; ++i
)
3080 if (!EQ (v
[i
], overlay
)
3081 && (tem
= Foverlay_get (overlay
, Qmouse_face
),
3091 /* Fast function to just test if we're at an overlay boundary. */
3093 overlay_touches_p (ptrdiff_t pos
)
3095 Lisp_Object overlay
;
3096 struct Lisp_Overlay
*tail
;
3098 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
3102 XSETMISC (overlay
,tail
);
3103 eassert (OVERLAYP (overlay
));
3105 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3108 if (endpos
== pos
|| OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
)
3112 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
3116 XSETMISC (overlay
, tail
);
3117 eassert (OVERLAYP (overlay
));
3119 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3122 if (startpos
== pos
|| OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
)
3130 Lisp_Object overlay
;
3133 EMACS_INT spriority
; /* Secondary priority. */
3137 compare_overlays (const void *v1
, const void *v2
)
3139 const struct sortvec
*s1
= v1
;
3140 const struct sortvec
*s2
= v2
;
3141 /* Return 1 if s1 should take precedence, -1 if v2 should take precedence,
3142 and 0 if they're equal. */
3143 if (s1
->priority
!= s2
->priority
)
3144 return s1
->priority
< s2
->priority
? -1 : 1;
3145 /* If the priority is equal, give precedence to the one not covered by the
3146 other. If neither covers the other, obey spriority. */
3147 else if (s1
->beg
< s2
->beg
)
3148 return (s1
->end
< s2
->end
&& s1
->spriority
> s2
->spriority
? 1 : -1);
3149 else if (s1
->beg
> s2
->beg
)
3150 return (s1
->end
> s2
->end
&& s1
->spriority
< s2
->spriority
? -1 : 1);
3151 else if (s1
->end
!= s2
->end
)
3152 return s2
->end
< s1
->end
? -1 : 1;
3153 else if (s1
->spriority
!= s2
->spriority
)
3154 return (s1
->spriority
< s2
->spriority
? -1 : 1);
3155 else if (EQ (s1
->overlay
, s2
->overlay
))
3158 /* Avoid the non-determinism of qsort by choosing an arbitrary ordering
3159 between "equal" overlays. The result can still change between
3160 invocations of Emacs, but it won't change in the middle of
3161 `find_field' (bug#6830). */
3162 return XLI (s1
->overlay
) < XLI (s2
->overlay
) ? -1 : 1;
3165 /* Sort an array of overlays by priority. The array is modified in place.
3166 The return value is the new size; this may be smaller than the original
3167 size if some of the overlays were invalid or were window-specific. */
3169 sort_overlays (Lisp_Object
*overlay_vec
, ptrdiff_t noverlays
, struct window
*w
)
3173 struct sortvec
*sortvec
;
3175 SAFE_NALLOCA (sortvec
, 1, noverlays
);
3177 /* Put the valid and relevant overlays into sortvec. */
3179 for (i
= 0, j
= 0; i
< noverlays
; i
++)
3182 Lisp_Object overlay
;
3184 overlay
= overlay_vec
[i
];
3185 if (OVERLAYP (overlay
)
3186 && OVERLAY_POSITION (OVERLAY_START (overlay
)) > 0
3187 && OVERLAY_POSITION (OVERLAY_END (overlay
)) > 0)
3189 /* If we're interested in a specific window, then ignore
3190 overlays that are limited to some other window. */
3195 window
= Foverlay_get (overlay
, Qwindow
);
3196 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3200 /* This overlay is good and counts: put it into sortvec. */
3201 sortvec
[j
].overlay
= overlay
;
3202 sortvec
[j
].beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3203 sortvec
[j
].end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3204 tem
= Foverlay_get (overlay
, Qpriority
);
3207 sortvec
[j
].priority
= 0;
3208 sortvec
[j
].spriority
= 0;
3210 else if (INTEGERP (tem
))
3212 sortvec
[j
].priority
= XINT (tem
);
3213 sortvec
[j
].spriority
= 0;
3215 else if (CONSP (tem
))
3217 Lisp_Object car
= XCAR (tem
);
3218 Lisp_Object cdr
= XCDR (tem
);
3219 sortvec
[j
].priority
= INTEGERP (car
) ? XINT (car
) : 0;
3220 sortvec
[j
].spriority
= INTEGERP (cdr
) ? XINT (cdr
) : 0;
3227 /* Sort the overlays into the proper order: increasing priority. */
3230 qsort (sortvec
, noverlays
, sizeof (struct sortvec
), compare_overlays
);
3232 for (i
= 0; i
< noverlays
; i
++)
3233 overlay_vec
[i
] = sortvec
[i
].overlay
;
3241 Lisp_Object string
, string2
;
3248 struct sortstr
*buf
; /* An array that expands as needed; never freed. */
3249 ptrdiff_t size
; /* Allocated length of that array. */
3250 ptrdiff_t used
; /* How much of the array is currently in use. */
3251 ptrdiff_t bytes
; /* Total length of the strings in buf. */
3254 /* Buffers for storing information about the overlays touching a given
3255 position. These could be automatic variables in overlay_strings, but
3256 it's more efficient to hold onto the memory instead of repeatedly
3257 allocating and freeing it. */
3258 static struct sortstrlist overlay_heads
, overlay_tails
;
3259 static unsigned char *overlay_str_buf
;
3261 /* Allocated length of overlay_str_buf. */
3262 static ptrdiff_t overlay_str_len
;
3264 /* A comparison function suitable for passing to qsort. */
3266 cmp_for_strings (const void *as1
, const void *as2
)
3268 struct sortstr
const *s1
= as1
;
3269 struct sortstr
const *s2
= as2
;
3270 if (s1
->size
!= s2
->size
)
3271 return s2
->size
< s1
->size
? -1 : 1;
3272 if (s1
->priority
!= s2
->priority
)
3273 return s1
->priority
< s2
->priority
? -1 : 1;
3278 record_overlay_string (struct sortstrlist
*ssl
, Lisp_Object str
,
3279 Lisp_Object str2
, Lisp_Object pri
, ptrdiff_t size
)
3283 if (ssl
->used
== ssl
->size
)
3284 ssl
->buf
= xpalloc (ssl
->buf
, &ssl
->size
, 5, -1, sizeof *ssl
->buf
);
3285 ssl
->buf
[ssl
->used
].string
= str
;
3286 ssl
->buf
[ssl
->used
].string2
= str2
;
3287 ssl
->buf
[ssl
->used
].size
= size
;
3288 ssl
->buf
[ssl
->used
].priority
= (INTEGERP (pri
) ? XINT (pri
) : 0);
3291 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3292 nbytes
= SCHARS (str
);
3293 else if (! STRING_MULTIBYTE (str
))
3294 nbytes
= count_size_as_multibyte (SDATA (str
),
3297 nbytes
= SBYTES (str
);
3299 if (INT_ADD_OVERFLOW (ssl
->bytes
, nbytes
))
3300 memory_full (SIZE_MAX
);
3301 ssl
->bytes
+= nbytes
;
3305 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3306 nbytes
= SCHARS (str2
);
3307 else if (! STRING_MULTIBYTE (str2
))
3308 nbytes
= count_size_as_multibyte (SDATA (str2
),
3311 nbytes
= SBYTES (str2
);
3313 if (INT_ADD_OVERFLOW (ssl
->bytes
, nbytes
))
3314 memory_full (SIZE_MAX
);
3315 ssl
->bytes
+= nbytes
;
3319 /* Concatenate the strings associated with overlays that begin or end
3320 at POS, ignoring overlays that are specific to windows other than W.
3321 The strings are concatenated in the appropriate order: shorter
3322 overlays nest inside longer ones, and higher priority inside lower.
3323 Normally all of the after-strings come first, but zero-sized
3324 overlays have their after-strings ride along with the
3325 before-strings because it would look strange to print them
3328 Returns the concatenated string's length, and return the pointer to
3329 that string via PSTR, if that variable is non-NULL. The storage of
3330 the concatenated strings may be overwritten by subsequent calls. */
3333 overlay_strings (ptrdiff_t pos
, struct window
*w
, unsigned char **pstr
)
3335 Lisp_Object overlay
, window
, str
;
3336 struct Lisp_Overlay
*ov
;
3337 ptrdiff_t startpos
, endpos
;
3338 bool multibyte
= ! NILP (BVAR (current_buffer
, enable_multibyte_characters
));
3340 overlay_heads
.used
= overlay_heads
.bytes
= 0;
3341 overlay_tails
.used
= overlay_tails
.bytes
= 0;
3342 for (ov
= current_buffer
->overlays_before
; ov
; ov
= ov
->next
)
3344 XSETMISC (overlay
, ov
);
3345 eassert (OVERLAYP (overlay
));
3347 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3348 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3351 if (endpos
!= pos
&& startpos
!= pos
)
3353 window
= Foverlay_get (overlay
, Qwindow
);
3354 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3357 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3358 record_overlay_string (&overlay_heads
, str
,
3360 ? Foverlay_get (overlay
, Qafter_string
)
3362 Foverlay_get (overlay
, Qpriority
),
3364 else if (endpos
== pos
3365 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3366 record_overlay_string (&overlay_tails
, str
, Qnil
,
3367 Foverlay_get (overlay
, Qpriority
),
3370 for (ov
= current_buffer
->overlays_after
; ov
; ov
= ov
->next
)
3372 XSETMISC (overlay
, ov
);
3373 eassert (OVERLAYP (overlay
));
3375 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3376 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3379 if (endpos
!= pos
&& startpos
!= pos
)
3381 window
= Foverlay_get (overlay
, Qwindow
);
3382 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3385 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3386 record_overlay_string (&overlay_heads
, str
,
3388 ? Foverlay_get (overlay
, Qafter_string
)
3390 Foverlay_get (overlay
, Qpriority
),
3392 else if (endpos
== pos
3393 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3394 record_overlay_string (&overlay_tails
, str
, Qnil
,
3395 Foverlay_get (overlay
, Qpriority
),
3398 if (overlay_tails
.used
> 1)
3399 qsort (overlay_tails
.buf
, overlay_tails
.used
, sizeof (struct sortstr
),
3401 if (overlay_heads
.used
> 1)
3402 qsort (overlay_heads
.buf
, overlay_heads
.used
, sizeof (struct sortstr
),
3404 if (overlay_heads
.bytes
|| overlay_tails
.bytes
)
3411 if (INT_ADD_OVERFLOW (overlay_heads
.bytes
, overlay_tails
.bytes
))
3412 memory_full (SIZE_MAX
);
3413 total
= overlay_heads
.bytes
+ overlay_tails
.bytes
;
3414 if (total
> overlay_str_len
)
3415 overlay_str_buf
= xpalloc (overlay_str_buf
, &overlay_str_len
,
3416 total
- overlay_str_len
, -1, 1);
3418 p
= overlay_str_buf
;
3419 for (i
= overlay_tails
.used
; --i
>= 0;)
3422 tem
= overlay_tails
.buf
[i
].string
;
3423 nbytes
= copy_text (SDATA (tem
), p
,
3425 STRING_MULTIBYTE (tem
), multibyte
);
3428 for (i
= 0; i
< overlay_heads
.used
; ++i
)
3431 tem
= overlay_heads
.buf
[i
].string
;
3432 nbytes
= copy_text (SDATA (tem
), p
,
3434 STRING_MULTIBYTE (tem
), multibyte
);
3436 tem
= overlay_heads
.buf
[i
].string2
;
3439 nbytes
= copy_text (SDATA (tem
), p
,
3441 STRING_MULTIBYTE (tem
), multibyte
);
3445 if (p
!= overlay_str_buf
+ total
)
3448 *pstr
= overlay_str_buf
;
3454 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
3457 recenter_overlay_lists (struct buffer
*buf
, ptrdiff_t pos
)
3459 Lisp_Object overlay
, beg
, end
;
3460 struct Lisp_Overlay
*prev
, *tail
, *next
;
3462 /* See if anything in overlays_before should move to overlays_after. */
3464 /* We don't strictly need prev in this loop; it should always be nil.
3465 But we use it for symmetry and in case that should cease to be true
3466 with some future change. */
3468 for (tail
= buf
->overlays_before
; tail
; prev
= tail
, tail
= next
)
3471 XSETMISC (overlay
, tail
);
3472 eassert (OVERLAYP (overlay
));
3474 beg
= OVERLAY_START (overlay
);
3475 end
= OVERLAY_END (overlay
);
3477 if (OVERLAY_POSITION (end
) > pos
)
3479 /* OVERLAY needs to be moved. */
3480 ptrdiff_t where
= OVERLAY_POSITION (beg
);
3481 struct Lisp_Overlay
*other
, *other_prev
;
3483 /* Splice the cons cell TAIL out of overlays_before. */
3487 set_buffer_overlays_before (buf
, next
);
3489 /* Search thru overlays_after for where to put it. */
3491 for (other
= buf
->overlays_after
; other
;
3492 other_prev
= other
, other
= other
->next
)
3494 Lisp_Object otherbeg
, otheroverlay
;
3496 XSETMISC (otheroverlay
, other
);
3497 eassert (OVERLAYP (otheroverlay
));
3499 otherbeg
= OVERLAY_START (otheroverlay
);
3500 if (OVERLAY_POSITION (otherbeg
) >= where
)
3504 /* Add TAIL to overlays_after before OTHER. */
3507 other_prev
->next
= tail
;
3509 set_buffer_overlays_after (buf
, tail
);
3513 /* We've reached the things that should stay in overlays_before.
3514 All the rest of overlays_before must end even earlier,
3519 /* See if anything in overlays_after should be in overlays_before. */
3521 for (tail
= buf
->overlays_after
; tail
; prev
= tail
, tail
= next
)
3524 XSETMISC (overlay
, tail
);
3525 eassert (OVERLAYP (overlay
));
3527 beg
= OVERLAY_START (overlay
);
3528 end
= OVERLAY_END (overlay
);
3530 /* Stop looking, when we know that nothing further
3531 can possibly end before POS. */
3532 if (OVERLAY_POSITION (beg
) > pos
)
3535 if (OVERLAY_POSITION (end
) <= pos
)
3537 /* OVERLAY needs to be moved. */
3538 ptrdiff_t where
= OVERLAY_POSITION (end
);
3539 struct Lisp_Overlay
*other
, *other_prev
;
3541 /* Splice the cons cell TAIL out of overlays_after. */
3545 set_buffer_overlays_after (buf
, next
);
3547 /* Search thru overlays_before for where to put it. */
3549 for (other
= buf
->overlays_before
; other
;
3550 other_prev
= other
, other
= other
->next
)
3552 Lisp_Object otherend
, otheroverlay
;
3554 XSETMISC (otheroverlay
, other
);
3555 eassert (OVERLAYP (otheroverlay
));
3557 otherend
= OVERLAY_END (otheroverlay
);
3558 if (OVERLAY_POSITION (otherend
) <= where
)
3562 /* Add TAIL to overlays_before before OTHER. */
3565 other_prev
->next
= tail
;
3567 set_buffer_overlays_before (buf
, tail
);
3572 buf
->overlay_center
= pos
;
3576 adjust_overlays_for_insert (ptrdiff_t pos
, ptrdiff_t length
)
3578 /* After an insertion, the lists are still sorted properly,
3579 but we may need to update the value of the overlay center. */
3580 if (current_buffer
->overlay_center
>= pos
)
3581 current_buffer
->overlay_center
+= length
;
3585 adjust_overlays_for_delete (ptrdiff_t pos
, ptrdiff_t length
)
3587 if (current_buffer
->overlay_center
< pos
)
3588 /* The deletion was to our right. No change needed; the before- and
3589 after-lists are still consistent. */
3591 else if (current_buffer
->overlay_center
- pos
> length
)
3592 /* The deletion was to our left. We need to adjust the center value
3593 to account for the change in position, but the lists are consistent
3594 given the new value. */
3595 current_buffer
->overlay_center
-= length
;
3597 /* We're right in the middle. There might be things on the after-list
3598 that now belong on the before-list. Recentering will move them,
3599 and also update the center point. */
3600 recenter_overlay_lists (current_buffer
, pos
);
3603 /* Fix up overlays that were garbled as a result of permuting markers
3604 in the range START through END. Any overlay with at least one
3605 endpoint in this range will need to be unlinked from the overlay
3606 list and reinserted in its proper place.
3607 Such an overlay might even have negative size at this point.
3608 If so, we'll make the overlay empty. */
3610 fix_start_end_in_overlays (register ptrdiff_t start
, register ptrdiff_t end
)
3612 Lisp_Object overlay
;
3613 struct Lisp_Overlay
*before_list
IF_LINT (= NULL
);
3614 struct Lisp_Overlay
*after_list
IF_LINT (= NULL
);
3615 /* These are either nil, indicating that before_list or after_list
3616 should be assigned, or the cons cell the cdr of which should be
3618 struct Lisp_Overlay
*beforep
= NULL
, *afterp
= NULL
;
3619 /* 'Parent', likewise, indicates a cons cell or
3620 current_buffer->overlays_before or overlays_after, depending
3621 which loop we're in. */
3622 struct Lisp_Overlay
*tail
, *parent
;
3623 ptrdiff_t startpos
, endpos
;
3625 /* This algorithm shifts links around instead of consing and GCing.
3626 The loop invariant is that before_list (resp. after_list) is a
3627 well-formed list except that its last element, the CDR of beforep
3628 (resp. afterp) if beforep (afterp) isn't nil or before_list
3629 (after_list) if it is, is still uninitialized. So it's not a bug
3630 that before_list isn't initialized, although it may look
3632 for (parent
= NULL
, tail
= current_buffer
->overlays_before
; tail
;)
3634 XSETMISC (overlay
, tail
);
3636 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3637 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3639 /* If the overlay is backwards, make it empty. */
3640 if (endpos
< startpos
)
3643 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3651 || (startpos
>= start
&& startpos
< end
))
3653 /* Add it to the end of the wrong list. Later on,
3654 recenter_overlay_lists will move it to the right place. */
3655 if (endpos
< current_buffer
->overlay_center
)
3660 afterp
->next
= tail
;
3668 beforep
->next
= tail
;
3672 set_buffer_overlays_before (current_buffer
, tail
->next
);
3674 parent
->next
= tail
->next
;
3678 parent
= tail
, tail
= parent
->next
;
3680 for (parent
= NULL
, tail
= current_buffer
->overlays_after
; tail
;)
3682 XSETMISC (overlay
, tail
);
3684 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3685 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3687 /* If the overlay is backwards, make it empty. */
3688 if (endpos
< startpos
)
3691 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3695 if (startpos
>= end
)
3698 if (startpos
>= start
3699 || (endpos
>= start
&& endpos
< end
))
3701 if (endpos
< current_buffer
->overlay_center
)
3706 afterp
->next
= tail
;
3714 beforep
->next
= tail
;
3718 set_buffer_overlays_after (current_buffer
, tail
->next
);
3720 parent
->next
= tail
->next
;
3724 parent
= tail
, tail
= parent
->next
;
3727 /* Splice the constructed (wrong) lists into the buffer's lists,
3728 and let the recenter function make it sane again. */
3731 beforep
->next
= current_buffer
->overlays_before
;
3732 set_buffer_overlays_before (current_buffer
, before_list
);
3737 afterp
->next
= current_buffer
->overlays_after
;
3738 set_buffer_overlays_after (current_buffer
, after_list
);
3740 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3743 /* We have two types of overlay: the one whose ending marker is
3744 after-insertion-marker (this is the usual case) and the one whose
3745 ending marker is before-insertion-marker. When `overlays_before'
3746 contains overlays of the latter type and the former type in this
3747 order and both overlays end at inserting position, inserting a text
3748 increases only the ending marker of the latter type, which results
3749 in incorrect ordering of `overlays_before'.
3751 This function fixes ordering of overlays in the slot
3752 `overlays_before' of the buffer *BP. Before the insertion, `point'
3753 was at PREV, and now is at POS. */
3756 fix_overlays_before (struct buffer
*bp
, ptrdiff_t prev
, ptrdiff_t pos
)
3758 /* If parent is nil, replace overlays_before; otherwise, parent->next. */
3759 struct Lisp_Overlay
*tail
= bp
->overlays_before
, *parent
= NULL
, *right_pair
;
3761 ptrdiff_t end
IF_LINT (= 0);
3763 /* After the insertion, the several overlays may be in incorrect
3764 order. The possibility is that, in the list `overlays_before',
3765 an overlay which ends at POS appears after an overlay which ends
3766 at PREV. Since POS is greater than PREV, we must fix the
3767 ordering of these overlays, by moving overlays ends at POS before
3768 the overlays ends at PREV. */
3770 /* At first, find a place where disordered overlays should be linked
3771 in. It is where an overlay which end before POS exists. (i.e. an
3772 overlay whose ending marker is after-insertion-marker if disorder
3775 && (XSETMISC (tem
, tail
),
3776 (end
= OVERLAY_POSITION (OVERLAY_END (tem
))) >= pos
))
3782 /* If we don't find such an overlay,
3783 or the found one ends before PREV,
3784 or the found one is the last one in the list,
3785 we don't have to fix anything. */
3786 if (!tail
|| end
< prev
|| !tail
->next
)
3789 right_pair
= parent
;
3793 /* Now, end position of overlays in the list TAIL should be before
3794 or equal to PREV. In the loop, an overlay which ends at POS is
3795 moved ahead to the place indicated by the CDR of RIGHT_PAIR. If
3796 we found an overlay which ends before PREV, the remaining
3797 overlays are in correct order. */
3800 XSETMISC (tem
, tail
);
3801 end
= OVERLAY_POSITION (OVERLAY_END (tem
));
3804 { /* This overlay is disordered. */
3805 struct Lisp_Overlay
*found
= tail
;
3807 /* Unlink the found overlay. */
3809 parent
->next
= tail
;
3810 /* Move an overlay at RIGHT_PLACE to the next of the found one,
3811 and link it into the right place. */
3814 found
->next
= bp
->overlays_before
;
3815 set_buffer_overlays_before (bp
, found
);
3819 found
->next
= right_pair
->next
;
3820 right_pair
->next
= found
;
3823 else if (end
== prev
)
3828 else /* No more disordered overlay. */
3833 DEFUN ("overlayp", Foverlayp
, Soverlayp
, 1, 1, 0,
3834 doc
: /* Return t if OBJECT is an overlay. */)
3835 (Lisp_Object object
)
3837 return (OVERLAYP (object
) ? Qt
: Qnil
);
3840 DEFUN ("make-overlay", Fmake_overlay
, Smake_overlay
, 2, 5, 0,
3841 doc
: /* Create a new overlay with range BEG to END in BUFFER and return it.
3842 If omitted, BUFFER defaults to the current buffer.
3843 BEG and END may be integers or markers.
3844 The fourth arg FRONT-ADVANCE, if non-nil, makes the marker
3845 for the front of the overlay advance when text is inserted there
3846 \(which means the text *is not* included in the overlay).
3847 The fifth arg REAR-ADVANCE, if non-nil, makes the marker
3848 for the rear of the overlay advance when text is inserted there
3849 \(which means the text *is* included in the overlay). */)
3850 (Lisp_Object beg
, Lisp_Object end
, Lisp_Object buffer
,
3851 Lisp_Object front_advance
, Lisp_Object rear_advance
)
3853 Lisp_Object overlay
;
3857 XSETBUFFER (buffer
, current_buffer
);
3859 CHECK_BUFFER (buffer
);
3861 if (MARKERP (beg
) && !EQ (Fmarker_buffer (beg
), buffer
))
3862 signal_error ("Marker points into wrong buffer", beg
);
3863 if (MARKERP (end
) && !EQ (Fmarker_buffer (end
), buffer
))
3864 signal_error ("Marker points into wrong buffer", end
);
3866 CHECK_NUMBER_COERCE_MARKER (beg
);
3867 CHECK_NUMBER_COERCE_MARKER (end
);
3869 if (XINT (beg
) > XINT (end
))
3872 temp
= beg
; beg
= end
; end
= temp
;
3875 b
= XBUFFER (buffer
);
3877 beg
= Fset_marker (Fmake_marker (), beg
, buffer
);
3878 end
= Fset_marker (Fmake_marker (), end
, buffer
);
3880 if (!NILP (front_advance
))
3881 XMARKER (beg
)->insertion_type
= 1;
3882 if (!NILP (rear_advance
))
3883 XMARKER (end
)->insertion_type
= 1;
3885 overlay
= build_overlay (beg
, end
, Qnil
);
3887 /* Put the new overlay on the wrong list. */
3888 end
= OVERLAY_END (overlay
);
3889 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
3891 eassert (b
->overlays_after
|| (XOVERLAY (overlay
)->next
== NULL
));
3892 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3893 set_buffer_overlays_after (b
, XOVERLAY (overlay
));
3897 eassert (b
->overlays_before
|| (XOVERLAY (overlay
)->next
== NULL
));
3898 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3899 set_buffer_overlays_before (b
, XOVERLAY (overlay
));
3901 /* This puts it in the right list, and in the right order. */
3902 recenter_overlay_lists (b
, b
->overlay_center
);
3904 /* We don't need to redisplay the region covered by the overlay, because
3905 the overlay has no properties at the moment. */
3910 /* Mark a section of BUF as needing redisplay because of overlays changes. */
3913 modify_overlay (struct buffer
*buf
, ptrdiff_t start
, ptrdiff_t end
)
3917 ptrdiff_t temp
= start
;
3922 BUF_COMPUTE_UNCHANGED (buf
, start
, end
);
3924 bset_redisplay (buf
);
3926 ++BUF_OVERLAY_MODIFF (buf
);
3929 /* Remove OVERLAY from LIST. */
3931 static struct Lisp_Overlay
*
3932 unchain_overlay (struct Lisp_Overlay
*list
, struct Lisp_Overlay
*overlay
)
3934 register struct Lisp_Overlay
*tail
, **prev
= &list
;
3936 for (tail
= list
; tail
; prev
= &tail
->next
, tail
= *prev
)
3937 if (tail
== overlay
)
3939 *prev
= overlay
->next
;
3940 overlay
->next
= NULL
;
3946 /* Remove OVERLAY from both overlay lists of B. */
3949 unchain_both (struct buffer
*b
, Lisp_Object overlay
)
3951 struct Lisp_Overlay
*ov
= XOVERLAY (overlay
);
3953 set_buffer_overlays_before (b
, unchain_overlay (b
->overlays_before
, ov
));
3954 set_buffer_overlays_after (b
, unchain_overlay (b
->overlays_after
, ov
));
3955 eassert (XOVERLAY (overlay
)->next
== NULL
);
3958 DEFUN ("move-overlay", Fmove_overlay
, Smove_overlay
, 3, 4, 0,
3959 doc
: /* Set the endpoints of OVERLAY to BEG and END in BUFFER.
3960 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.
3961 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current
3963 (Lisp_Object overlay
, Lisp_Object beg
, Lisp_Object end
, Lisp_Object buffer
)
3965 struct buffer
*b
, *ob
= 0;
3966 Lisp_Object obuffer
;
3967 ptrdiff_t count
= SPECPDL_INDEX ();
3968 ptrdiff_t n_beg
, n_end
, o_beg
IF_LINT (= 0), o_end
IF_LINT (= 0);
3970 CHECK_OVERLAY (overlay
);
3972 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3974 XSETBUFFER (buffer
, current_buffer
);
3975 CHECK_BUFFER (buffer
);
3977 if (NILP (Fbuffer_live_p (buffer
)))
3978 error ("Attempt to move overlay to a dead buffer");
3980 if (MARKERP (beg
) && !EQ (Fmarker_buffer (beg
), buffer
))
3981 signal_error ("Marker points into wrong buffer", beg
);
3982 if (MARKERP (end
) && !EQ (Fmarker_buffer (end
), buffer
))
3983 signal_error ("Marker points into wrong buffer", end
);
3985 CHECK_NUMBER_COERCE_MARKER (beg
);
3986 CHECK_NUMBER_COERCE_MARKER (end
);
3988 if (XINT (beg
) > XINT (end
))
3991 temp
= beg
; beg
= end
; end
= temp
;
3994 specbind (Qinhibit_quit
, Qt
);
3996 obuffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3997 b
= XBUFFER (buffer
);
3999 if (!NILP (obuffer
))
4001 ob
= XBUFFER (obuffer
);
4003 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4004 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4006 unchain_both (ob
, overlay
);
4009 /* Set the overlay boundaries, which may clip them. */
4010 Fset_marker (OVERLAY_START (overlay
), beg
, buffer
);
4011 Fset_marker (OVERLAY_END (overlay
), end
, buffer
);
4013 n_beg
= marker_position (OVERLAY_START (overlay
));
4014 n_end
= marker_position (OVERLAY_END (overlay
));
4016 /* If the overlay has changed buffers, do a thorough redisplay. */
4017 if (!EQ (buffer
, obuffer
))
4019 /* Redisplay where the overlay was. */
4021 modify_overlay (ob
, o_beg
, o_end
);
4023 /* Redisplay where the overlay is going to be. */
4024 modify_overlay (b
, n_beg
, n_end
);
4027 /* Redisplay the area the overlay has just left, or just enclosed. */
4030 modify_overlay (b
, o_end
, n_end
);
4031 else if (o_end
== n_end
)
4032 modify_overlay (b
, o_beg
, n_beg
);
4034 modify_overlay (b
, min (o_beg
, n_beg
), max (o_end
, n_end
));
4037 /* Delete the overlay if it is empty after clipping and has the
4038 evaporate property. */
4039 if (n_beg
== n_end
&& !NILP (Foverlay_get (overlay
, Qevaporate
)))
4040 return unbind_to (count
, Fdelete_overlay (overlay
));
4042 /* Put the overlay into the new buffer's overlay lists, first on the
4044 if (n_end
< b
->overlay_center
)
4046 XOVERLAY (overlay
)->next
= b
->overlays_after
;
4047 set_buffer_overlays_after (b
, XOVERLAY (overlay
));
4051 XOVERLAY (overlay
)->next
= b
->overlays_before
;
4052 set_buffer_overlays_before (b
, XOVERLAY (overlay
));
4055 /* This puts it in the right list, and in the right order. */
4056 recenter_overlay_lists (b
, b
->overlay_center
);
4058 return unbind_to (count
, overlay
);
4061 DEFUN ("delete-overlay", Fdelete_overlay
, Sdelete_overlay
, 1, 1, 0,
4062 doc
: /* Delete the overlay OVERLAY from its buffer. */)
4063 (Lisp_Object overlay
)
4067 ptrdiff_t count
= SPECPDL_INDEX ();
4069 CHECK_OVERLAY (overlay
);
4071 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4075 b
= XBUFFER (buffer
);
4076 specbind (Qinhibit_quit
, Qt
);
4078 unchain_both (b
, overlay
);
4079 drop_overlay (b
, XOVERLAY (overlay
));
4081 /* When deleting an overlay with before or after strings, turn off
4082 display optimizations for the affected buffer, on the basis that
4083 these strings may contain newlines. This is easier to do than to
4084 check for that situation during redisplay. */
4085 if (!windows_or_buffers_changed
4086 && (!NILP (Foverlay_get (overlay
, Qbefore_string
))
4087 || !NILP (Foverlay_get (overlay
, Qafter_string
))))
4088 b
->prevent_redisplay_optimizations_p
= 1;
4090 return unbind_to (count
, Qnil
);
4093 DEFUN ("delete-all-overlays", Fdelete_all_overlays
, Sdelete_all_overlays
, 0, 1, 0,
4094 doc
: /* Delete all overlays of BUFFER.
4095 BUFFER omitted or nil means delete all overlays of the current
4097 (Lisp_Object buffer
)
4099 delete_all_overlays (decode_buffer (buffer
));
4103 /* Overlay dissection functions. */
4105 DEFUN ("overlay-start", Foverlay_start
, Soverlay_start
, 1, 1, 0,
4106 doc
: /* Return the position at which OVERLAY starts. */)
4107 (Lisp_Object overlay
)
4109 CHECK_OVERLAY (overlay
);
4111 return (Fmarker_position (OVERLAY_START (overlay
)));
4114 DEFUN ("overlay-end", Foverlay_end
, Soverlay_end
, 1, 1, 0,
4115 doc
: /* Return the position at which OVERLAY ends. */)
4116 (Lisp_Object overlay
)
4118 CHECK_OVERLAY (overlay
);
4120 return (Fmarker_position (OVERLAY_END (overlay
)));
4123 DEFUN ("overlay-buffer", Foverlay_buffer
, Soverlay_buffer
, 1, 1, 0,
4124 doc
: /* Return the buffer OVERLAY belongs to.
4125 Return nil if OVERLAY has been deleted. */)
4126 (Lisp_Object overlay
)
4128 CHECK_OVERLAY (overlay
);
4130 return Fmarker_buffer (OVERLAY_START (overlay
));
4133 DEFUN ("overlay-properties", Foverlay_properties
, Soverlay_properties
, 1, 1, 0,
4134 doc
: /* Return a list of the properties on OVERLAY.
4135 This is a copy of OVERLAY's plist; modifying its conses has no effect on
4137 (Lisp_Object overlay
)
4139 CHECK_OVERLAY (overlay
);
4141 return Fcopy_sequence (XOVERLAY (overlay
)->plist
);
4145 DEFUN ("overlays-at", Foverlays_at
, Soverlays_at
, 1, 2, 0,
4146 doc
: /* Return a list of the overlays that contain the character at POS.
4147 If SORTED is non-nil, then sort them by decreasing priority. */)
4148 (Lisp_Object pos
, Lisp_Object sorted
)
4150 ptrdiff_t len
, noverlays
;
4151 Lisp_Object
*overlay_vec
;
4154 CHECK_NUMBER_COERCE_MARKER (pos
);
4156 if (!buffer_has_overlays ())
4160 /* We can't use alloca here because overlays_at can call xrealloc. */
4161 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4163 /* Put all the overlays we want in a vector in overlay_vec.
4164 Store the length in len. */
4165 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4169 noverlays
= sort_overlays (overlay_vec
, noverlays
,
4170 WINDOWP (sorted
) ? XWINDOW (sorted
) : NULL
);
4172 /* Make a list of them all. */
4173 result
= Flist (noverlays
, overlay_vec
);
4175 xfree (overlay_vec
);
4179 DEFUN ("overlays-in", Foverlays_in
, Soverlays_in
, 2, 2, 0,
4180 doc
: /* Return a list of the overlays that overlap the region BEG ... END.
4181 Overlap means that at least one character is contained within the overlay
4182 and also contained within the specified region.
4183 Empty overlays are included in the result if they are located at BEG,
4184 between BEG and END, or at END provided END denotes the position at the
4185 end of the buffer. */)
4186 (Lisp_Object beg
, Lisp_Object end
)
4188 ptrdiff_t len
, noverlays
;
4189 Lisp_Object
*overlay_vec
;
4192 CHECK_NUMBER_COERCE_MARKER (beg
);
4193 CHECK_NUMBER_COERCE_MARKER (end
);
4195 if (!buffer_has_overlays ())
4199 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4201 /* Put all the overlays we want in a vector in overlay_vec.
4202 Store the length in len. */
4203 noverlays
= overlays_in (XINT (beg
), XINT (end
), 1, &overlay_vec
, &len
,
4206 /* Make a list of them all. */
4207 result
= Flist (noverlays
, overlay_vec
);
4209 xfree (overlay_vec
);
4213 DEFUN ("next-overlay-change", Fnext_overlay_change
, Snext_overlay_change
,
4215 doc
: /* Return the next position after POS where an overlay starts or ends.
4216 If there are no overlay boundaries from POS to (point-max),
4217 the value is (point-max). */)
4220 ptrdiff_t i
, len
, noverlays
;
4222 Lisp_Object
*overlay_vec
;
4224 CHECK_NUMBER_COERCE_MARKER (pos
);
4226 if (!buffer_has_overlays ())
4227 return make_number (ZV
);
4230 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4232 /* Put all the overlays we want in a vector in overlay_vec.
4233 Store the length in len.
4234 endpos gets the position where the next overlay starts. */
4235 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4238 /* If any of these overlays ends before endpos,
4239 use its ending point instead. */
4240 for (i
= 0; i
< noverlays
; i
++)
4245 oend
= OVERLAY_END (overlay_vec
[i
]);
4246 oendpos
= OVERLAY_POSITION (oend
);
4247 if (oendpos
< endpos
)
4251 xfree (overlay_vec
);
4252 return make_number (endpos
);
4255 DEFUN ("previous-overlay-change", Fprevious_overlay_change
,
4256 Sprevious_overlay_change
, 1, 1, 0,
4257 doc
: /* Return the previous position before POS where an overlay starts or ends.
4258 If there are no overlay boundaries from (point-min) to POS,
4259 the value is (point-min). */)
4263 Lisp_Object
*overlay_vec
;
4266 CHECK_NUMBER_COERCE_MARKER (pos
);
4268 if (!buffer_has_overlays ())
4269 return make_number (BEGV
);
4271 /* At beginning of buffer, we know the answer;
4272 avoid bug subtracting 1 below. */
4273 if (XINT (pos
) == BEGV
)
4277 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4279 /* Put all the overlays we want in a vector in overlay_vec.
4280 Store the length in len.
4281 prevpos gets the position of the previous change. */
4282 overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4285 xfree (overlay_vec
);
4286 return make_number (prevpos
);
4289 /* These functions are for debugging overlays. */
4291 DEFUN ("overlay-lists", Foverlay_lists
, Soverlay_lists
, 0, 0, 0,
4292 doc
: /* Return a pair of lists giving all the overlays of the current buffer.
4293 The car has all the overlays before the overlay center;
4294 the cdr has all the overlays after the overlay center.
4295 Recentering overlays moves overlays between these lists.
4296 The lists you get are copies, so that changing them has no effect.
4297 However, the overlays you get are the real objects that the buffer uses. */)
4300 struct Lisp_Overlay
*ol
;
4301 Lisp_Object before
= Qnil
, after
= Qnil
, tmp
;
4303 for (ol
= current_buffer
->overlays_before
; ol
; ol
= ol
->next
)
4306 before
= Fcons (tmp
, before
);
4308 for (ol
= current_buffer
->overlays_after
; ol
; ol
= ol
->next
)
4311 after
= Fcons (tmp
, after
);
4314 return Fcons (Fnreverse (before
), Fnreverse (after
));
4317 DEFUN ("overlay-recenter", Foverlay_recenter
, Soverlay_recenter
, 1, 1, 0,
4318 doc
: /* Recenter the overlays of the current buffer around position POS.
4319 That makes overlay lookup faster for positions near POS (but perhaps slower
4320 for positions far away from POS). */)
4324 CHECK_NUMBER_COERCE_MARKER (pos
);
4326 p
= clip_to_bounds (PTRDIFF_MIN
, XINT (pos
), PTRDIFF_MAX
);
4327 recenter_overlay_lists (current_buffer
, p
);
4331 DEFUN ("overlay-get", Foverlay_get
, Soverlay_get
, 2, 2, 0,
4332 doc
: /* Get the property of overlay OVERLAY with property name PROP. */)
4333 (Lisp_Object overlay
, Lisp_Object prop
)
4335 CHECK_OVERLAY (overlay
);
4336 return lookup_char_property (XOVERLAY (overlay
)->plist
, prop
, 0);
4339 DEFUN ("overlay-put", Foverlay_put
, Soverlay_put
, 3, 3, 0,
4340 doc
: /* Set one property of overlay OVERLAY: give property PROP value VALUE.
4341 VALUE will be returned.*/)
4342 (Lisp_Object overlay
, Lisp_Object prop
, Lisp_Object value
)
4344 Lisp_Object tail
, buffer
;
4347 CHECK_OVERLAY (overlay
);
4349 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4351 for (tail
= XOVERLAY (overlay
)->plist
;
4352 CONSP (tail
) && CONSP (XCDR (tail
));
4353 tail
= XCDR (XCDR (tail
)))
4354 if (EQ (XCAR (tail
), prop
))
4356 changed
= !EQ (XCAR (XCDR (tail
)), value
);
4357 XSETCAR (XCDR (tail
), value
);
4360 /* It wasn't in the list, so add it to the front. */
4361 changed
= !NILP (value
);
4363 (overlay
, Fcons (prop
, Fcons (value
, XOVERLAY (overlay
)->plist
)));
4365 if (! NILP (buffer
))
4368 modify_overlay (XBUFFER (buffer
),
4369 marker_position (OVERLAY_START (overlay
)),
4370 marker_position (OVERLAY_END (overlay
)));
4371 if (EQ (prop
, Qevaporate
) && ! NILP (value
)
4372 && (OVERLAY_POSITION (OVERLAY_START (overlay
))
4373 == OVERLAY_POSITION (OVERLAY_END (overlay
))))
4374 Fdelete_overlay (overlay
);
4380 /* Subroutine of report_overlay_modification. */
4382 /* Lisp vector holding overlay hook functions to call.
4383 Vector elements come in pairs.
4384 Each even-index element is a list of hook functions.
4385 The following odd-index element is the overlay they came from.
4387 Before the buffer change, we fill in this vector
4388 as we call overlay hook functions.
4389 After the buffer change, we get the functions to call from this vector.
4390 This way we always call the same functions before and after the change. */
4391 static Lisp_Object last_overlay_modification_hooks
;
4393 /* Number of elements actually used in last_overlay_modification_hooks. */
4394 static ptrdiff_t last_overlay_modification_hooks_used
;
4396 /* Add one functionlist/overlay pair
4397 to the end of last_overlay_modification_hooks. */
4400 add_overlay_mod_hooklist (Lisp_Object functionlist
, Lisp_Object overlay
)
4402 ptrdiff_t oldsize
= ASIZE (last_overlay_modification_hooks
);
4404 if (oldsize
- 1 <= last_overlay_modification_hooks_used
)
4405 last_overlay_modification_hooks
=
4406 larger_vector (last_overlay_modification_hooks
, 2, -1);
4407 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4408 functionlist
); last_overlay_modification_hooks_used
++;
4409 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4410 overlay
); last_overlay_modification_hooks_used
++;
4413 /* Run the modification-hooks of overlays that include
4414 any part of the text in START to END.
4415 If this change is an insertion, also
4416 run the insert-before-hooks of overlay starting at END,
4417 and the insert-after-hooks of overlay ending at START.
4419 This is called both before and after the modification.
4420 AFTER is true when we call after the modification.
4422 ARG1, ARG2, ARG3 are arguments to pass to the hook functions.
4423 When AFTER is nonzero, they are the start position,
4424 the position after the inserted new text,
4425 and the length of deleted or replaced old text. */
4428 report_overlay_modification (Lisp_Object start
, Lisp_Object end
, bool after
,
4429 Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
)
4431 Lisp_Object prop
, overlay
;
4432 struct Lisp_Overlay
*tail
;
4433 /* True if this change is an insertion. */
4434 bool insertion
= (after
? XFASTINT (arg3
) == 0 : EQ (start
, end
));
4435 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4440 /* We used to run the functions as soon as we found them and only register
4441 them in last_overlay_modification_hooks for the purpose of the `after'
4442 case. But running elisp code as we traverse the list of overlays is
4443 painful because the list can be modified by the elisp code so we had to
4444 copy at several places. We now simply do a read-only traversal that
4445 only collects the functions to run and we run them afterwards. It's
4446 simpler, especially since all the code was already there. -stef */
4450 /* We are being called before a change.
4451 Scan the overlays to find the functions to call. */
4452 last_overlay_modification_hooks_used
= 0;
4453 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4455 ptrdiff_t startpos
, endpos
;
4456 Lisp_Object ostart
, oend
;
4458 XSETMISC (overlay
, tail
);
4460 ostart
= OVERLAY_START (overlay
);
4461 oend
= OVERLAY_END (overlay
);
4462 endpos
= OVERLAY_POSITION (oend
);
4463 if (XFASTINT (start
) > endpos
)
4465 startpos
= OVERLAY_POSITION (ostart
);
4466 if (insertion
&& (XFASTINT (start
) == startpos
4467 || XFASTINT (end
) == startpos
))
4469 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4471 add_overlay_mod_hooklist (prop
, overlay
);
4473 if (insertion
&& (XFASTINT (start
) == endpos
4474 || XFASTINT (end
) == endpos
))
4476 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4478 add_overlay_mod_hooklist (prop
, overlay
);
4480 /* Test for intersecting intervals. This does the right thing
4481 for both insertion and deletion. */
4482 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4484 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4486 add_overlay_mod_hooklist (prop
, overlay
);
4490 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4492 ptrdiff_t startpos
, endpos
;
4493 Lisp_Object ostart
, oend
;
4495 XSETMISC (overlay
, tail
);
4497 ostart
= OVERLAY_START (overlay
);
4498 oend
= OVERLAY_END (overlay
);
4499 startpos
= OVERLAY_POSITION (ostart
);
4500 endpos
= OVERLAY_POSITION (oend
);
4501 if (XFASTINT (end
) < startpos
)
4503 if (insertion
&& (XFASTINT (start
) == startpos
4504 || XFASTINT (end
) == startpos
))
4506 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4508 add_overlay_mod_hooklist (prop
, overlay
);
4510 if (insertion
&& (XFASTINT (start
) == endpos
4511 || XFASTINT (end
) == endpos
))
4513 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4515 add_overlay_mod_hooklist (prop
, overlay
);
4517 /* Test for intersecting intervals. This does the right thing
4518 for both insertion and deletion. */
4519 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4521 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4523 add_overlay_mod_hooklist (prop
, overlay
);
4528 GCPRO4 (overlay
, arg1
, arg2
, arg3
);
4530 /* Call the functions recorded in last_overlay_modification_hooks.
4531 First copy the vector contents, in case some of these hooks
4532 do subsequent modification of the buffer. */
4533 ptrdiff_t size
= last_overlay_modification_hooks_used
;
4538 SAFE_ALLOCA_LISP (copy
, size
);
4539 memcpy (copy
, XVECTOR (last_overlay_modification_hooks
)->contents
,
4542 for (i
= 0; i
< size
;)
4544 Lisp_Object prop_i
, overlay_i
;
4546 overlay_i
= copy
[i
++];
4547 call_overlay_mod_hooks (prop_i
, overlay_i
, after
, arg1
, arg2
, arg3
);
4556 call_overlay_mod_hooks (Lisp_Object list
, Lisp_Object overlay
, bool after
,
4557 Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
)
4559 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4561 GCPRO4 (list
, arg1
, arg2
, arg3
);
4563 while (CONSP (list
))
4566 call4 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
);
4568 call5 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
, arg3
);
4574 /* Delete any zero-sized overlays at position POS, if the `evaporate'
4577 evaporate_overlays (ptrdiff_t pos
)
4579 Lisp_Object overlay
, hit_list
;
4580 struct Lisp_Overlay
*tail
;
4583 if (pos
<= current_buffer
->overlay_center
)
4584 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4587 XSETMISC (overlay
, tail
);
4588 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4591 if (endpos
== pos
&& OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
4592 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4593 hit_list
= Fcons (overlay
, hit_list
);
4596 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4599 XSETMISC (overlay
, tail
);
4600 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4603 if (startpos
== pos
&& OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
4604 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4605 hit_list
= Fcons (overlay
, hit_list
);
4607 for (; CONSP (hit_list
); hit_list
= XCDR (hit_list
))
4608 Fdelete_overlay (XCAR (hit_list
));
4611 /***********************************************************************
4612 Allocation with mmap
4613 ***********************************************************************/
4615 /* Note: WINDOWSNT implements this stuff on w32heap.c. */
4616 #if defined USE_MMAP_FOR_BUFFERS && !defined WINDOWSNT
4618 #include <sys/mman.h>
4621 #ifdef MAP_ANONYMOUS
4622 #define MAP_ANON MAP_ANONYMOUS
4629 #define MAP_FAILED ((void *) -1)
4639 /* Memory is allocated in regions which are mapped using mmap(2).
4640 The current implementation lets the system select mapped
4641 addresses; we're not using MAP_FIXED in general, except when
4642 trying to enlarge regions.
4644 Each mapped region starts with a mmap_region structure, the user
4645 area starts after that structure, aligned to MEM_ALIGN.
4647 +-----------------------+
4648 | struct mmap_info + |
4650 +-----------------------+
4654 +-----------------------+ */
4658 /* User-specified size. */
4659 size_t nbytes_specified
;
4661 /* Number of bytes mapped */
4662 size_t nbytes_mapped
;
4664 /* Pointer to the location holding the address of the memory
4665 allocated with the mmap'd block. The variable actually points
4666 after this structure. */
4669 /* Next and previous in list of all mmap'd regions. */
4670 struct mmap_region
*next
, *prev
;
4673 /* Doubly-linked list of mmap'd regions. */
4675 static struct mmap_region
*mmap_regions
;
4677 /* File descriptor for mmap. If we don't have anonymous mapping,
4678 /dev/zero will be opened on it. */
4682 /* Page size on this system. */
4684 static int mmap_page_size
;
4686 /* 1 means mmap has been initialized. */
4688 static bool mmap_initialized_p
;
4690 /* Value is X rounded up to the next multiple of N. */
4692 #define ROUND(X, N) (((X) + (N) - 1) / (N) * (N))
4694 /* Size of mmap_region structure plus padding. */
4696 #define MMAP_REGION_STRUCT_SIZE \
4697 ROUND (sizeof (struct mmap_region), MEM_ALIGN)
4699 /* Given a pointer P to the start of the user-visible part of a mapped
4700 region, return a pointer to the start of the region. */
4702 #define MMAP_REGION(P) \
4703 ((struct mmap_region *) ((char *) (P) - MMAP_REGION_STRUCT_SIZE))
4705 /* Given a pointer P to the start of a mapped region, return a pointer
4706 to the start of the user-visible part of the region. */
4708 #define MMAP_USER_AREA(P) \
4709 ((void *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
4711 #define MEM_ALIGN sizeof (double)
4713 /* Predicate returning true if part of the address range [START .. END]
4714 is currently mapped. Used to prevent overwriting an existing
4717 Default is to conservatively assume the address range is occupied by
4718 something else. This can be overridden by system configuration
4719 files if system-specific means to determine this exists. */
4721 #ifndef MMAP_ALLOCATED_P
4722 #define MMAP_ALLOCATED_P(start, end) 1
4725 /* Perform necessary initializations for the use of mmap. */
4731 /* The value of mmap_fd is initially 0 in temacs, and -1
4732 in a dumped Emacs. */
4735 /* No anonymous mmap -- we need the file descriptor. */
4736 mmap_fd
= emacs_open ("/dev/zero", O_RDONLY
, 0);
4738 fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno
));
4740 #endif /* MAP_ANON == 0 */
4742 if (mmap_initialized_p
)
4744 mmap_initialized_p
= 1;
4750 mmap_page_size
= getpagesize ();
4753 /* Unmap a region. P is a pointer to the start of the user-araa of
4757 mmap_free_1 (struct mmap_region
*r
)
4760 r
->next
->prev
= r
->prev
;
4762 r
->prev
->next
= r
->next
;
4764 mmap_regions
= r
->next
;
4766 if (munmap (r
, r
->nbytes_mapped
) == -1)
4767 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4771 /* Enlarge region R by NPAGES pages. NPAGES < 0 means shrink R.
4772 Value is true if successful. */
4775 mmap_enlarge (struct mmap_region
*r
, int npages
)
4777 char *region_end
= (char *) r
+ r
->nbytes_mapped
;
4783 /* Unmap pages at the end of the region. */
4784 nbytes
= - npages
* mmap_page_size
;
4785 if (munmap (region_end
- nbytes
, nbytes
) == -1)
4786 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4789 r
->nbytes_mapped
-= nbytes
;
4793 else if (npages
> 0)
4795 nbytes
= npages
* mmap_page_size
;
4797 /* Try to map additional pages at the end of the region. We
4798 cannot do this if the address range is already occupied by
4799 something else because mmap deletes any previous mapping.
4800 I'm not sure this is worth doing, let's see. */
4801 if (!MMAP_ALLOCATED_P (region_end
, region_end
+ nbytes
))
4805 p
= mmap (region_end
, nbytes
, PROT_READ
| PROT_WRITE
,
4806 MAP_ANON
| MAP_PRIVATE
| MAP_FIXED
, mmap_fd
, 0);
4807 if (p
== MAP_FAILED
)
4808 ; /* fprintf (stderr, "mmap: %s\n", emacs_strerror (errno)); */
4809 else if (p
!= region_end
)
4811 /* Kernels are free to choose a different address. In
4812 that case, unmap what we've mapped above; we have
4814 if (munmap (p
, nbytes
) == -1)
4815 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4819 r
->nbytes_mapped
+= nbytes
;
4829 /* Allocate a block of storage large enough to hold NBYTES bytes of
4830 data. A pointer to the data is returned in *VAR. VAR is thus the
4831 address of some variable which will use the data area.
4833 The allocation of 0 bytes is valid.
4835 If we can't allocate the necessary memory, set *VAR to null, and
4839 mmap_alloc (void **var
, size_t nbytes
)
4846 map
= ROUND (nbytes
+ MMAP_REGION_STRUCT_SIZE
, mmap_page_size
);
4847 p
= mmap (NULL
, map
, PROT_READ
| PROT_WRITE
, MAP_ANON
| MAP_PRIVATE
,
4850 if (p
== MAP_FAILED
)
4852 if (errno
!= ENOMEM
)
4853 fprintf (stderr
, "mmap: %s\n", emacs_strerror (errno
));
4858 struct mmap_region
*r
= p
;
4860 r
->nbytes_specified
= nbytes
;
4861 r
->nbytes_mapped
= map
;
4864 r
->next
= mmap_regions
;
4869 p
= MMAP_USER_AREA (p
);
4876 /* Free a block of relocatable storage whose data is pointed to by
4877 PTR. Store 0 in *PTR to show there's no block allocated. */
4880 mmap_free (void **var
)
4886 mmap_free_1 (MMAP_REGION (*var
));
4892 /* Given a pointer at address VAR to data allocated with mmap_alloc,
4893 resize it to size NBYTES. Change *VAR to reflect the new block,
4894 and return this value. If more memory cannot be allocated, then
4895 leave *VAR unchanged, and return null. */
4898 mmap_realloc (void **var
, size_t nbytes
)
4905 result
= mmap_alloc (var
, nbytes
);
4906 else if (nbytes
== 0)
4909 result
= mmap_alloc (var
, nbytes
);
4913 struct mmap_region
*r
= MMAP_REGION (*var
);
4914 size_t room
= r
->nbytes_mapped
- MMAP_REGION_STRUCT_SIZE
;
4919 void *old_ptr
= *var
;
4921 /* Try to map additional pages at the end of the region.
4922 If that fails, allocate a new region, copy data
4923 from the old region, then free it. */
4924 if (mmap_enlarge (r
, (ROUND (nbytes
- room
, mmap_page_size
)
4927 r
->nbytes_specified
= nbytes
;
4928 *var
= result
= old_ptr
;
4930 else if (mmap_alloc (var
, nbytes
))
4932 memcpy (*var
, old_ptr
, r
->nbytes_specified
);
4933 mmap_free_1 (MMAP_REGION (old_ptr
));
4935 r
= MMAP_REGION (result
);
4936 r
->nbytes_specified
= nbytes
;
4944 else if (room
- nbytes
>= mmap_page_size
)
4946 /* Shrinking by at least a page. Let's give some
4947 memory back to the system.
4949 The extra parens are to make the division happens first,
4950 on positive values, so we know it will round towards
4952 mmap_enlarge (r
, - ((room
- nbytes
) / mmap_page_size
));
4954 r
->nbytes_specified
= nbytes
;
4958 /* Leave it alone. */
4960 r
->nbytes_specified
= nbytes
;
4968 #endif /* USE_MMAP_FOR_BUFFERS */
4972 /***********************************************************************
4973 Buffer-text Allocation
4974 ***********************************************************************/
4976 /* Allocate NBYTES bytes for buffer B's text buffer. */
4979 alloc_buffer_text (struct buffer
*b
, ptrdiff_t nbytes
)
4984 #if defined USE_MMAP_FOR_BUFFERS
4985 p
= mmap_alloc ((void **) &b
->text
->beg
, nbytes
);
4986 #elif defined REL_ALLOC
4987 p
= r_alloc ((void **) &b
->text
->beg
, nbytes
);
4989 p
= xmalloc (nbytes
);
4995 memory_full (nbytes
);
5002 /* Enlarge buffer B's text buffer by DELTA bytes. DELTA < 0 means
5006 enlarge_buffer_text (struct buffer
*b
, ptrdiff_t delta
)
5009 ptrdiff_t nbytes
= (BUF_Z_BYTE (b
) - BUF_BEG_BYTE (b
) + BUF_GAP_SIZE (b
) + 1
5012 #if defined USE_MMAP_FOR_BUFFERS
5013 p
= mmap_realloc ((void **) &b
->text
->beg
, nbytes
);
5014 #elif defined REL_ALLOC
5015 p
= r_re_alloc ((void **) &b
->text
->beg
, nbytes
);
5017 p
= xrealloc (b
->text
->beg
, nbytes
);
5023 memory_full (nbytes
);
5026 BUF_BEG_ADDR (b
) = p
;
5031 /* Free buffer B's text buffer. */
5034 free_buffer_text (struct buffer
*b
)
5038 #if defined USE_MMAP_FOR_BUFFERS
5039 mmap_free ((void **) &b
->text
->beg
);
5040 #elif defined REL_ALLOC
5041 r_alloc_free ((void **) &b
->text
->beg
);
5043 xfree (b
->text
->beg
);
5046 BUF_BEG_ADDR (b
) = NULL
;
5052 /***********************************************************************
5054 ***********************************************************************/
5057 init_buffer_once (void)
5061 memset (buffer_permanent_local_flags
, 0, sizeof buffer_permanent_local_flags
);
5063 /* Make sure all markable slots in buffer_defaults
5064 are initialized reasonably, so mark_buffer won't choke. */
5065 reset_buffer (&buffer_defaults
);
5066 eassert (EQ (BVAR (&buffer_defaults
, name
), make_number (0)));
5067 reset_buffer_local_variables (&buffer_defaults
, 1);
5068 eassert (EQ (BVAR (&buffer_local_symbols
, name
), make_number (0)));
5069 reset_buffer (&buffer_local_symbols
);
5070 reset_buffer_local_variables (&buffer_local_symbols
, 1);
5071 /* Prevent GC from getting confused. */
5072 buffer_defaults
.text
= &buffer_defaults
.own_text
;
5073 buffer_local_symbols
.text
= &buffer_local_symbols
.own_text
;
5074 /* No one will share the text with these buffers, but let's play it safe. */
5075 buffer_defaults
.indirections
= 0;
5076 buffer_local_symbols
.indirections
= 0;
5077 /* Likewise no one will display them. */
5078 buffer_defaults
.window_count
= 0;
5079 buffer_local_symbols
.window_count
= 0;
5080 set_buffer_intervals (&buffer_defaults
, NULL
);
5081 set_buffer_intervals (&buffer_local_symbols
, NULL
);
5082 /* This is not strictly necessary, but let's make them initialized. */
5083 bset_name (&buffer_defaults
, build_pure_c_string (" *buffer-defaults*"));
5084 bset_name (&buffer_local_symbols
, build_pure_c_string (" *buffer-local-symbols*"));
5085 BUFFER_PVEC_INIT (&buffer_defaults
);
5086 BUFFER_PVEC_INIT (&buffer_local_symbols
);
5088 /* Set up the default values of various buffer slots. */
5089 /* Must do these before making the first buffer! */
5091 /* real setup is done in bindings.el */
5092 bset_mode_line_format (&buffer_defaults
, build_pure_c_string ("%-"));
5093 bset_header_line_format (&buffer_defaults
, Qnil
);
5094 bset_abbrev_mode (&buffer_defaults
, Qnil
);
5095 bset_overwrite_mode (&buffer_defaults
, Qnil
);
5096 bset_case_fold_search (&buffer_defaults
, Qt
);
5097 bset_auto_fill_function (&buffer_defaults
, Qnil
);
5098 bset_selective_display (&buffer_defaults
, Qnil
);
5099 bset_selective_display_ellipses (&buffer_defaults
, Qt
);
5100 bset_abbrev_table (&buffer_defaults
, Qnil
);
5101 bset_display_table (&buffer_defaults
, Qnil
);
5102 bset_undo_list (&buffer_defaults
, Qnil
);
5103 bset_mark_active (&buffer_defaults
, Qnil
);
5104 bset_file_format (&buffer_defaults
, Qnil
);
5105 bset_auto_save_file_format (&buffer_defaults
, Qt
);
5106 set_buffer_overlays_before (&buffer_defaults
, NULL
);
5107 set_buffer_overlays_after (&buffer_defaults
, NULL
);
5108 buffer_defaults
.overlay_center
= BEG
;
5110 XSETFASTINT (BVAR (&buffer_defaults
, tab_width
), 8);
5111 bset_truncate_lines (&buffer_defaults
, Qnil
);
5112 bset_word_wrap (&buffer_defaults
, Qnil
);
5113 bset_ctl_arrow (&buffer_defaults
, Qt
);
5114 bset_bidi_display_reordering (&buffer_defaults
, Qt
);
5115 bset_bidi_paragraph_direction (&buffer_defaults
, Qnil
);
5116 bset_cursor_type (&buffer_defaults
, Qt
);
5117 bset_extra_line_spacing (&buffer_defaults
, Qnil
);
5118 bset_cursor_in_non_selected_windows (&buffer_defaults
, Qt
);
5120 bset_enable_multibyte_characters (&buffer_defaults
, Qt
);
5121 bset_buffer_file_coding_system (&buffer_defaults
, Qnil
);
5122 XSETFASTINT (BVAR (&buffer_defaults
, fill_column
), 70);
5123 XSETFASTINT (BVAR (&buffer_defaults
, left_margin
), 0);
5124 bset_cache_long_scans (&buffer_defaults
, Qt
);
5125 bset_file_truename (&buffer_defaults
, Qnil
);
5126 XSETFASTINT (BVAR (&buffer_defaults
, display_count
), 0);
5127 XSETFASTINT (BVAR (&buffer_defaults
, left_margin_cols
), 0);
5128 XSETFASTINT (BVAR (&buffer_defaults
, right_margin_cols
), 0);
5129 bset_left_fringe_width (&buffer_defaults
, Qnil
);
5130 bset_right_fringe_width (&buffer_defaults
, Qnil
);
5131 bset_fringes_outside_margins (&buffer_defaults
, Qnil
);
5132 bset_scroll_bar_width (&buffer_defaults
, Qnil
);
5133 bset_scroll_bar_height (&buffer_defaults
, Qnil
);
5134 bset_vertical_scroll_bar_type (&buffer_defaults
, Qt
);
5135 bset_horizontal_scroll_bar_type (&buffer_defaults
, Qt
);
5136 bset_indicate_empty_lines (&buffer_defaults
, Qnil
);
5137 bset_indicate_buffer_boundaries (&buffer_defaults
, Qnil
);
5138 bset_fringe_indicator_alist (&buffer_defaults
, Qnil
);
5139 bset_fringe_cursor_alist (&buffer_defaults
, Qnil
);
5140 bset_scroll_up_aggressively (&buffer_defaults
, Qnil
);
5141 bset_scroll_down_aggressively (&buffer_defaults
, Qnil
);
5142 bset_display_time (&buffer_defaults
, Qnil
);
5144 /* Assign the local-flags to the slots that have default values.
5145 The local flag is a bit that is used in the buffer
5146 to say that it has its own local value for the slot.
5147 The local flag bits are in the local_var_flags slot of the buffer. */
5149 /* Nothing can work if this isn't true */
5150 { verify (sizeof (EMACS_INT
) == word_size
); }
5152 /* 0 means not a lisp var, -1 means always local, else mask */
5153 memset (&buffer_local_flags
, 0, sizeof buffer_local_flags
);
5154 bset_filename (&buffer_local_flags
, make_number (-1));
5155 bset_directory (&buffer_local_flags
, make_number (-1));
5156 bset_backed_up (&buffer_local_flags
, make_number (-1));
5157 bset_save_length (&buffer_local_flags
, make_number (-1));
5158 bset_auto_save_file_name (&buffer_local_flags
, make_number (-1));
5159 bset_read_only (&buffer_local_flags
, make_number (-1));
5160 bset_major_mode (&buffer_local_flags
, make_number (-1));
5161 bset_mode_name (&buffer_local_flags
, make_number (-1));
5162 bset_undo_list (&buffer_local_flags
, make_number (-1));
5163 bset_mark_active (&buffer_local_flags
, make_number (-1));
5164 bset_point_before_scroll (&buffer_local_flags
, make_number (-1));
5165 bset_file_truename (&buffer_local_flags
, make_number (-1));
5166 bset_invisibility_spec (&buffer_local_flags
, make_number (-1));
5167 bset_file_format (&buffer_local_flags
, make_number (-1));
5168 bset_auto_save_file_format (&buffer_local_flags
, make_number (-1));
5169 bset_display_count (&buffer_local_flags
, make_number (-1));
5170 bset_display_time (&buffer_local_flags
, make_number (-1));
5171 bset_enable_multibyte_characters (&buffer_local_flags
, make_number (-1));
5174 XSETFASTINT (BVAR (&buffer_local_flags
, mode_line_format
), idx
); ++idx
;
5175 XSETFASTINT (BVAR (&buffer_local_flags
, abbrev_mode
), idx
); ++idx
;
5176 XSETFASTINT (BVAR (&buffer_local_flags
, overwrite_mode
), idx
); ++idx
;
5177 XSETFASTINT (BVAR (&buffer_local_flags
, case_fold_search
), idx
); ++idx
;
5178 XSETFASTINT (BVAR (&buffer_local_flags
, auto_fill_function
), idx
); ++idx
;
5179 XSETFASTINT (BVAR (&buffer_local_flags
, selective_display
), idx
); ++idx
;
5180 XSETFASTINT (BVAR (&buffer_local_flags
, selective_display_ellipses
), idx
); ++idx
;
5181 XSETFASTINT (BVAR (&buffer_local_flags
, tab_width
), idx
); ++idx
;
5182 XSETFASTINT (BVAR (&buffer_local_flags
, truncate_lines
), idx
); ++idx
;
5183 XSETFASTINT (BVAR (&buffer_local_flags
, word_wrap
), idx
); ++idx
;
5184 XSETFASTINT (BVAR (&buffer_local_flags
, ctl_arrow
), idx
); ++idx
;
5185 XSETFASTINT (BVAR (&buffer_local_flags
, fill_column
), idx
); ++idx
;
5186 XSETFASTINT (BVAR (&buffer_local_flags
, left_margin
), idx
); ++idx
;
5187 XSETFASTINT (BVAR (&buffer_local_flags
, abbrev_table
), idx
); ++idx
;
5188 XSETFASTINT (BVAR (&buffer_local_flags
, display_table
), idx
); ++idx
;
5189 XSETFASTINT (BVAR (&buffer_local_flags
, syntax_table
), idx
); ++idx
;
5190 XSETFASTINT (BVAR (&buffer_local_flags
, cache_long_scans
), idx
); ++idx
;
5191 XSETFASTINT (BVAR (&buffer_local_flags
, category_table
), idx
); ++idx
;
5192 XSETFASTINT (BVAR (&buffer_local_flags
, bidi_display_reordering
), idx
); ++idx
;
5193 XSETFASTINT (BVAR (&buffer_local_flags
, bidi_paragraph_direction
), idx
); ++idx
;
5194 XSETFASTINT (BVAR (&buffer_local_flags
, buffer_file_coding_system
), idx
);
5195 /* Make this one a permanent local. */
5196 buffer_permanent_local_flags
[idx
++] = 1;
5197 XSETFASTINT (BVAR (&buffer_local_flags
, left_margin_cols
), idx
); ++idx
;
5198 XSETFASTINT (BVAR (&buffer_local_flags
, right_margin_cols
), idx
); ++idx
;
5199 XSETFASTINT (BVAR (&buffer_local_flags
, left_fringe_width
), idx
); ++idx
;
5200 XSETFASTINT (BVAR (&buffer_local_flags
, right_fringe_width
), idx
); ++idx
;
5201 XSETFASTINT (BVAR (&buffer_local_flags
, fringes_outside_margins
), idx
); ++idx
;
5202 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_bar_width
), idx
); ++idx
;
5203 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_bar_height
), idx
); ++idx
;
5204 XSETFASTINT (BVAR (&buffer_local_flags
, vertical_scroll_bar_type
), idx
); ++idx
;
5205 XSETFASTINT (BVAR (&buffer_local_flags
, horizontal_scroll_bar_type
), idx
); ++idx
;
5206 XSETFASTINT (BVAR (&buffer_local_flags
, indicate_empty_lines
), idx
); ++idx
;
5207 XSETFASTINT (BVAR (&buffer_local_flags
, indicate_buffer_boundaries
), idx
); ++idx
;
5208 XSETFASTINT (BVAR (&buffer_local_flags
, fringe_indicator_alist
), idx
); ++idx
;
5209 XSETFASTINT (BVAR (&buffer_local_flags
, fringe_cursor_alist
), idx
); ++idx
;
5210 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_up_aggressively
), idx
); ++idx
;
5211 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_down_aggressively
), idx
); ++idx
;
5212 XSETFASTINT (BVAR (&buffer_local_flags
, header_line_format
), idx
); ++idx
;
5213 XSETFASTINT (BVAR (&buffer_local_flags
, cursor_type
), idx
); ++idx
;
5214 XSETFASTINT (BVAR (&buffer_local_flags
, extra_line_spacing
), idx
); ++idx
;
5215 XSETFASTINT (BVAR (&buffer_local_flags
, cursor_in_non_selected_windows
), idx
); ++idx
;
5217 /* Need more room? */
5218 if (idx
>= MAX_PER_BUFFER_VARS
)
5220 last_per_buffer_idx
= idx
;
5222 Vbuffer_alist
= Qnil
;
5226 QSFundamental
= build_pure_c_string ("Fundamental");
5228 DEFSYM (Qfundamental_mode
, "fundamental-mode");
5229 bset_major_mode (&buffer_defaults
, Qfundamental_mode
);
5231 DEFSYM (Qmode_class
, "mode-class");
5232 DEFSYM (Qprotected_field
, "protected-field");
5234 DEFSYM (Qpermanent_local
, "permanent-local");
5235 DEFSYM (Qkill_buffer_hook
, "kill-buffer-hook");
5236 Fput (Qkill_buffer_hook
, Qpermanent_local
, Qt
);
5238 /* super-magic invisible buffer */
5239 Vprin1_to_string_buffer
= Fget_buffer_create (build_pure_c_string (" prin1"));
5240 Vbuffer_alist
= Qnil
;
5242 Fset_buffer (Fget_buffer_create (build_pure_c_string ("*scratch*")));
5244 inhibit_modification_hooks
= 0;
5248 init_buffer (int initialized
)
5254 #ifdef USE_MMAP_FOR_BUFFERS
5260 /* These must be reset in the dumped Emacs, to avoid stale
5261 references to mmap'ed memory from before the dump.
5263 WINDOWSNT doesn't need this because it doesn't track mmap'ed
5264 regions by hand (see w32heap.c, which uses system APIs for
5265 that purpose), and thus doesn't use mmap_regions. */
5266 mmap_regions
= NULL
;
5270 /* The dumped buffers reference addresses of buffer text
5271 recorded by temacs, that cannot be used by the dumped Emacs.
5272 We map new memory for their text here.
5274 Implementation note: the buffers we carry from temacs are:
5275 " prin1", "*scratch*", " *Minibuf-0*", "*Messages*", and
5276 " *code-conversion-work*". They are created by
5277 init_buffer_once and init_window_once (which are not called
5278 in the dumped Emacs), and by the first call to coding.c routines. */
5281 b
->text
->beg
= NULL
;
5282 enlarge_buffer_text (b
, 0);
5289 /* Only buffers with allocated buffer text should be present at
5290 this point in temacs. */
5293 eassert (b
->text
->beg
!= NULL
);
5296 #else /* not USE_MMAP_FOR_BUFFERS */
5297 /* Avoid compiler warnings. */
5299 #endif /* USE_MMAP_FOR_BUFFERS */
5301 AUTO_STRING (scratch
, "*scratch*");
5302 Fset_buffer (Fget_buffer_create (scratch
));
5303 if (NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
)))
5304 Fset_buffer_multibyte (Qnil
);
5306 pwd
= get_current_dir_name ();
5309 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5311 /* Maybe this should really use some standard subroutine
5312 whose definition is filename syntax dependent. */
5314 if (!(IS_DIRECTORY_SEP (pwd
[len
- 1])))
5316 /* Grow buffer to add directory separator and '\0'. */
5317 pwd
= realloc (pwd
, len
+ 2);
5319 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5320 pwd
[len
] = DIRECTORY_SEP
;
5321 pwd
[len
+ 1] = '\0';
5325 /* At this moment, we still don't know how to decode the directory
5326 name. So, we keep the bytes in unibyte form so that file I/O
5327 routines correctly get the original bytes. */
5328 bset_directory (current_buffer
, make_unibyte_string (pwd
, len
));
5330 /* Add /: to the front of the name
5331 if it would otherwise be treated as magic. */
5332 temp
= Ffind_file_name_handler (BVAR (current_buffer
, directory
), Qt
);
5334 /* If the default dir is just /, TEMP is non-nil
5335 because of the ange-ftp completion handler.
5336 However, it is not necessary to turn / into /:/.
5337 So avoid doing that. */
5338 && strcmp ("/", SSDATA (BVAR (current_buffer
, directory
))))
5340 AUTO_STRING (slash_colon
, "/:");
5341 bset_directory (current_buffer
,
5342 concat2 (slash_colon
,
5343 BVAR (current_buffer
, directory
)));
5346 temp
= get_minibuffer (0);
5347 bset_directory (XBUFFER (temp
), BVAR (current_buffer
, directory
));
5352 /* Similar to defvar_lisp but define a variable whose value is the
5353 Lisp_Object stored in the current buffer. LNAME is the Lisp-level
5354 variable name. VNAME is the name of the buffer slot. PREDICATE
5355 is nil for a general Lisp variable. If PREDICATE is non-nil, then
5356 only Lisp values that satisfies the PREDICATE are allowed (except
5357 that nil is allowed too). DOC is a dummy where you write the doc
5358 string as a comment. */
5360 #define DEFVAR_PER_BUFFER(lname, vname, predicate, doc) \
5362 static struct Lisp_Buffer_Objfwd bo_fwd; \
5363 defvar_per_buffer (&bo_fwd, lname, vname, predicate); \
5367 defvar_per_buffer (struct Lisp_Buffer_Objfwd
*bo_fwd
, const char *namestring
,
5368 Lisp_Object
*address
, Lisp_Object predicate
)
5370 struct Lisp_Symbol
*sym
;
5373 sym
= XSYMBOL (intern (namestring
));
5374 offset
= (char *)address
- (char *)current_buffer
;
5376 bo_fwd
->type
= Lisp_Fwd_Buffer_Obj
;
5377 bo_fwd
->offset
= offset
;
5378 bo_fwd
->predicate
= predicate
;
5379 sym
->declared_special
= 1;
5380 sym
->redirect
= SYMBOL_FORWARDED
;
5381 SET_SYMBOL_FWD (sym
, (union Lisp_Fwd
*) bo_fwd
);
5382 XSETSYMBOL (PER_BUFFER_SYMBOL (offset
), sym
);
5384 if (PER_BUFFER_IDX (offset
) == 0)
5385 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
5386 slot of buffer_local_flags. */
5391 /* Initialize the buffer routines. */
5393 syms_of_buffer (void)
5395 staticpro (&last_overlay_modification_hooks
);
5396 last_overlay_modification_hooks
5397 = Fmake_vector (make_number (10), Qnil
);
5399 staticpro (&QSFundamental
);
5400 staticpro (&Vbuffer_alist
);
5402 DEFSYM (Qchoice
, "choice");
5403 DEFSYM (Qleft
, "left");
5404 DEFSYM (Qright
, "right");
5405 DEFSYM (Qrange
, "range");
5407 DEFSYM (Qpermanent_local_hook
, "permanent-local-hook");
5408 DEFSYM (Qoverlayp
, "overlayp");
5409 DEFSYM (Qevaporate
, "evaporate");
5410 DEFSYM (Qmodification_hooks
, "modification-hooks");
5411 DEFSYM (Qinsert_in_front_hooks
, "insert-in-front-hooks");
5412 DEFSYM (Qinsert_behind_hooks
, "insert-behind-hooks");
5413 DEFSYM (Qget_file_buffer
, "get-file-buffer");
5414 DEFSYM (Qpriority
, "priority");
5415 DEFSYM (Qbefore_string
, "before-string");
5416 DEFSYM (Qafter_string
, "after-string");
5417 DEFSYM (Qfirst_change_hook
, "first-change-hook");
5418 DEFSYM (Qbefore_change_functions
, "before-change-functions");
5419 DEFSYM (Qafter_change_functions
, "after-change-functions");
5420 DEFSYM (Qkill_buffer_query_functions
, "kill-buffer-query-functions");
5422 DEFSYM (Qvertical_scroll_bar
, "vertical-scroll-bar");
5423 Fput (Qvertical_scroll_bar
, Qchoice
, list4 (Qnil
, Qt
, Qleft
, Qright
));
5424 DEFSYM (Qhorizontal_scroll_bar
, "horizontal-scroll-bar");
5426 DEFSYM (Qfraction
, "fraction");
5427 Fput (Qfraction
, Qrange
, Fcons (make_float (0.0), make_float (1.0)));
5429 DEFSYM (Qoverwrite_mode
, "overwrite-mode");
5430 Fput (Qoverwrite_mode
, Qchoice
,
5431 list3 (Qnil
, intern ("overwrite-mode-textual"),
5432 intern ("overwrite-mode-binary")));
5434 Fput (Qprotected_field
, Qerror_conditions
,
5435 listn (CONSTYPE_PURE
, 2, Qprotected_field
, Qerror
));
5436 Fput (Qprotected_field
, Qerror_message
,
5437 build_pure_c_string ("Attempt to modify a protected field"));
5439 DEFVAR_BUFFER_DEFAULTS ("default-mode-line-format",
5441 doc
: /* Default value of `mode-line-format' for buffers that don't override it.
5442 This is the same as (default-value 'mode-line-format). */);
5444 DEFVAR_BUFFER_DEFAULTS ("default-header-line-format",
5446 doc
: /* Default value of `header-line-format' for buffers that don't override it.
5447 This is the same as (default-value 'header-line-format). */);
5449 DEFVAR_BUFFER_DEFAULTS ("default-cursor-type", cursor_type
,
5450 doc
: /* Default value of `cursor-type' for buffers that don't override it.
5451 This is the same as (default-value 'cursor-type). */);
5453 DEFVAR_BUFFER_DEFAULTS ("default-line-spacing",
5455 doc
: /* Default value of `line-spacing' for buffers that don't override it.
5456 This is the same as (default-value 'line-spacing). */);
5458 DEFVAR_BUFFER_DEFAULTS ("default-cursor-in-non-selected-windows",
5459 cursor_in_non_selected_windows
,
5460 doc
: /* Default value of `cursor-in-non-selected-windows'.
5461 This is the same as (default-value 'cursor-in-non-selected-windows). */);
5463 DEFVAR_BUFFER_DEFAULTS ("default-abbrev-mode",
5465 doc
: /* Default value of `abbrev-mode' for buffers that do not override it.
5466 This is the same as (default-value 'abbrev-mode). */);
5468 DEFVAR_BUFFER_DEFAULTS ("default-ctl-arrow",
5470 doc
: /* Default value of `ctl-arrow' for buffers that do not override it.
5471 This is the same as (default-value 'ctl-arrow). */);
5473 DEFVAR_BUFFER_DEFAULTS ("default-enable-multibyte-characters",
5474 enable_multibyte_characters
,
5475 doc
: /* Default value of `enable-multibyte-characters' for buffers not overriding it.
5476 This is the same as (default-value 'enable-multibyte-characters). */);
5478 DEFVAR_BUFFER_DEFAULTS ("default-buffer-file-coding-system",
5479 buffer_file_coding_system
,
5480 doc
: /* Default value of `buffer-file-coding-system' for buffers not overriding it.
5481 This is the same as (default-value 'buffer-file-coding-system). */);
5483 DEFVAR_BUFFER_DEFAULTS ("default-truncate-lines",
5485 doc
: /* Default value of `truncate-lines' for buffers that do not override it.
5486 This is the same as (default-value 'truncate-lines). */);
5488 DEFVAR_BUFFER_DEFAULTS ("default-fill-column",
5490 doc
: /* Default value of `fill-column' for buffers that do not override it.
5491 This is the same as (default-value 'fill-column). */);
5493 DEFVAR_BUFFER_DEFAULTS ("default-left-margin",
5495 doc
: /* Default value of `left-margin' for buffers that do not override it.
5496 This is the same as (default-value 'left-margin). */);
5498 DEFVAR_BUFFER_DEFAULTS ("default-tab-width",
5500 doc
: /* Default value of `tab-width' for buffers that do not override it.
5501 NOTE: This controls the display width of a TAB character, and not
5502 the size of an indentation step.
5503 This is the same as (default-value 'tab-width). */);
5505 DEFVAR_BUFFER_DEFAULTS ("default-case-fold-search",
5507 doc
: /* Default value of `case-fold-search' for buffers that don't override it.
5508 This is the same as (default-value 'case-fold-search). */);
5510 DEFVAR_BUFFER_DEFAULTS ("default-left-margin-width",
5512 doc
: /* Default value of `left-margin-width' for buffers that don't override it.
5513 This is the same as (default-value 'left-margin-width). */);
5515 DEFVAR_BUFFER_DEFAULTS ("default-right-margin-width",
5517 doc
: /* Default value of `right-margin-width' for buffers that don't override it.
5518 This is the same as (default-value 'right-margin-width). */);
5520 DEFVAR_BUFFER_DEFAULTS ("default-left-fringe-width",
5522 doc
: /* Default value of `left-fringe-width' for buffers that don't override it.
5523 This is the same as (default-value 'left-fringe-width). */);
5525 DEFVAR_BUFFER_DEFAULTS ("default-right-fringe-width",
5527 doc
: /* Default value of `right-fringe-width' for buffers that don't override it.
5528 This is the same as (default-value 'right-fringe-width). */);
5530 DEFVAR_BUFFER_DEFAULTS ("default-fringes-outside-margins",
5531 fringes_outside_margins
,
5532 doc
: /* Default value of `fringes-outside-margins' for buffers that don't override it.
5533 This is the same as (default-value 'fringes-outside-margins). */);
5535 DEFVAR_BUFFER_DEFAULTS ("default-scroll-bar-width",
5537 doc
: /* Default value of `scroll-bar-width' for buffers that don't override it.
5538 This is the same as (default-value 'scroll-bar-width). */);
5540 DEFVAR_BUFFER_DEFAULTS ("default-vertical-scroll-bar",
5541 vertical_scroll_bar_type
,
5542 doc
: /* Default value of `vertical-scroll-bar' for buffers that don't override it.
5543 This is the same as (default-value 'vertical-scroll-bar). */);
5545 DEFVAR_BUFFER_DEFAULTS ("default-indicate-empty-lines",
5546 indicate_empty_lines
,
5547 doc
: /* Default value of `indicate-empty-lines' for buffers that don't override it.
5548 This is the same as (default-value 'indicate-empty-lines). */);
5550 DEFVAR_BUFFER_DEFAULTS ("default-indicate-buffer-boundaries",
5551 indicate_buffer_boundaries
,
5552 doc
: /* Default value of `indicate-buffer-boundaries' for buffers that don't override it.
5553 This is the same as (default-value 'indicate-buffer-boundaries). */);
5555 DEFVAR_BUFFER_DEFAULTS ("default-fringe-indicator-alist",
5556 fringe_indicator_alist
,
5557 doc
: /* Default value of `fringe-indicator-alist' for buffers that don't override it.
5558 This is the same as (default-value 'fringe-indicator-alist'). */);
5560 DEFVAR_BUFFER_DEFAULTS ("default-fringe-cursor-alist",
5561 fringe_cursor_alist
,
5562 doc
: /* Default value of `fringe-cursor-alist' for buffers that don't override it.
5563 This is the same as (default-value 'fringe-cursor-alist'). */);
5565 DEFVAR_BUFFER_DEFAULTS ("default-scroll-up-aggressively",
5566 scroll_up_aggressively
,
5567 doc
: /* Default value of `scroll-up-aggressively'.
5568 This value applies in buffers that don't have their own local values.
5569 This is the same as (default-value 'scroll-up-aggressively). */);
5571 DEFVAR_BUFFER_DEFAULTS ("default-scroll-down-aggressively",
5572 scroll_down_aggressively
,
5573 doc
: /* Default value of `scroll-down-aggressively'.
5574 This value applies in buffers that don't have their own local values.
5575 This is the same as (default-value 'scroll-down-aggressively). */);
5577 DEFVAR_PER_BUFFER ("header-line-format",
5578 &BVAR (current_buffer
, header_line_format
),
5580 doc
: /* Analogous to `mode-line-format', but controls the header line.
5581 The header line appears, optionally, at the top of a window;
5582 the mode line appears at the bottom. */);
5584 DEFVAR_PER_BUFFER ("mode-line-format", &BVAR (current_buffer
, mode_line_format
),
5586 doc
: /* Template for displaying mode line for current buffer.
5588 The value may be nil, a string, a symbol or a list.
5590 A value of nil means don't display a mode line.
5592 For any symbol other than t or nil, the symbol's value is processed as
5593 a mode line construct. As a special exception, if that value is a
5594 string, the string is processed verbatim, without handling any
5595 %-constructs (see below). Also, unless the symbol has a non-nil
5596 `risky-local-variable' property, all properties in any strings, as
5597 well as all :eval and :propertize forms in the value, are ignored.
5599 A list whose car is a string or list is processed by processing each
5600 of the list elements recursively, as separate mode line constructs,
5601 and concatenating the results.
5603 A list of the form `(:eval FORM)' is processed by evaluating FORM and
5604 using the result as a mode line construct. Be careful--FORM should
5605 not load any files, because that can cause an infinite recursion.
5607 A list of the form `(:propertize ELT PROPS...)' is processed by
5608 processing ELT as the mode line construct, and adding the text
5609 properties PROPS to the result.
5611 A list whose car is a symbol is processed by examining the symbol's
5612 value, and, if that value is non-nil, processing the cadr of the list
5613 recursively; and if that value is nil, processing the caddr of the
5616 A list whose car is an integer is processed by processing the cadr of
5617 the list, and padding (if the number is positive) or truncating (if
5618 negative) to the width specified by that number.
5620 A string is printed verbatim in the mode line except for %-constructs:
5621 %b -- print buffer name. %f -- print visited file name.
5622 %F -- print frame name.
5623 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
5624 %& is like %*, but ignore read-only-ness.
5625 % means buffer is read-only and * means it is modified.
5626 For a modified read-only buffer, %* gives % and %+ gives *.
5627 %s -- print process status. %l -- print the current line number.
5628 %c -- print the current column number (this makes editing slower).
5629 To make the column number update correctly in all cases,
5630 `column-number-mode' must be non-nil.
5631 %i -- print the size of the buffer.
5632 %I -- like %i, but use k, M, G, etc., to abbreviate.
5633 %p -- print percent of buffer above top of window, or Top, Bot or All.
5634 %P -- print percent of buffer above bottom of window, perhaps plus Top,
5635 or print Bottom or All.
5636 %n -- print Narrow if appropriate.
5637 %t -- visited file is text or binary (if OS supports this distinction).
5638 %z -- print mnemonics of keyboard, terminal, and buffer coding systems.
5639 %Z -- like %z, but including the end-of-line format.
5640 %e -- print error message about full memory.
5641 %@ -- print @ or hyphen. @ means that default-directory is on a
5643 %[ -- print one [ for each recursive editing level. %] similar.
5644 %% -- print %. %- -- print infinitely many dashes.
5645 Decimal digits after the % specify field width to which to pad. */);
5647 DEFVAR_BUFFER_DEFAULTS ("default-major-mode", major_mode
,
5648 doc
: /* Value of `major-mode' for new buffers. */);
5650 DEFVAR_PER_BUFFER ("major-mode", &BVAR (current_buffer
, major_mode
),
5652 doc
: /* Symbol for current buffer's major mode.
5653 The default value (normally `fundamental-mode') affects new buffers.
5654 A value of nil means to use the current buffer's major mode, provided
5655 it is not marked as "special".
5657 When a mode is used by default, `find-file' switches to it before it
5658 reads the contents into the buffer and before it finishes setting up
5659 the buffer. Thus, the mode and its hooks should not expect certain
5660 variables such as `buffer-read-only' and `buffer-file-coding-system'
5663 DEFVAR_PER_BUFFER ("mode-name", &BVAR (current_buffer
, mode_name
),
5665 doc
: /* Pretty name of current buffer's major mode.
5666 Usually a string, but can use any of the constructs for `mode-line-format',
5668 Format with `format-mode-line' to produce a string value. */);
5670 DEFVAR_PER_BUFFER ("local-abbrev-table", &BVAR (current_buffer
, abbrev_table
), Qnil
,
5671 doc
: /* Local (mode-specific) abbrev table of current buffer. */);
5673 DEFVAR_PER_BUFFER ("abbrev-mode", &BVAR (current_buffer
, abbrev_mode
), Qnil
,
5674 doc
: /* Non-nil if Abbrev mode is enabled.
5675 Use the command `abbrev-mode' to change this variable. */);
5677 DEFVAR_PER_BUFFER ("case-fold-search", &BVAR (current_buffer
, case_fold_search
),
5679 doc
: /* Non-nil if searches and matches should ignore case. */);
5681 DEFVAR_PER_BUFFER ("fill-column", &BVAR (current_buffer
, fill_column
),
5683 doc
: /* Column beyond which automatic line-wrapping should happen.
5684 Interactively, you can set the buffer local value using \\[set-fill-column]. */);
5686 DEFVAR_PER_BUFFER ("left-margin", &BVAR (current_buffer
, left_margin
),
5688 doc
: /* Column for the default `indent-line-function' to indent to.
5689 Linefeed indents to this column in Fundamental mode. */);
5691 DEFVAR_PER_BUFFER ("tab-width", &BVAR (current_buffer
, tab_width
),
5693 doc
: /* Distance between tab stops (for display of tab characters), in columns.
5694 NOTE: This controls the display width of a TAB character, and not
5695 the size of an indentation step.
5696 This should be an integer greater than zero. */);
5698 DEFVAR_PER_BUFFER ("ctl-arrow", &BVAR (current_buffer
, ctl_arrow
), Qnil
,
5699 doc
: /* Non-nil means display control chars with uparrow.
5700 A value of nil means use backslash and octal digits.
5701 This variable does not apply to characters whose display is specified
5702 in the current display table (if there is one). */);
5704 DEFVAR_PER_BUFFER ("enable-multibyte-characters",
5705 &BVAR (current_buffer
, enable_multibyte_characters
),
5707 doc
: /* Non-nil means the buffer contents are regarded as multi-byte characters.
5708 Otherwise they are regarded as unibyte. This affects the display,
5709 file I/O and the behavior of various editing commands.
5711 This variable is buffer-local but you cannot set it directly;
5712 use the function `set-buffer-multibyte' to change a buffer's representation.
5713 See also Info node `(elisp)Text Representations'. */);
5714 XSYMBOL (intern_c_string ("enable-multibyte-characters"))->constant
= 1;
5716 DEFVAR_PER_BUFFER ("buffer-file-coding-system",
5717 &BVAR (current_buffer
, buffer_file_coding_system
), Qnil
,
5718 doc
: /* Coding system to be used for encoding the buffer contents on saving.
5719 This variable applies to saving the buffer, and also to `write-region'
5720 and other functions that use `write-region'.
5721 It does not apply to sending output to subprocesses, however.
5723 If this is nil, the buffer is saved without any code conversion
5724 unless some coding system is specified in `file-coding-system-alist'
5725 for the buffer file.
5727 If the text to be saved cannot be encoded as specified by this variable,
5728 an alternative encoding is selected by `select-safe-coding-system', which see.
5730 The variable `coding-system-for-write', if non-nil, overrides this variable.
5732 This variable is never applied to a way of decoding a file while reading it. */);
5734 DEFVAR_PER_BUFFER ("bidi-display-reordering",
5735 &BVAR (current_buffer
, bidi_display_reordering
), Qnil
,
5736 doc
: /* Non-nil means reorder bidirectional text for display in the visual order. */);
5738 DEFVAR_PER_BUFFER ("bidi-paragraph-direction",
5739 &BVAR (current_buffer
, bidi_paragraph_direction
), Qnil
,
5740 doc
: /* If non-nil, forces directionality of text paragraphs in the buffer.
5742 If this is nil (the default), the direction of each paragraph is
5743 determined by the first strong directional character of its text.
5744 The values of `right-to-left' and `left-to-right' override that.
5745 Any other value is treated as nil.
5747 This variable has no effect unless the buffer's value of
5748 \`bidi-display-reordering' is non-nil. */);
5750 DEFVAR_PER_BUFFER ("truncate-lines", &BVAR (current_buffer
, truncate_lines
), Qnil
,
5751 doc
: /* Non-nil means do not display continuation lines.
5752 Instead, give each line of text just one screen line.
5754 Note that this is overridden by the variable
5755 `truncate-partial-width-windows' if that variable is non-nil
5756 and this buffer is not full-frame width.
5758 Minibuffers set this variable to nil. */);
5760 DEFVAR_PER_BUFFER ("word-wrap", &BVAR (current_buffer
, word_wrap
), Qnil
,
5761 doc
: /* Non-nil means to use word-wrapping for continuation lines.
5762 When word-wrapping is on, continuation lines are wrapped at the space
5763 or tab character nearest to the right window edge.
5764 If nil, continuation lines are wrapped at the right screen edge.
5766 This variable has no effect if long lines are truncated (see
5767 `truncate-lines' and `truncate-partial-width-windows'). If you use
5768 word-wrapping, you might want to reduce the value of
5769 `truncate-partial-width-windows', since wrapping can make text readable
5770 in narrower windows.
5772 Instead of setting this variable directly, most users should use
5773 Visual Line mode . Visual Line mode, when enabled, sets `word-wrap'
5774 to t, and additionally redefines simple editing commands to act on
5775 visual lines rather than logical lines. See the documentation of
5776 `visual-line-mode'. */);
5778 DEFVAR_PER_BUFFER ("default-directory", &BVAR (current_buffer
, directory
),
5780 doc
: /* Name of default directory of current buffer. Should end with slash.
5781 To interactively change the default directory, use command `cd'. */);
5783 DEFVAR_PER_BUFFER ("auto-fill-function", &BVAR (current_buffer
, auto_fill_function
),
5785 doc
: /* Function called (if non-nil) to perform auto-fill.
5786 It is called after self-inserting any character specified in
5787 the `auto-fill-chars' table.
5788 NOTE: This variable is not a hook;
5789 its value may not be a list of functions. */);
5791 DEFVAR_PER_BUFFER ("buffer-file-name", &BVAR (current_buffer
, filename
),
5793 doc
: /* Name of file visited in current buffer, or nil if not visiting a file.
5794 This should be an absolute file name. */);
5796 DEFVAR_PER_BUFFER ("buffer-file-truename", &BVAR (current_buffer
, file_truename
),
5798 doc
: /* Abbreviated truename of file visited in current buffer, or nil if none.
5799 The truename of a file is calculated by `file-truename'
5800 and then abbreviated with `abbreviate-file-name'. */);
5802 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
5803 &BVAR (current_buffer
, auto_save_file_name
),
5805 doc
: /* Name of file for auto-saving current buffer.
5806 If it is nil, that means don't auto-save this buffer. */);
5808 DEFVAR_PER_BUFFER ("buffer-read-only", &BVAR (current_buffer
, read_only
), Qnil
,
5809 doc
: /* Non-nil if this buffer is read-only. */);
5811 DEFVAR_PER_BUFFER ("buffer-backed-up", &BVAR (current_buffer
, backed_up
), Qnil
,
5812 doc
: /* Non-nil if this buffer's file has been backed up.
5813 Backing up is done before the first time the file is saved. */);
5815 DEFVAR_PER_BUFFER ("buffer-saved-size", &BVAR (current_buffer
, save_length
),
5817 doc
: /* Length of current buffer when last read in, saved or auto-saved.
5819 -1 means auto-saving turned off until next real save.
5821 If you set this to -2, that means don't turn off auto-saving in this buffer
5822 if its text size shrinks. If you use `buffer-swap-text' on a buffer,
5823 you probably should set this to -2 in that buffer. */);
5825 DEFVAR_PER_BUFFER ("selective-display", &BVAR (current_buffer
, selective_display
),
5827 doc
: /* Non-nil enables selective display.
5828 An integer N as value means display only lines
5829 that start with less than N columns of space.
5830 A value of t means that the character ^M makes itself and
5831 all the rest of the line invisible; also, when saving the buffer
5832 in a file, save the ^M as a newline. */);
5834 DEFVAR_PER_BUFFER ("selective-display-ellipses",
5835 &BVAR (current_buffer
, selective_display_ellipses
),
5837 doc
: /* Non-nil means display ... on previous line when a line is invisible. */);
5839 DEFVAR_PER_BUFFER ("overwrite-mode", &BVAR (current_buffer
, overwrite_mode
),
5841 doc
: /* Non-nil if self-insertion should replace existing text.
5842 The value should be one of `overwrite-mode-textual',
5843 `overwrite-mode-binary', or nil.
5844 If it is `overwrite-mode-textual', self-insertion still
5845 inserts at the end of a line, and inserts when point is before a tab,
5846 until the tab is filled in.
5847 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too. */);
5849 DEFVAR_PER_BUFFER ("buffer-display-table", &BVAR (current_buffer
, display_table
),
5851 doc
: /* Display table that controls display of the contents of current buffer.
5853 If this variable is nil, the value of `standard-display-table' is used.
5854 Each window can have its own, overriding display table, see
5855 `set-window-display-table' and `window-display-table'.
5857 The display table is a char-table created with `make-display-table'.
5858 A char-table is an array indexed by character codes. Normal array
5859 primitives `aref' and `aset' can be used to access elements of a char-table.
5861 Each of the char-table elements control how to display the corresponding
5862 text character: the element at index C in the table says how to display
5863 the character whose code is C. Each element should be a vector of
5864 characters or nil. The value nil means display the character in the
5865 default fashion; otherwise, the characters from the vector are delivered
5866 to the screen instead of the original character.
5868 For example, (aset buffer-display-table ?X [?Y]) tells Emacs
5869 to display a capital Y instead of each X character.
5871 In addition, a char-table has six extra slots to control the display of:
5873 the end of a truncated screen line (extra-slot 0, a single character);
5874 the end of a continued line (extra-slot 1, a single character);
5875 the escape character used to display character codes in octal
5876 (extra-slot 2, a single character);
5877 the character used as an arrow for control characters (extra-slot 3,
5878 a single character);
5879 the decoration indicating the presence of invisible lines (extra-slot 4,
5880 a vector of characters);
5881 the character used to draw the border between side-by-side windows
5882 (extra-slot 5, a single character).
5884 See also the functions `display-table-slot' and `set-display-table-slot'. */);
5886 DEFVAR_PER_BUFFER ("left-margin-width", &BVAR (current_buffer
, left_margin_cols
),
5888 doc
: /* Width in columns of left marginal area for display of a buffer.
5889 A value of nil means no marginal area.
5891 Setting this variable does not take effect until a new buffer is displayed
5892 in a window. To make the change take effect, call `set-window-buffer'. */);
5894 DEFVAR_PER_BUFFER ("right-margin-width", &BVAR (current_buffer
, right_margin_cols
),
5896 doc
: /* Width in columns of right marginal area for display of a buffer.
5897 A value of nil means no marginal area.
5899 Setting this variable does not take effect until a new buffer is displayed
5900 in a window. To make the change take effect, call `set-window-buffer'. */);
5902 DEFVAR_PER_BUFFER ("left-fringe-width", &BVAR (current_buffer
, left_fringe_width
),
5904 doc
: /* Width of this buffer's left fringe (in pixels).
5905 A value of 0 means no left fringe is shown in this buffer's window.
5906 A value of nil means to use the left fringe width from the window's frame.
5908 Setting this variable does not take effect until a new buffer is displayed
5909 in a window. To make the change take effect, call `set-window-buffer'. */);
5911 DEFVAR_PER_BUFFER ("right-fringe-width", &BVAR (current_buffer
, right_fringe_width
),
5913 doc
: /* Width of this buffer's right fringe (in pixels).
5914 A value of 0 means no right fringe is shown in this buffer's window.
5915 A value of nil means to use the right fringe width from the window's frame.
5917 Setting this variable does not take effect until a new buffer is displayed
5918 in a window. To make the change take effect, call `set-window-buffer'. */);
5920 DEFVAR_PER_BUFFER ("fringes-outside-margins", &BVAR (current_buffer
, fringes_outside_margins
),
5922 doc
: /* Non-nil means to display fringes outside display margins.
5923 A value of nil means to display fringes between margins and buffer text.
5925 Setting this variable does not take effect until a new buffer is displayed
5926 in a window. To make the change take effect, call `set-window-buffer'. */);
5928 DEFVAR_PER_BUFFER ("scroll-bar-width", &BVAR (current_buffer
, scroll_bar_width
),
5930 doc
: /* Width of this buffer's vertical scroll bars in pixels.
5931 A value of nil means to use the scroll bar width from the window's frame. */);
5933 DEFVAR_PER_BUFFER ("scroll-bar-height", &BVAR (current_buffer
, scroll_bar_height
),
5935 doc
: /* Height of this buffer's horizontal scroll bars in pixels.
5936 A value of nil means to use the scroll bar height from the window's frame. */);
5938 DEFVAR_PER_BUFFER ("vertical-scroll-bar", &BVAR (current_buffer
, vertical_scroll_bar_type
),
5939 Qvertical_scroll_bar
,
5940 doc
: /* Position of this buffer's vertical scroll bar.
5941 The value takes effect whenever you tell a window to display this buffer;
5942 for instance, with `set-window-buffer' or when `display-buffer' displays it.
5944 A value of `left' or `right' means put the vertical scroll bar at that side
5945 of the window; a value of nil means don't show any vertical scroll bars.
5946 A value of t (the default) means do whatever the window's frame specifies. */);
5948 DEFVAR_PER_BUFFER ("horizontal-scroll-bar", &BVAR (current_buffer
, horizontal_scroll_bar_type
),
5950 doc
: /* Position of this buffer's horizontal scroll bar.
5951 The value takes effect whenever you tell a window to display this buffer;
5952 for instance, with `set-window-buffer' or when `display-buffer' displays it.
5954 A value of `bottom' means put the horizontal scroll bar at the bottom of
5955 the window; a value of nil means don't show any horizontal scroll bars.
5956 A value of t (the default) means do whatever the window's frame
5959 DEFVAR_PER_BUFFER ("indicate-empty-lines",
5960 &BVAR (current_buffer
, indicate_empty_lines
), Qnil
,
5961 doc
: /* Visually indicate empty lines after the buffer end.
5962 If non-nil, a bitmap is displayed in the left fringe of a window on
5963 window-systems. */);
5965 DEFVAR_PER_BUFFER ("indicate-buffer-boundaries",
5966 &BVAR (current_buffer
, indicate_buffer_boundaries
), Qnil
,
5967 doc
: /* Visually indicate buffer boundaries and scrolling.
5968 If non-nil, the first and last line of the buffer are marked in the fringe
5969 of a window on window-systems with angle bitmaps, or if the window can be
5970 scrolled, the top and bottom line of the window are marked with up and down
5973 If value is a symbol `left' or `right', both angle and arrow bitmaps
5974 are displayed in the left or right fringe, resp. Any other value
5975 that doesn't look like an alist means display the angle bitmaps in
5976 the left fringe but no arrows.
5978 You can exercise more precise control by using an alist as the
5979 value. Each alist element (INDICATOR . POSITION) specifies
5980 where to show one of the indicators. INDICATOR is one of `top',
5981 `bottom', `up', `down', or t, which specifies the default position,
5982 and POSITION is one of `left', `right', or nil, meaning do not show
5985 For example, ((top . left) (t . right)) places the top angle bitmap in
5986 left fringe, the bottom angle bitmap in right fringe, and both arrow
5987 bitmaps in right fringe. To show just the angle bitmaps in the left
5988 fringe, but no arrow bitmaps, use ((top . left) (bottom . left)). */);
5990 DEFVAR_PER_BUFFER ("fringe-indicator-alist",
5991 &BVAR (current_buffer
, fringe_indicator_alist
), Qnil
,
5992 doc
: /* Mapping from logical to physical fringe indicator bitmaps.
5993 The value is an alist where each element (INDICATOR . BITMAPS)
5994 specifies the fringe bitmaps used to display a specific logical
5997 INDICATOR specifies the logical indicator type which is one of the
5998 following symbols: `truncation' , `continuation', `overlay-arrow',
5999 `top', `bottom', `top-bottom', `up', `down', empty-line', or `unknown'.
6001 BITMAPS is a list of symbols (LEFT RIGHT [LEFT1 RIGHT1]) which specifies
6002 the actual bitmap shown in the left or right fringe for the logical
6003 indicator. LEFT and RIGHT are the bitmaps shown in the left and/or
6004 right fringe for the specific indicator. The LEFT1 or RIGHT1 bitmaps
6005 are used only for the `bottom' and `top-bottom' indicators when the
6006 last (only) line has no final newline. BITMAPS may also be a single
6007 symbol which is used in both left and right fringes. */);
6009 DEFVAR_PER_BUFFER ("fringe-cursor-alist",
6010 &BVAR (current_buffer
, fringe_cursor_alist
), Qnil
,
6011 doc
: /* Mapping from logical to physical fringe cursor bitmaps.
6012 The value is an alist where each element (CURSOR . BITMAP)
6013 specifies the fringe bitmaps used to display a specific logical
6014 cursor type in the fringe.
6016 CURSOR specifies the logical cursor type which is one of the following
6017 symbols: `box' , `hollow', `bar', `hbar', or `hollow-small'. The last
6018 one is used to show a hollow cursor on narrow lines display lines
6019 where the normal hollow cursor will not fit.
6021 BITMAP is the corresponding fringe bitmap shown for the logical
6024 DEFVAR_PER_BUFFER ("scroll-up-aggressively",
6025 &BVAR (current_buffer
, scroll_up_aggressively
), Qfraction
,
6026 doc
: /* How far to scroll windows upward.
6027 If you move point off the bottom, the window scrolls automatically.
6028 This variable controls how far it scrolls. The value nil, the default,
6029 means scroll to center point. A fraction means scroll to put point
6030 that fraction of the window's height from the bottom of the window.
6031 When the value is 0.0, point goes at the bottom line, which in the
6032 simple case that you moved off with C-f means scrolling just one line.
6033 1.0 means point goes at the top, so that in that simple case, the
6034 window scrolls by a full window height. Meaningful values are
6035 between 0.0 and 1.0, inclusive. */);
6037 DEFVAR_PER_BUFFER ("scroll-down-aggressively",
6038 &BVAR (current_buffer
, scroll_down_aggressively
), Qfraction
,
6039 doc
: /* How far to scroll windows downward.
6040 If you move point off the top, the window scrolls automatically.
6041 This variable controls how far it scrolls. The value nil, the default,
6042 means scroll to center point. A fraction means scroll to put point
6043 that fraction of the window's height from the top of the window.
6044 When the value is 0.0, point goes at the top line, which in the
6045 simple case that you moved off with C-b means scrolling just one line.
6046 1.0 means point goes at the bottom, so that in that simple case, the
6047 window scrolls by a full window height. Meaningful values are
6048 between 0.0 and 1.0, inclusive. */);
6050 DEFVAR_LISP ("before-change-functions", Vbefore_change_functions
,
6051 doc
: /* List of functions to call before each text change.
6052 Two arguments are passed to each function: the positions of
6053 the beginning and end of the range of old text to be changed.
6054 \(For an insertion, the beginning and end are at the same place.)
6055 No information is given about the length of the text after the change.
6057 Buffer changes made while executing the `before-change-functions'
6058 don't call any before-change or after-change functions.
6059 That's because `inhibit-modification-hooks' is temporarily set non-nil.
6061 If an unhandled error happens in running these functions,
6062 the variable's value remains nil. That prevents the error
6063 from happening repeatedly and making Emacs nonfunctional. */);
6064 Vbefore_change_functions
= Qnil
;
6066 DEFVAR_LISP ("after-change-functions", Vafter_change_functions
,
6067 doc
: /* List of functions to call after each text change.
6068 Three arguments are passed to each function: the positions of
6069 the beginning and end of the range of changed text,
6070 and the length in chars of the pre-change text replaced by that range.
6071 \(For an insertion, the pre-change length is zero;
6072 for a deletion, that length is the number of chars deleted,
6073 and the post-change beginning and end are at the same place.)
6075 Buffer changes made while executing the `after-change-functions'
6076 don't call any before-change or after-change functions.
6077 That's because `inhibit-modification-hooks' is temporarily set non-nil.
6079 If an unhandled error happens in running these functions,
6080 the variable's value remains nil. That prevents the error
6081 from happening repeatedly and making Emacs nonfunctional. */);
6082 Vafter_change_functions
= Qnil
;
6084 DEFVAR_LISP ("first-change-hook", Vfirst_change_hook
,
6085 doc
: /* A list of functions to call before changing a buffer which is unmodified.
6086 The functions are run using the `run-hooks' function. */);
6087 Vfirst_change_hook
= Qnil
;
6089 DEFVAR_PER_BUFFER ("buffer-undo-list", &BVAR (current_buffer
, undo_list
), Qnil
,
6090 doc
: /* List of undo entries in current buffer.
6091 Recent changes come first; older changes follow newer.
6093 An entry (BEG . END) represents an insertion which begins at
6094 position BEG and ends at position END.
6096 An entry (TEXT . POSITION) represents the deletion of the string TEXT
6097 from (abs POSITION). If POSITION is positive, point was at the front
6098 of the text being deleted; if negative, point was at the end.
6100 An entry (t HIGH LOW USEC PSEC) indicates that the buffer was previously
6101 unmodified; (HIGH LOW USEC PSEC) is in the same style as (current-time)
6102 and is the visited file's modification time, as of that time. If the
6103 modification time of the most recent save is different, this entry is
6106 An entry (t . 0) means means the buffer was previously unmodified but
6107 its time stamp was unknown because it was not associated with a file.
6108 An entry (t . -1) is similar, except that it means the buffer's visited
6111 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
6112 was modified between BEG and END. PROPERTY is the property name,
6113 and VALUE is the old value.
6115 An entry (apply FUN-NAME . ARGS) means undo the change with
6116 \(apply FUN-NAME ARGS).
6118 An entry (apply DELTA BEG END FUN-NAME . ARGS) supports selective undo
6119 in the active region. BEG and END is the range affected by this entry
6120 and DELTA is the number of characters added or deleted in that range by
6123 An entry (MARKER . DISTANCE) indicates that the marker MARKER
6124 was adjusted in position by the offset DISTANCE (an integer).
6126 An entry of the form POSITION indicates that point was at the buffer
6127 location given by the integer. Undoing an entry of this form places
6130 Entries with value `nil' mark undo boundaries. The undo command treats
6131 the changes between two undo boundaries as a single step to be undone.
6133 If the value of the variable is t, undo information is not recorded. */);
6135 DEFVAR_PER_BUFFER ("mark-active", &BVAR (current_buffer
, mark_active
), Qnil
,
6136 doc
: /* Non-nil means the mark and region are currently active in this buffer. */);
6138 DEFVAR_PER_BUFFER ("cache-long-scans", &BVAR (current_buffer
, cache_long_scans
), Qnil
,
6139 doc
: /* Non-nil means that Emacs should use caches in attempt to speedup buffer scans.
6141 There is no reason to set this to nil except for debugging purposes.
6143 Normally, the line-motion functions work by scanning the buffer for
6144 newlines. Columnar operations (like `move-to-column' and
6145 `compute-motion') also work by scanning the buffer, summing character
6146 widths as they go. This works well for ordinary text, but if the
6147 buffer's lines are very long (say, more than 500 characters), these
6148 motion functions will take longer to execute. Emacs may also take
6149 longer to update the display.
6151 If `cache-long-scans' is non-nil, these motion functions cache the
6152 results of their scans, and consult the cache to avoid rescanning
6153 regions of the buffer until the text is modified. The caches are most
6154 beneficial when they prevent the most searching---that is, when the
6155 buffer contains long lines and large regions of characters with the
6156 same, fixed screen width.
6158 When `cache-long-scans' is non-nil, processing short lines will
6159 become slightly slower (because of the overhead of consulting the
6160 cache), and the caches will use memory roughly proportional to the
6161 number of newlines and characters whose screen width varies.
6163 Bidirectional editing also requires buffer scans to find paragraph
6164 separators. If you have large paragraphs or no paragraph separators
6165 at all, these scans may be slow. If `cache-long-scans' is non-nil,
6166 results of these scans are cached. This doesn't help too much if
6167 paragraphs are of the reasonable (few thousands of characters) size.
6169 The caches require no explicit maintenance; their accuracy is
6170 maintained internally by the Emacs primitives. Enabling or disabling
6171 the cache should not affect the behavior of any of the motion
6172 functions; it should only affect their performance. */);
6174 DEFVAR_PER_BUFFER ("point-before-scroll", &BVAR (current_buffer
, point_before_scroll
), Qnil
,
6175 doc
: /* Value of point before the last series of scroll operations, or nil. */);
6177 DEFVAR_PER_BUFFER ("buffer-file-format", &BVAR (current_buffer
, file_format
), Qnil
,
6178 doc
: /* List of formats to use when saving this buffer.
6179 Formats are defined by `format-alist'. This variable is
6180 set when a file is visited. */);
6182 DEFVAR_PER_BUFFER ("buffer-auto-save-file-format",
6183 &BVAR (current_buffer
, auto_save_file_format
), Qnil
,
6184 doc
: /* Format in which to write auto-save files.
6185 Should be a list of symbols naming formats that are defined in `format-alist'.
6186 If it is t, which is the default, auto-save files are written in the
6187 same format as a regular save would use. */);
6189 DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
6190 &BVAR (current_buffer
, invisibility_spec
), Qnil
,
6191 doc
: /* Invisibility spec of this buffer.
6192 The default is t, which means that text is invisible if it has a non-nil
6193 `invisible' property.
6194 This variable can also be a list. The list can have two kinds of elements:
6195 `ATOM' and `(ATOM . ELLIPSIS)'. A text character is invisible if its
6196 `invisible' property is `ATOM', or has an `invisible' property that is a list
6197 that contains `ATOM'.
6198 If the `(ATOM . ELLIPSIS)' form is used, and `ELLIPSIS' is non-nil, an
6199 ellipsis will be displayed after the invisible characters.
6200 Setting this variable is very fast, much faster than scanning all the text in
6201 the buffer looking for properties to change. */);
6203 DEFVAR_PER_BUFFER ("buffer-display-count",
6204 &BVAR (current_buffer
, display_count
), Qintegerp
,
6205 doc
: /* A number incremented each time this buffer is displayed in a window.
6206 The function `set-window-buffer' increments it. */);
6208 DEFVAR_PER_BUFFER ("buffer-display-time",
6209 &BVAR (current_buffer
, display_time
), Qnil
,
6210 doc
: /* Time stamp updated each time this buffer is displayed in a window.
6211 The function `set-window-buffer' updates this variable
6212 to the value obtained by calling `current-time'.
6213 If the buffer has never been shown in a window, the value is nil. */);
6215 DEFVAR_LISP ("transient-mark-mode", Vtransient_mark_mode
,
6216 doc
: /* Non-nil if Transient Mark mode is enabled.
6217 See the command `transient-mark-mode' for a description of this minor mode.
6219 Non-nil also enables highlighting of the region whenever the mark is active.
6220 The variable `highlight-nonselected-windows' controls whether to highlight
6221 all windows or just the selected window.
6223 Lisp programs may give this variable certain special values:
6225 - A value of `lambda' enables Transient Mark mode temporarily.
6226 It is disabled again after any subsequent action that would
6227 normally deactivate the mark (e.g. buffer modification).
6229 - A value of (only . OLDVAL) enables Transient Mark mode
6230 temporarily. After any subsequent point motion command that is
6231 not shift-translated, or any other action that would normally
6232 deactivate the mark (e.g. buffer modification), the value of
6233 `transient-mark-mode' is set to OLDVAL. */);
6234 Vtransient_mark_mode
= Qnil
;
6236 DEFVAR_LISP ("inhibit-read-only", Vinhibit_read_only
,
6237 doc
: /* Non-nil means disregard read-only status of buffers or characters.
6238 If the value is t, disregard `buffer-read-only' and all `read-only'
6239 text properties. If the value is a list, disregard `buffer-read-only'
6240 and disregard a `read-only' text property if the property value
6241 is a member of the list. */);
6242 Vinhibit_read_only
= Qnil
;
6244 DEFVAR_PER_BUFFER ("cursor-type", &BVAR (current_buffer
, cursor_type
), Qnil
,
6245 doc
: /* Cursor to use when this buffer is in the selected window.
6246 Values are interpreted as follows:
6248 t use the cursor specified for the frame
6249 nil don't display a cursor
6250 box display a filled box cursor
6251 hollow display a hollow box cursor
6252 bar display a vertical bar cursor with default width
6253 (bar . WIDTH) display a vertical bar cursor with width WIDTH
6254 hbar display a horizontal bar cursor with default height
6255 (hbar . HEIGHT) display a horizontal bar cursor with height HEIGHT
6256 ANYTHING ELSE display a hollow box cursor
6258 When the buffer is displayed in a non-selected window, the
6259 cursor's appearance is instead controlled by the variable
6260 `cursor-in-non-selected-windows'. */);
6262 DEFVAR_PER_BUFFER ("line-spacing",
6263 &BVAR (current_buffer
, extra_line_spacing
), Qnumberp
,
6264 doc
: /* Additional space to put between lines when displaying a buffer.
6265 The space is measured in pixels, and put below lines on graphic displays,
6266 see `display-graphic-p'.
6267 If value is a floating point number, it specifies the spacing relative
6268 to the default frame line height. A value of nil means add no extra space. */);
6270 DEFVAR_PER_BUFFER ("cursor-in-non-selected-windows",
6271 &BVAR (current_buffer
, cursor_in_non_selected_windows
), Qnil
,
6272 doc
: /* Non-nil means show a cursor in non-selected windows.
6273 If nil, only shows a cursor in the selected window.
6274 If t, displays a cursor related to the usual cursor type
6275 \(a solid box becomes hollow, a bar becomes a narrower bar).
6276 You can also specify the cursor type as in the `cursor-type' variable.
6277 Use Custom to set this variable and update the display." */);
6279 DEFVAR_LISP ("kill-buffer-query-functions", Vkill_buffer_query_functions
,
6280 doc
: /* List of functions called with no args to query before killing a buffer.
6281 The buffer being killed will be current while the functions are running.
6283 If any of them returns nil, the buffer is not killed. Functions run by
6284 this hook are supposed to not change the current buffer. */);
6285 Vkill_buffer_query_functions
= Qnil
;
6287 DEFVAR_LISP ("change-major-mode-hook", Vchange_major_mode_hook
,
6288 doc
: /* Normal hook run before changing the major mode of a buffer.
6289 The function `kill-all-local-variables' runs this before doing anything else. */);
6290 Vchange_major_mode_hook
= Qnil
;
6291 DEFSYM (Qchange_major_mode_hook
, "change-major-mode-hook");
6293 DEFVAR_LISP ("buffer-list-update-hook", Vbuffer_list_update_hook
,
6294 doc
: /* Hook run when the buffer list changes.
6295 Functions running this hook are, `get-buffer-create',
6296 `make-indirect-buffer', `rename-buffer', `kill-buffer',
6297 `bury-buffer-internal' and `select-window'. */);
6298 Vbuffer_list_update_hook
= Qnil
;
6299 DEFSYM (Qbuffer_list_update_hook
, "buffer-list-update-hook");
6301 defsubr (&Sbuffer_live_p
);
6302 defsubr (&Sbuffer_list
);
6303 defsubr (&Sget_buffer
);
6304 defsubr (&Sget_file_buffer
);
6305 defsubr (&Sget_buffer_create
);
6306 defsubr (&Smake_indirect_buffer
);
6307 defsubr (&Sgenerate_new_buffer_name
);
6308 defsubr (&Sbuffer_name
);
6309 defsubr (&Sbuffer_file_name
);
6310 defsubr (&Sbuffer_base_buffer
);
6311 defsubr (&Sbuffer_local_value
);
6312 defsubr (&Sbuffer_local_variables
);
6313 defsubr (&Sbuffer_modified_p
);
6314 defsubr (&Sforce_mode_line_update
);
6315 defsubr (&Sset_buffer_modified_p
);
6316 defsubr (&Sbuffer_modified_tick
);
6317 defsubr (&Sbuffer_chars_modified_tick
);
6318 defsubr (&Srename_buffer
);
6319 defsubr (&Sother_buffer
);
6320 defsubr (&Sbuffer_enable_undo
);
6321 defsubr (&Skill_buffer
);
6322 defsubr (&Sbury_buffer_internal
);
6323 defsubr (&Sset_buffer_major_mode
);
6324 defsubr (&Scurrent_buffer
);
6325 defsubr (&Sset_buffer
);
6326 defsubr (&Sbarf_if_buffer_read_only
);
6327 defsubr (&Serase_buffer
);
6328 defsubr (&Sbuffer_swap_text
);
6329 defsubr (&Sset_buffer_multibyte
);
6330 defsubr (&Skill_all_local_variables
);
6332 defsubr (&Soverlayp
);
6333 defsubr (&Smake_overlay
);
6334 defsubr (&Sdelete_overlay
);
6335 defsubr (&Sdelete_all_overlays
);
6336 defsubr (&Smove_overlay
);
6337 defsubr (&Soverlay_start
);
6338 defsubr (&Soverlay_end
);
6339 defsubr (&Soverlay_buffer
);
6340 defsubr (&Soverlay_properties
);
6341 defsubr (&Soverlays_at
);
6342 defsubr (&Soverlays_in
);
6343 defsubr (&Snext_overlay_change
);
6344 defsubr (&Sprevious_overlay_change
);
6345 defsubr (&Soverlay_recenter
);
6346 defsubr (&Soverlay_lists
);
6347 defsubr (&Soverlay_get
);
6348 defsubr (&Soverlay_put
);
6349 defsubr (&Srestore_buffer_modified_p
);
6353 keys_of_buffer (void)
6355 initial_define_key (control_x_map
, 'b', "switch-to-buffer");
6356 initial_define_key (control_x_map
, 'k', "kill-buffer");
6358 /* This must not be in syms_of_buffer, because Qdisabled is not
6359 initialized when that function gets called. */
6360 Fput (intern_c_string ("erase-buffer"), Qdisabled
, Qt
);