1 /* Buffer manipulation primitives for GNU Emacs.
3 Copyright (C) 1985-1989, 1993-1995, 1997-2013 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 #define BUFFER_INLINE EXTERN_INLINE
25 #include <sys/types.h>
27 #include <sys/param.h>
35 #include "intervals.h"
38 #include "character.h"
40 #include "region-cache.h"
42 #include "blockinput.h"
47 struct buffer
*current_buffer
; /* The current buffer. */
49 /* First buffer in chain of all buffers (in reverse order of creation).
50 Threaded through ->header.next.buffer. */
52 struct buffer
*all_buffers
;
54 /* This structure holds the default values of the buffer-local variables
55 defined with DEFVAR_PER_BUFFER, that have special slots in each buffer.
56 The default value occupies the same slot in this structure
57 as an individual buffer's value occupies in that buffer.
58 Setting the default value also goes through the alist of buffers
59 and stores into each buffer that does not say it has a local value. */
61 struct buffer
alignas (GCALIGNMENT
) buffer_defaults
;
63 /* This structure marks which slots in a buffer have corresponding
64 default values in buffer_defaults.
65 Each such slot has a nonzero value in this structure.
66 The value has only one nonzero bit.
68 When a buffer has its own local value for a slot,
69 the entry for that slot (found in the same slot in this structure)
70 is turned on in the buffer's local_flags array.
72 If a slot in this structure is -1, then even though there may
73 be a DEFVAR_PER_BUFFER for the slot, there is no default value for it;
74 and the corresponding slot in buffer_defaults is not used.
76 If a slot in this structure corresponding to a DEFVAR_PER_BUFFER is
77 zero, that is a bug. */
79 struct buffer buffer_local_flags
;
81 /* This structure holds the names of symbols whose values may be
82 buffer-local. It is indexed and accessed in the same way as the above. */
84 struct buffer
alignas (GCALIGNMENT
) buffer_local_symbols
;
86 /* Return the symbol of the per-buffer variable at offset OFFSET in
87 the buffer structure. */
89 #define PER_BUFFER_SYMBOL(OFFSET) \
90 (*(Lisp_Object *)((OFFSET) + (char *) &buffer_local_symbols))
92 /* Maximum length of an overlay vector. */
93 #define OVERLAY_COUNT_MAX \
94 ((ptrdiff_t) min (MOST_POSITIVE_FIXNUM, \
95 min (PTRDIFF_MAX, SIZE_MAX) / word_size))
97 /* Flags indicating which built-in buffer-local variables
98 are permanent locals. */
99 static char buffer_permanent_local_flags
[MAX_PER_BUFFER_VARS
];
101 /* Number of per-buffer variables used. */
103 int last_per_buffer_idx
;
105 static void call_overlay_mod_hooks (Lisp_Object list
, Lisp_Object overlay
,
106 bool after
, Lisp_Object arg1
,
107 Lisp_Object arg2
, Lisp_Object arg3
);
108 static void swap_out_buffer_local_variables (struct buffer
*b
);
109 static void reset_buffer_local_variables (struct buffer
*, bool);
111 /* Alist of all buffer names vs the buffers. */
112 /* This used to be a variable, but is no longer,
113 to prevent lossage due to user rplac'ing this alist or its elements. */
114 Lisp_Object Vbuffer_alist
;
116 static Lisp_Object Qkill_buffer_query_functions
;
118 /* Hook run before changing a major mode. */
119 static Lisp_Object Qchange_major_mode_hook
;
121 Lisp_Object Qfirst_change_hook
;
122 Lisp_Object Qbefore_change_functions
;
123 Lisp_Object Qafter_change_functions
;
125 static Lisp_Object Qfundamental_mode
, Qmode_class
, Qpermanent_local
;
126 static Lisp_Object Qpermanent_local_hook
;
128 static Lisp_Object Qprotected_field
;
130 static Lisp_Object QSFundamental
; /* A string "Fundamental". */
132 static Lisp_Object Qkill_buffer_hook
;
133 static Lisp_Object Qbuffer_list_update_hook
;
135 static Lisp_Object Qget_file_buffer
;
137 static Lisp_Object Qoverlayp
;
139 Lisp_Object Qpriority
, Qbefore_string
, Qafter_string
;
141 static Lisp_Object Qevaporate
;
143 Lisp_Object Qmodification_hooks
;
144 Lisp_Object Qinsert_in_front_hooks
;
145 Lisp_Object Qinsert_behind_hooks
;
147 static void alloc_buffer_text (struct buffer
*, ptrdiff_t);
148 static void free_buffer_text (struct buffer
*b
);
149 static struct Lisp_Overlay
* copy_overlays (struct buffer
*, struct Lisp_Overlay
*);
150 static void modify_overlay (struct buffer
*, ptrdiff_t, ptrdiff_t);
151 static Lisp_Object
buffer_lisp_local_variables (struct buffer
*, bool);
153 /* These setters are used only in this file, so they can be private. */
155 bset_abbrev_mode (struct buffer
*b
, Lisp_Object val
)
157 b
->INTERNAL_FIELD (abbrev_mode
) = val
;
160 bset_abbrev_table (struct buffer
*b
, Lisp_Object val
)
162 b
->INTERNAL_FIELD (abbrev_table
) = val
;
165 bset_auto_fill_function (struct buffer
*b
, Lisp_Object val
)
167 b
->INTERNAL_FIELD (auto_fill_function
) = val
;
170 bset_auto_save_file_format (struct buffer
*b
, Lisp_Object val
)
172 b
->INTERNAL_FIELD (auto_save_file_format
) = val
;
175 bset_auto_save_file_name (struct buffer
*b
, Lisp_Object val
)
177 b
->INTERNAL_FIELD (auto_save_file_name
) = val
;
180 bset_backed_up (struct buffer
*b
, Lisp_Object val
)
182 b
->INTERNAL_FIELD (backed_up
) = val
;
185 bset_begv_marker (struct buffer
*b
, Lisp_Object val
)
187 b
->INTERNAL_FIELD (begv_marker
) = val
;
190 bset_bidi_display_reordering (struct buffer
*b
, Lisp_Object val
)
192 b
->INTERNAL_FIELD (bidi_display_reordering
) = val
;
195 bset_buffer_file_coding_system (struct buffer
*b
, Lisp_Object val
)
197 b
->INTERNAL_FIELD (buffer_file_coding_system
) = val
;
200 bset_cache_long_line_scans (struct buffer
*b
, Lisp_Object val
)
202 b
->INTERNAL_FIELD (cache_long_line_scans
) = val
;
205 bset_case_fold_search (struct buffer
*b
, Lisp_Object val
)
207 b
->INTERNAL_FIELD (case_fold_search
) = val
;
210 bset_ctl_arrow (struct buffer
*b
, Lisp_Object val
)
212 b
->INTERNAL_FIELD (ctl_arrow
) = val
;
215 bset_cursor_in_non_selected_windows (struct buffer
*b
, Lisp_Object val
)
217 b
->INTERNAL_FIELD (cursor_in_non_selected_windows
) = val
;
220 bset_cursor_type (struct buffer
*b
, Lisp_Object val
)
222 b
->INTERNAL_FIELD (cursor_type
) = val
;
225 bset_display_table (struct buffer
*b
, Lisp_Object val
)
227 b
->INTERNAL_FIELD (display_table
) = val
;
230 bset_extra_line_spacing (struct buffer
*b
, Lisp_Object val
)
232 b
->INTERNAL_FIELD (extra_line_spacing
) = val
;
235 bset_file_format (struct buffer
*b
, Lisp_Object val
)
237 b
->INTERNAL_FIELD (file_format
) = val
;
240 bset_file_truename (struct buffer
*b
, Lisp_Object val
)
242 b
->INTERNAL_FIELD (file_truename
) = val
;
245 bset_fringe_cursor_alist (struct buffer
*b
, Lisp_Object val
)
247 b
->INTERNAL_FIELD (fringe_cursor_alist
) = val
;
250 bset_fringe_indicator_alist (struct buffer
*b
, Lisp_Object val
)
252 b
->INTERNAL_FIELD (fringe_indicator_alist
) = val
;
255 bset_fringes_outside_margins (struct buffer
*b
, Lisp_Object val
)
257 b
->INTERNAL_FIELD (fringes_outside_margins
) = val
;
260 bset_header_line_format (struct buffer
*b
, Lisp_Object val
)
262 b
->INTERNAL_FIELD (header_line_format
) = val
;
265 bset_indicate_buffer_boundaries (struct buffer
*b
, Lisp_Object val
)
267 b
->INTERNAL_FIELD (indicate_buffer_boundaries
) = val
;
270 bset_indicate_empty_lines (struct buffer
*b
, Lisp_Object val
)
272 b
->INTERNAL_FIELD (indicate_empty_lines
) = val
;
275 bset_invisibility_spec (struct buffer
*b
, Lisp_Object val
)
277 b
->INTERNAL_FIELD (invisibility_spec
) = val
;
280 bset_left_fringe_width (struct buffer
*b
, Lisp_Object val
)
282 b
->INTERNAL_FIELD (left_fringe_width
) = val
;
285 bset_major_mode (struct buffer
*b
, Lisp_Object val
)
287 b
->INTERNAL_FIELD (major_mode
) = val
;
290 bset_mark (struct buffer
*b
, Lisp_Object val
)
292 b
->INTERNAL_FIELD (mark
) = val
;
295 bset_minor_modes (struct buffer
*b
, Lisp_Object val
)
297 b
->INTERNAL_FIELD (minor_modes
) = val
;
300 bset_mode_line_format (struct buffer
*b
, Lisp_Object val
)
302 b
->INTERNAL_FIELD (mode_line_format
) = val
;
305 bset_mode_name (struct buffer
*b
, Lisp_Object val
)
307 b
->INTERNAL_FIELD (mode_name
) = val
;
310 bset_name (struct buffer
*b
, Lisp_Object val
)
312 b
->INTERNAL_FIELD (name
) = val
;
315 bset_overwrite_mode (struct buffer
*b
, Lisp_Object val
)
317 b
->INTERNAL_FIELD (overwrite_mode
) = val
;
320 bset_pt_marker (struct buffer
*b
, Lisp_Object val
)
322 b
->INTERNAL_FIELD (pt_marker
) = val
;
325 bset_right_fringe_width (struct buffer
*b
, Lisp_Object val
)
327 b
->INTERNAL_FIELD (right_fringe_width
) = val
;
330 bset_save_length (struct buffer
*b
, Lisp_Object val
)
332 b
->INTERNAL_FIELD (save_length
) = val
;
335 bset_scroll_bar_width (struct buffer
*b
, Lisp_Object val
)
337 b
->INTERNAL_FIELD (scroll_bar_width
) = val
;
340 bset_scroll_down_aggressively (struct buffer
*b
, Lisp_Object val
)
342 b
->INTERNAL_FIELD (scroll_down_aggressively
) = val
;
345 bset_scroll_up_aggressively (struct buffer
*b
, Lisp_Object val
)
347 b
->INTERNAL_FIELD (scroll_up_aggressively
) = val
;
350 bset_selective_display (struct buffer
*b
, Lisp_Object val
)
352 b
->INTERNAL_FIELD (selective_display
) = val
;
355 bset_selective_display_ellipses (struct buffer
*b
, Lisp_Object val
)
357 b
->INTERNAL_FIELD (selective_display_ellipses
) = val
;
360 bset_vertical_scroll_bar_type (struct buffer
*b
, Lisp_Object val
)
362 b
->INTERNAL_FIELD (vertical_scroll_bar_type
) = val
;
365 bset_word_wrap (struct buffer
*b
, Lisp_Object val
)
367 b
->INTERNAL_FIELD (word_wrap
) = val
;
370 bset_zv_marker (struct buffer
*b
, Lisp_Object val
)
372 b
->INTERNAL_FIELD (zv_marker
) = val
;
375 /* For debugging; temporary. See set_buffer_internal. */
376 /* Lisp_Object Qlisp_mode, Vcheck_symbol; */
379 nsberror (Lisp_Object spec
)
382 error ("No buffer named %s", SDATA (spec
));
383 error ("Invalid buffer argument");
386 DEFUN ("buffer-live-p", Fbuffer_live_p
, Sbuffer_live_p
, 1, 1, 0,
387 doc
: /* Return non-nil if OBJECT is a buffer which has not been killed.
388 Value is nil if OBJECT is not a buffer or if it has been killed. */)
391 return ((BUFFERP (object
) && BUFFER_LIVE_P (XBUFFER (object
)))
395 DEFUN ("buffer-list", Fbuffer_list
, Sbuffer_list
, 0, 1, 0,
396 doc
: /* Return a list of all existing live buffers.
397 If the optional arg FRAME is a frame, we return the buffer list in the
398 proper order for that frame: the buffers show in FRAME come first,
399 followed by the rest of the buffers. */)
403 general
= Fmapcar (Qcdr
, Vbuffer_alist
);
407 Lisp_Object framelist
, prevlist
, tail
;
411 framelist
= Fcopy_sequence (XFRAME (frame
)->buffer_list
);
412 prevlist
= Fnreverse (Fcopy_sequence
413 (XFRAME (frame
)->buried_buffer_list
));
415 /* Remove from GENERAL any buffer that duplicates one in
416 FRAMELIST or PREVLIST. */
420 general
= Fdelq (XCAR (tail
), general
);
426 general
= Fdelq (XCAR (tail
), general
);
433 return Fnconc (3, args
);
439 /* Like Fassoc, but use Fstring_equal to compare
440 (which ignores text properties),
441 and don't ever QUIT. */
444 assoc_ignore_text_properties (register Lisp_Object key
, Lisp_Object list
)
446 register Lisp_Object tail
;
447 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
449 register Lisp_Object elt
, tem
;
451 tem
= Fstring_equal (Fcar (elt
), key
);
458 DEFUN ("get-buffer", Fget_buffer
, Sget_buffer
, 1, 1, 0,
459 doc
: /* Return the buffer named BUFFER-OR-NAME.
460 BUFFER-OR-NAME must be either a string or a buffer. If BUFFER-OR-NAME
461 is a string and there is no buffer with that name, return nil. If
462 BUFFER-OR-NAME is a buffer, return it as given. */)
463 (register Lisp_Object buffer_or_name
)
465 if (BUFFERP (buffer_or_name
))
466 return buffer_or_name
;
467 CHECK_STRING (buffer_or_name
);
469 return Fcdr (assoc_ignore_text_properties (buffer_or_name
, Vbuffer_alist
));
472 DEFUN ("get-file-buffer", Fget_file_buffer
, Sget_file_buffer
, 1, 1, 0,
473 doc
: /* Return the buffer visiting file FILENAME (a string).
474 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
475 If there is no such live buffer, return nil.
476 See also `find-buffer-visiting'. */)
477 (register Lisp_Object filename
)
479 register Lisp_Object tail
, buf
, tem
;
482 CHECK_STRING (filename
);
483 filename
= Fexpand_file_name (filename
, Qnil
);
485 /* If the file name has special constructs in it,
486 call the corresponding file handler. */
487 handler
= Ffind_file_name_handler (filename
, Qget_file_buffer
);
490 Lisp_Object handled_buf
= call2 (handler
, Qget_file_buffer
,
492 return BUFFERP (handled_buf
) ? handled_buf
: Qnil
;
495 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
497 buf
= Fcdr (XCAR (tail
));
498 if (!BUFFERP (buf
)) continue;
499 if (!STRINGP (BVAR (XBUFFER (buf
), filename
))) continue;
500 tem
= Fstring_equal (BVAR (XBUFFER (buf
), filename
), filename
);
508 get_truename_buffer (register Lisp_Object filename
)
510 register Lisp_Object tail
, buf
, tem
;
512 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
514 buf
= Fcdr (XCAR (tail
));
515 if (!BUFFERP (buf
)) continue;
516 if (!STRINGP (BVAR (XBUFFER (buf
), file_truename
))) continue;
517 tem
= Fstring_equal (BVAR (XBUFFER (buf
), file_truename
), filename
);
524 DEFUN ("get-buffer-create", Fget_buffer_create
, Sget_buffer_create
, 1, 1, 0,
525 doc
: /* Return the buffer specified by BUFFER-OR-NAME, creating a new one if needed.
526 If BUFFER-OR-NAME is a string and a live buffer with that name exists,
527 return that buffer. If no such buffer exists, create a new buffer with
528 that name and return it. If BUFFER-OR-NAME starts with a space, the new
529 buffer does not keep undo information.
531 If BUFFER-OR-NAME is a buffer instead of a string, return it as given,
532 even if it is dead. The return value is never nil. */)
533 (register Lisp_Object buffer_or_name
)
535 register Lisp_Object buffer
, name
;
536 register struct buffer
*b
;
538 buffer
= Fget_buffer (buffer_or_name
);
542 if (SCHARS (buffer_or_name
) == 0)
543 error ("Empty string for buffer name is not allowed");
545 b
= allocate_buffer ();
547 /* An ordinary buffer uses its own struct buffer_text. */
548 b
->text
= &b
->own_text
;
549 b
->base_buffer
= NULL
;
550 /* No one shares the text with us now. */
553 BUF_GAP_SIZE (b
) = 20;
555 /* We allocate extra 1-byte at the tail and keep it always '\0' for
556 anchoring a search. */
557 alloc_buffer_text (b
, BUF_GAP_SIZE (b
) + 1);
559 if (! BUF_BEG_ADDR (b
))
560 buffer_memory_full (BUF_GAP_SIZE (b
) + 1);
565 b
->pt_byte
= BEG_BYTE
;
566 b
->begv_byte
= BEG_BYTE
;
567 b
->zv_byte
= BEG_BYTE
;
570 BUF_GPT_BYTE (b
) = BEG_BYTE
;
573 BUF_Z_BYTE (b
) = BEG_BYTE
;
575 BUF_CHARS_MODIFF (b
) = 1;
576 BUF_OVERLAY_MODIFF (b
) = 1;
577 BUF_SAVE_MODIFF (b
) = 1;
578 set_buffer_intervals (b
, NULL
);
579 BUF_UNCHANGED_MODIFIED (b
) = 1;
580 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = 1;
581 BUF_END_UNCHANGED (b
) = 0;
582 BUF_BEG_UNCHANGED (b
) = 0;
583 *(BUF_GPT_ADDR (b
)) = *(BUF_Z_ADDR (b
)) = 0; /* Put an anchor '\0'. */
584 b
->text
->inhibit_shrinking
= 0;
586 b
->newline_cache
= 0;
587 b
->width_run_cache
= 0;
588 bset_width_table (b
, Qnil
);
589 b
->prevent_redisplay_optimizations_p
= 1;
591 /* An ordinary buffer normally doesn't need markers
592 to handle BEGV and ZV. */
593 bset_pt_marker (b
, Qnil
);
594 bset_begv_marker (b
, Qnil
);
595 bset_zv_marker (b
, Qnil
);
597 name
= Fcopy_sequence (buffer_or_name
);
598 set_string_intervals (name
, NULL
);
601 bset_undo_list (b
, SREF (name
, 0) != ' ' ? Qnil
: Qt
);
604 reset_buffer_local_variables (b
, 1);
606 bset_mark (b
, Fmake_marker ());
607 BUF_MARKERS (b
) = NULL
;
609 /* Put this in the alist of all live buffers. */
610 XSETBUFFER (buffer
, b
);
611 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buffer
), Qnil
));
612 /* And run buffer-list-update-hook. */
613 if (!NILP (Vrun_hooks
))
614 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
620 /* Return a list of overlays which is a copy of the overlay list
621 LIST, but for buffer B. */
623 static struct Lisp_Overlay
*
624 copy_overlays (struct buffer
*b
, struct Lisp_Overlay
*list
)
626 struct Lisp_Overlay
*result
= NULL
, *tail
= NULL
;
628 for (; list
; list
= list
->next
)
630 Lisp_Object overlay
, start
, end
;
631 struct Lisp_Marker
*m
;
633 eassert (MARKERP (list
->start
));
634 m
= XMARKER (list
->start
);
635 start
= build_marker (b
, m
->charpos
, m
->bytepos
);
636 XMARKER (start
)->insertion_type
= m
->insertion_type
;
638 eassert (MARKERP (list
->end
));
639 m
= XMARKER (list
->end
);
640 end
= build_marker (b
, m
->charpos
, m
->bytepos
);
641 XMARKER (end
)->insertion_type
= m
->insertion_type
;
643 overlay
= build_overlay (start
, end
, Fcopy_sequence (list
->plist
));
645 tail
= tail
->next
= XOVERLAY (overlay
);
647 result
= tail
= XOVERLAY (overlay
);
653 /* Set an appropriate overlay of B. */
656 set_buffer_overlays_before (struct buffer
*b
, struct Lisp_Overlay
*o
)
658 b
->overlays_before
= o
;
662 set_buffer_overlays_after (struct buffer
*b
, struct Lisp_Overlay
*o
)
664 b
->overlays_after
= o
;
667 /* Clone per-buffer values of buffer FROM.
669 Buffer TO gets the same per-buffer values as FROM, with the
670 following exceptions: (1) TO's name is left untouched, (2) markers
671 are copied and made to refer to TO, and (3) overlay lists are
675 clone_per_buffer_values (struct buffer
*from
, struct buffer
*to
)
679 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
683 /* Don't touch the `name' which should be unique for every buffer. */
684 if (offset
== PER_BUFFER_VAR_OFFSET (name
))
687 obj
= per_buffer_value (from
, offset
);
688 if (MARKERP (obj
) && XMARKER (obj
)->buffer
== from
)
690 struct Lisp_Marker
*m
= XMARKER (obj
);
692 obj
= build_marker (to
, m
->charpos
, m
->bytepos
);
693 XMARKER (obj
)->insertion_type
= m
->insertion_type
;
696 set_per_buffer_value (to
, offset
, obj
);
699 memcpy (to
->local_flags
, from
->local_flags
, sizeof to
->local_flags
);
701 set_buffer_overlays_before (to
, copy_overlays (to
, from
->overlays_before
));
702 set_buffer_overlays_after (to
, copy_overlays (to
, from
->overlays_after
));
704 /* Get (a copy of) the alist of Lisp-level local variables of FROM
705 and install that in TO. */
706 bset_local_var_alist (to
, buffer_lisp_local_variables (from
, 1));
710 /* If buffer B has markers to record PT, BEGV and ZV when it is not
711 current, update these markers. */
714 record_buffer_markers (struct buffer
*b
)
716 if (! NILP (BVAR (b
, pt_marker
)))
720 eassert (!NILP (BVAR (b
, begv_marker
)));
721 eassert (!NILP (BVAR (b
, zv_marker
)));
723 XSETBUFFER (buffer
, b
);
724 set_marker_both (BVAR (b
, pt_marker
), buffer
, b
->pt
, b
->pt_byte
);
725 set_marker_both (BVAR (b
, begv_marker
), buffer
, b
->begv
, b
->begv_byte
);
726 set_marker_both (BVAR (b
, zv_marker
), buffer
, b
->zv
, b
->zv_byte
);
731 /* If buffer B has markers to record PT, BEGV and ZV when it is not
732 current, fetch these values into B->begv etc. */
735 fetch_buffer_markers (struct buffer
*b
)
737 if (! NILP (BVAR (b
, pt_marker
)))
741 eassert (!NILP (BVAR (b
, begv_marker
)));
742 eassert (!NILP (BVAR (b
, zv_marker
)));
744 m
= BVAR (b
, pt_marker
);
745 SET_BUF_PT_BOTH (b
, marker_position (m
), marker_byte_position (m
));
747 m
= BVAR (b
, begv_marker
);
748 SET_BUF_BEGV_BOTH (b
, marker_position (m
), marker_byte_position (m
));
750 m
= BVAR (b
, zv_marker
);
751 SET_BUF_ZV_BOTH (b
, marker_position (m
), marker_byte_position (m
));
756 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer
, Smake_indirect_buffer
,
758 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ",
759 doc
: /* Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.
760 BASE-BUFFER should be a live buffer, or the name of an existing buffer.
761 NAME should be a string which is not the name of an existing buffer.
762 Optional argument CLONE non-nil means preserve BASE-BUFFER's state,
763 such as major and minor modes, in the indirect buffer.
764 CLONE nil means the indirect buffer's state is reset to default values. */)
765 (Lisp_Object base_buffer
, Lisp_Object name
, Lisp_Object clone
)
767 Lisp_Object buf
, tem
;
771 buf
= Fget_buffer (name
);
773 error ("Buffer name `%s' is in use", SDATA (name
));
776 base_buffer
= Fget_buffer (base_buffer
);
777 if (NILP (base_buffer
))
778 error ("No such buffer: `%s'", SDATA (tem
));
779 if (!BUFFER_LIVE_P (XBUFFER (base_buffer
)))
780 error ("Base buffer has been killed");
782 if (SCHARS (name
) == 0)
783 error ("Empty string for buffer name is not allowed");
785 b
= allocate_buffer ();
787 /* No double indirection - if base buffer is indirect,
788 new buffer becomes an indirect to base's base. */
789 b
->base_buffer
= (XBUFFER (base_buffer
)->base_buffer
790 ? XBUFFER (base_buffer
)->base_buffer
791 : XBUFFER (base_buffer
));
793 /* Use the base buffer's text object. */
794 b
->text
= b
->base_buffer
->text
;
795 /* We have no own text. */
796 b
->indirections
= -1;
797 /* Notify base buffer that we share the text now. */
798 b
->base_buffer
->indirections
++;
800 b
->pt
= b
->base_buffer
->pt
;
801 b
->begv
= b
->base_buffer
->begv
;
802 b
->zv
= b
->base_buffer
->zv
;
803 b
->pt_byte
= b
->base_buffer
->pt_byte
;
804 b
->begv_byte
= b
->base_buffer
->begv_byte
;
805 b
->zv_byte
= b
->base_buffer
->zv_byte
;
807 b
->newline_cache
= 0;
808 b
->width_run_cache
= 0;
809 bset_width_table (b
, Qnil
);
811 name
= Fcopy_sequence (name
);
812 set_string_intervals (name
, NULL
);
816 reset_buffer_local_variables (b
, 1);
818 /* Put this in the alist of all live buffers. */
820 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buf
), Qnil
));
822 bset_mark (b
, Fmake_marker ());
824 /* The multibyte status belongs to the base buffer. */
825 bset_enable_multibyte_characters
826 (b
, BVAR (b
->base_buffer
, enable_multibyte_characters
));
828 /* Make sure the base buffer has markers for its narrowing. */
829 if (NILP (BVAR (b
->base_buffer
, pt_marker
)))
831 eassert (NILP (BVAR (b
->base_buffer
, begv_marker
)));
832 eassert (NILP (BVAR (b
->base_buffer
, zv_marker
)));
834 bset_pt_marker (b
->base_buffer
,
835 build_marker (b
->base_buffer
, b
->base_buffer
->pt
,
836 b
->base_buffer
->pt_byte
));
838 bset_begv_marker (b
->base_buffer
,
839 build_marker (b
->base_buffer
, b
->base_buffer
->begv
,
840 b
->base_buffer
->begv_byte
));
842 bset_zv_marker (b
->base_buffer
,
843 build_marker (b
->base_buffer
, b
->base_buffer
->zv
,
844 b
->base_buffer
->zv_byte
));
846 XMARKER (BVAR (b
->base_buffer
, zv_marker
))->insertion_type
= 1;
851 /* Give the indirect buffer markers for its narrowing. */
852 bset_pt_marker (b
, build_marker (b
, b
->pt
, b
->pt_byte
));
853 bset_begv_marker (b
, build_marker (b
, b
->begv
, b
->begv_byte
));
854 bset_zv_marker (b
, build_marker (b
, b
->zv
, b
->zv_byte
));
855 XMARKER (BVAR (b
, zv_marker
))->insertion_type
= 1;
859 struct buffer
*old_b
= current_buffer
;
861 clone_per_buffer_values (b
->base_buffer
, b
);
862 bset_filename (b
, Qnil
);
863 bset_file_truename (b
, Qnil
);
864 bset_display_count (b
, make_number (0));
865 bset_backed_up (b
, Qnil
);
866 bset_auto_save_file_name (b
, Qnil
);
867 set_buffer_internal_1 (b
);
868 Fset (intern ("buffer-save-without-query"), Qnil
);
869 Fset (intern ("buffer-file-number"), Qnil
);
870 Fset (intern ("buffer-stale-function"), Qnil
);
871 set_buffer_internal_1 (old_b
);
874 /* Run buffer-list-update-hook. */
875 if (!NILP (Vrun_hooks
))
876 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
881 /* Mark OV as no longer associated with B. */
884 drop_overlay (struct buffer
*b
, struct Lisp_Overlay
*ov
)
886 eassert (b
== XBUFFER (Fmarker_buffer (ov
->start
)));
887 modify_overlay (b
, marker_position (ov
->start
),
888 marker_position (ov
->end
));
889 Fset_marker (ov
->start
, Qnil
, Qnil
);
890 Fset_marker (ov
->end
, Qnil
, Qnil
);
894 /* Delete all overlays of B and reset it's overlay lists. */
897 delete_all_overlays (struct buffer
*b
)
899 struct Lisp_Overlay
*ov
, *next
;
901 /* FIXME: Since each drop_overlay will scan BUF_MARKERS to unlink its
902 markers, we have an unneeded O(N^2) behavior here. */
903 for (ov
= b
->overlays_before
; ov
; ov
= next
)
905 drop_overlay (b
, ov
);
910 for (ov
= b
->overlays_after
; ov
; ov
= next
)
912 drop_overlay (b
, ov
);
917 set_buffer_overlays_before (b
, NULL
);
918 set_buffer_overlays_after (b
, NULL
);
921 /* Reinitialize everything about a buffer except its name and contents
923 If called on an already-initialized buffer, the list of overlays
924 should be deleted before calling this function, otherwise we end up
925 with overlays that claim to belong to the buffer but the buffer
926 claims it doesn't belong to it. */
929 reset_buffer (register struct buffer
*b
)
931 bset_filename (b
, Qnil
);
932 bset_file_truename (b
, Qnil
);
933 bset_directory (b
, current_buffer
? BVAR (current_buffer
, directory
) : Qnil
);
934 b
->modtime
= make_emacs_time (0, UNKNOWN_MODTIME_NSECS
);
935 b
->modtime_size
= -1;
936 XSETFASTINT (BVAR (b
, save_length
), 0);
937 b
->last_window_start
= 1;
938 /* It is more conservative to start out "changed" than "unchanged". */
940 b
->prevent_redisplay_optimizations_p
= 1;
941 bset_backed_up (b
, Qnil
);
942 BUF_AUTOSAVE_MODIFF (b
) = 0;
943 b
->auto_save_failure_time
= 0;
944 bset_auto_save_file_name (b
, Qnil
);
945 bset_read_only (b
, Qnil
);
946 set_buffer_overlays_before (b
, NULL
);
947 set_buffer_overlays_after (b
, NULL
);
948 b
->overlay_center
= BEG
;
949 bset_mark_active (b
, Qnil
);
950 bset_point_before_scroll (b
, Qnil
);
951 bset_file_format (b
, Qnil
);
952 bset_auto_save_file_format (b
, Qt
);
953 bset_last_selected_window (b
, Qnil
);
954 bset_display_count (b
, make_number (0));
955 bset_display_time (b
, Qnil
);
956 bset_enable_multibyte_characters
957 (b
, BVAR (&buffer_defaults
, enable_multibyte_characters
));
958 bset_cursor_type (b
, BVAR (&buffer_defaults
, cursor_type
));
959 bset_extra_line_spacing (b
, BVAR (&buffer_defaults
, extra_line_spacing
));
961 b
->display_error_modiff
= 0;
964 /* Reset buffer B's local variables info.
965 Don't use this on a buffer that has already been in use;
966 it does not treat permanent locals consistently.
967 Instead, use Fkill_all_local_variables.
969 If PERMANENT_TOO, reset permanent buffer-local variables.
970 If not, preserve those. */
973 reset_buffer_local_variables (struct buffer
*b
, bool permanent_too
)
977 /* Reset the major mode to Fundamental, together with all the
978 things that depend on the major mode.
979 default-major-mode is handled at a higher level.
980 We ignore it here. */
981 bset_major_mode (b
, Qfundamental_mode
);
982 bset_keymap (b
, Qnil
);
983 bset_mode_name (b
, QSFundamental
);
984 bset_minor_modes (b
, Qnil
);
986 /* If the standard case table has been altered and invalidated,
987 fix up its insides first. */
988 if (! (CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[0])
989 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[1])
990 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[2])))
991 Fset_standard_case_table (Vascii_downcase_table
);
993 bset_downcase_table (b
, Vascii_downcase_table
);
994 bset_upcase_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[0]);
995 bset_case_canon_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[1]);
996 bset_case_eqv_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[2]);
997 bset_invisibility_spec (b
, Qt
);
999 /* Reset all (or most) per-buffer variables to their defaults. */
1001 bset_local_var_alist (b
, Qnil
);
1004 Lisp_Object tmp
, prop
, last
= Qnil
;
1005 for (tmp
= BVAR (b
, local_var_alist
); CONSP (tmp
); tmp
= XCDR (tmp
))
1006 if (!NILP (prop
= Fget (XCAR (XCAR (tmp
)), Qpermanent_local
)))
1008 /* If permanent-local, keep it. */
1010 if (EQ (prop
, Qpermanent_local_hook
))
1012 /* This is a partially permanent hook variable.
1013 Preserve only the elements that want to be preserved. */
1014 Lisp_Object list
, newlist
;
1015 list
= XCDR (XCAR (tmp
));
1019 for (newlist
= Qnil
; CONSP (list
); list
= XCDR (list
))
1021 Lisp_Object elt
= XCAR (list
);
1022 /* Preserve element ELT if it's t,
1023 if it is a function with a `permanent-local-hook' property,
1024 or if it's not a symbol. */
1027 || !NILP (Fget (elt
, Qpermanent_local_hook
)))
1028 newlist
= Fcons (elt
, newlist
);
1030 XSETCDR (XCAR (tmp
), Fnreverse (newlist
));
1033 /* Delete this local variable. */
1034 else if (NILP (last
))
1035 bset_local_var_alist (b
, XCDR (tmp
));
1037 XSETCDR (last
, XCDR (tmp
));
1040 for (i
= 0; i
< last_per_buffer_idx
; ++i
)
1041 if (permanent_too
|| buffer_permanent_local_flags
[i
] == 0)
1042 SET_PER_BUFFER_VALUE_P (b
, i
, 0);
1044 /* For each slot that has a default value, copy that into the slot. */
1045 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
1047 int idx
= PER_BUFFER_IDX (offset
);
1050 || buffer_permanent_local_flags
[idx
] == 0)))
1051 set_per_buffer_value (b
, offset
, per_buffer_default (offset
));
1055 /* We split this away from generate-new-buffer, because rename-buffer
1056 and set-visited-file-name ought to be able to use this to really
1057 rename the buffer properly. */
1059 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name
,
1060 Sgenerate_new_buffer_name
, 1, 2, 0,
1061 doc
: /* Return a string that is the name of no existing buffer based on NAME.
1062 If there is no live buffer named NAME, then return NAME.
1063 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
1064 \(starting at 2) until an unused name is found, and then return that name.
1065 Optional second argument IGNORE specifies a name that is okay to use (if
1066 it is in the sequence to be tried) even if a buffer with that name exists.
1068 If NAME begins with a space (i.e., a buffer that is not normally
1069 visible to users), then if buffer NAME already exists a random number
1070 is first appended to NAME, to speed up finding a non-existent buffer. */)
1071 (register Lisp_Object name
, Lisp_Object ignore
)
1073 register Lisp_Object gentemp
, tem
, tem2
;
1075 char number
[INT_BUFSIZE_BOUND (ptrdiff_t) + sizeof "<>"];
1077 CHECK_STRING (name
);
1079 tem
= Fstring_equal (name
, ignore
);
1082 tem
= Fget_buffer (name
);
1086 if (!strncmp (SSDATA (name
), " ", 1)) /* see bug#1229 */
1088 /* Note fileio.c:make_temp_name does random differently. */
1089 tem2
= concat2 (name
, make_formatted_string
1091 XFASTINT (Frandom (make_number (999999)))));
1092 tem
= Fget_buffer (tem2
);
1102 gentemp
= concat2 (tem2
, make_formatted_string
1103 (number
, "<%"pD
"d>", ++count
));
1104 tem
= Fstring_equal (gentemp
, ignore
);
1107 tem
= Fget_buffer (gentemp
);
1114 DEFUN ("buffer-name", Fbuffer_name
, Sbuffer_name
, 0, 1, 0,
1115 doc
: /* Return the name of BUFFER, as a string.
1116 BUFFER defaults to the current buffer.
1117 Return nil if BUFFER has been killed. */)
1118 (register Lisp_Object buffer
)
1121 return BVAR (current_buffer
, name
);
1122 CHECK_BUFFER (buffer
);
1123 return BVAR (XBUFFER (buffer
), name
);
1126 DEFUN ("buffer-file-name", Fbuffer_file_name
, Sbuffer_file_name
, 0, 1, 0,
1127 doc
: /* Return name of file BUFFER is visiting, or nil if none.
1128 No argument or nil as argument means use the current buffer. */)
1129 (register Lisp_Object buffer
)
1132 return BVAR (current_buffer
, filename
);
1133 CHECK_BUFFER (buffer
);
1134 return BVAR (XBUFFER (buffer
), filename
);
1137 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer
, Sbuffer_base_buffer
,
1139 doc
: /* Return the base buffer of indirect buffer BUFFER.
1140 If BUFFER is not indirect, return nil.
1141 BUFFER defaults to the current buffer. */)
1142 (register Lisp_Object buffer
)
1144 struct buffer
*base
;
1145 Lisp_Object base_buffer
;
1148 base
= current_buffer
->base_buffer
;
1151 CHECK_BUFFER (buffer
);
1152 base
= XBUFFER (buffer
)->base_buffer
;
1157 XSETBUFFER (base_buffer
, base
);
1161 DEFUN ("buffer-local-value", Fbuffer_local_value
,
1162 Sbuffer_local_value
, 2, 2, 0,
1163 doc
: /* Return the value of VARIABLE in BUFFER.
1164 If VARIABLE does not have a buffer-local binding in BUFFER, the value
1165 is the default binding of the variable. */)
1166 (register Lisp_Object variable
, register Lisp_Object buffer
)
1168 register Lisp_Object result
= buffer_local_value_1 (variable
, buffer
);
1170 if (EQ (result
, Qunbound
))
1171 xsignal1 (Qvoid_variable
, variable
);
1177 /* Like Fbuffer_local_value, but return Qunbound if the variable is
1181 buffer_local_value_1 (Lisp_Object variable
, Lisp_Object buffer
)
1183 register struct buffer
*buf
;
1184 register Lisp_Object result
;
1185 struct Lisp_Symbol
*sym
;
1187 CHECK_SYMBOL (variable
);
1188 CHECK_BUFFER (buffer
);
1189 buf
= XBUFFER (buffer
);
1190 sym
= XSYMBOL (variable
);
1193 switch (sym
->redirect
)
1195 case SYMBOL_VARALIAS
: sym
= indirect_variable (sym
); goto start
;
1196 case SYMBOL_PLAINVAL
: result
= SYMBOL_VAL (sym
); break;
1197 case SYMBOL_LOCALIZED
:
1198 { /* Look in local_var_alist. */
1199 struct Lisp_Buffer_Local_Value
*blv
= SYMBOL_BLV (sym
);
1200 XSETSYMBOL (variable
, sym
); /* Update In case of aliasing. */
1201 result
= Fassoc (variable
, BVAR (buf
, local_var_alist
));
1205 { /* What binding is loaded right now? */
1206 Lisp_Object current_alist_element
= blv
->valcell
;
1208 /* The value of the currently loaded binding is not
1209 stored in it, but rather in the realvalue slot.
1210 Store that value into the binding it belongs to
1211 in case that is the one we are about to use. */
1213 XSETCDR (current_alist_element
,
1214 do_symval_forwarding (blv
->fwd
));
1216 /* Now get the (perhaps updated) value out of the binding. */
1217 result
= XCDR (result
);
1220 result
= Fdefault_value (variable
);
1223 case SYMBOL_FORWARDED
:
1225 union Lisp_Fwd
*fwd
= SYMBOL_FWD (sym
);
1226 if (BUFFER_OBJFWDP (fwd
))
1227 result
= per_buffer_value (buf
, XBUFFER_OBJFWD (fwd
)->offset
);
1229 result
= Fdefault_value (variable
);
1232 default: emacs_abort ();
1238 /* Return an alist of the Lisp-level buffer-local bindings of
1239 buffer BUF. That is, don't include the variables maintained
1240 in special slots in the buffer object.
1241 If not CLONE, replace elements of the form (VAR . unbound)
1245 buffer_lisp_local_variables (struct buffer
*buf
, bool clone
)
1247 Lisp_Object result
= Qnil
;
1249 for (tail
= BVAR (buf
, local_var_alist
); CONSP (tail
); tail
= XCDR (tail
))
1251 Lisp_Object val
, elt
;
1255 /* Reference each variable in the alist in buf.
1256 If inquiring about the current buffer, this gets the current values,
1257 so store them into the alist so the alist is up to date.
1258 If inquiring about some other buffer, this swaps out any values
1259 for that buffer, making the alist up to date automatically. */
1260 val
= find_symbol_value (XCAR (elt
));
1261 /* Use the current buffer value only if buf is the current buffer. */
1262 if (buf
!= current_buffer
)
1265 result
= Fcons (!clone
&& EQ (val
, Qunbound
)
1267 : Fcons (XCAR (elt
), val
),
1274 DEFUN ("buffer-local-variables", Fbuffer_local_variables
,
1275 Sbuffer_local_variables
, 0, 1, 0,
1276 doc
: /* Return an alist of variables that are buffer-local in BUFFER.
1277 Most elements look like (SYMBOL . VALUE), describing one variable.
1278 For a symbol that is locally unbound, just the symbol appears in the value.
1279 Note that storing new VALUEs in these elements doesn't change the variables.
1280 No argument or nil as argument means use current buffer as BUFFER. */)
1281 (register Lisp_Object buffer
)
1283 register struct buffer
*buf
;
1284 register Lisp_Object result
;
1287 buf
= current_buffer
;
1290 CHECK_BUFFER (buffer
);
1291 buf
= XBUFFER (buffer
);
1294 result
= buffer_lisp_local_variables (buf
, 0);
1296 /* Add on all the variables stored in special slots. */
1300 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
1302 idx
= PER_BUFFER_IDX (offset
);
1303 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
1304 && SYMBOLP (PER_BUFFER_SYMBOL (offset
)))
1306 Lisp_Object sym
= PER_BUFFER_SYMBOL (offset
);
1307 Lisp_Object val
= per_buffer_value (buf
, offset
);
1308 result
= Fcons (EQ (val
, Qunbound
) ? sym
: Fcons (sym
, val
),
1317 DEFUN ("buffer-modified-p", Fbuffer_modified_p
, Sbuffer_modified_p
,
1319 doc
: /* Return t if BUFFER was modified since its file was last read or saved.
1320 No argument or nil as argument means use current buffer as BUFFER. */)
1321 (register Lisp_Object buffer
)
1323 register struct buffer
*buf
;
1325 buf
= current_buffer
;
1328 CHECK_BUFFER (buffer
);
1329 buf
= XBUFFER (buffer
);
1332 return BUF_SAVE_MODIFF (buf
) < BUF_MODIFF (buf
) ? Qt
: Qnil
;
1335 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p
, Sset_buffer_modified_p
,
1337 doc
: /* Mark current buffer as modified or unmodified according to FLAG.
1338 A non-nil FLAG means mark the buffer modified. */)
1341 Lisp_Object fn
, buffer
, window
;
1343 #ifdef CLASH_DETECTION
1344 /* If buffer becoming modified, lock the file.
1345 If buffer becoming unmodified, unlock the file. */
1347 struct buffer
*b
= current_buffer
->base_buffer
1348 ? current_buffer
->base_buffer
1351 fn
= BVAR (b
, file_truename
);
1352 /* Test buffer-file-name so that binding it to nil is effective. */
1353 if (!NILP (fn
) && ! NILP (BVAR (b
, filename
)))
1355 bool already
= SAVE_MODIFF
< MODIFF
;
1356 if (!already
&& !NILP (flag
))
1358 else if (already
&& NILP (flag
))
1361 #endif /* CLASH_DETECTION */
1363 /* Here we have a problem. SAVE_MODIFF is used here to encode
1364 buffer-modified-p (as SAVE_MODIFF<MODIFF) as well as
1365 recent-auto-save-p (as SAVE_MODIFF<auto_save_modified). So if we
1366 modify SAVE_MODIFF to affect one, we may affect the other
1368 E.g. if FLAG is nil we need to set SAVE_MODIFF to MODIFF, but
1369 if SAVE_MODIFF<auto_save_modified that means we risk changing
1370 recent-auto-save-p from t to nil.
1371 Vice versa, if FLAG is non-nil and SAVE_MODIFF>=auto_save_modified
1372 we risk changing recent-auto-save-p from nil to t. */
1373 SAVE_MODIFF
= (NILP (flag
)
1374 /* FIXME: This unavoidably sets recent-auto-save-p to nil. */
1376 /* Let's try to preserve recent-auto-save-p. */
1377 : SAVE_MODIFF
< MODIFF
? SAVE_MODIFF
1378 /* If SAVE_MODIFF == auto_save_modified == MODIFF,
1379 we can either decrease SAVE_MODIFF and auto_save_modified
1380 or increase MODIFF. */
1383 /* Set update_mode_lines only if buffer is displayed in some window.
1384 Packages like jit-lock or lazy-lock preserve a buffer's modified
1385 state by recording/restoring the state around blocks of code.
1386 Setting update_mode_lines makes redisplay consider all windows
1387 (on all frames). Stealth fontification of buffers not displayed
1388 would incur additional redisplay costs if we'd set
1389 update_modes_lines unconditionally.
1391 Ideally, I think there should be another mechanism for fontifying
1392 buffers without "modifying" buffers, or redisplay should be
1393 smarter about updating the `*' in mode lines. --gerd */
1394 XSETBUFFER (buffer
, current_buffer
);
1395 window
= Fget_buffer_window (buffer
, Qt
);
1396 if (WINDOWP (window
))
1398 ++update_mode_lines
;
1399 current_buffer
->prevent_redisplay_optimizations_p
= 1;
1405 DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p
,
1406 Srestore_buffer_modified_p
, 1, 1, 0,
1407 doc
: /* Like `set-buffer-modified-p', with a difference concerning redisplay.
1408 It is not ensured that mode lines will be updated to show the modified
1409 state of the current buffer. Use with care. */)
1412 #ifdef CLASH_DETECTION
1415 /* If buffer becoming modified, lock the file.
1416 If buffer becoming unmodified, unlock the file. */
1418 fn
= BVAR (current_buffer
, file_truename
);
1419 /* Test buffer-file-name so that binding it to nil is effective. */
1420 if (!NILP (fn
) && ! NILP (BVAR (current_buffer
, filename
)))
1422 bool already
= SAVE_MODIFF
< MODIFF
;
1423 if (!already
&& !NILP (flag
))
1425 else if (already
&& NILP (flag
))
1428 #endif /* CLASH_DETECTION */
1430 SAVE_MODIFF
= NILP (flag
) ? MODIFF
: 0;
1434 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick
, Sbuffer_modified_tick
,
1436 doc
: /* Return BUFFER's tick counter, incremented for each change in text.
1437 Each buffer has a tick counter which is incremented each time the
1438 text in that buffer is changed. It wraps around occasionally.
1439 No argument or nil as argument means use current buffer as BUFFER. */)
1440 (register Lisp_Object buffer
)
1442 register struct buffer
*buf
;
1444 buf
= current_buffer
;
1447 CHECK_BUFFER (buffer
);
1448 buf
= XBUFFER (buffer
);
1451 return make_number (BUF_MODIFF (buf
));
1454 DEFUN ("buffer-chars-modified-tick", Fbuffer_chars_modified_tick
,
1455 Sbuffer_chars_modified_tick
, 0, 1, 0,
1456 doc
: /* Return BUFFER's character-change tick counter.
1457 Each buffer has a character-change tick counter, which is set to the
1458 value of the buffer's tick counter \(see `buffer-modified-tick'), each
1459 time text in that buffer is inserted or deleted. By comparing the
1460 values returned by two individual calls of `buffer-chars-modified-tick',
1461 you can tell whether a character change occurred in that buffer in
1462 between these calls. No argument or nil as argument means use current
1463 buffer as BUFFER. */)
1464 (register Lisp_Object buffer
)
1466 register struct buffer
*buf
;
1468 buf
= current_buffer
;
1471 CHECK_BUFFER (buffer
);
1472 buf
= XBUFFER (buffer
);
1475 return make_number (BUF_CHARS_MODIFF (buf
));
1478 DEFUN ("rename-buffer", Frename_buffer
, Srename_buffer
, 1, 2,
1479 "(list (read-string \"Rename buffer (to new name): \" \
1480 nil 'buffer-name-history (buffer-name (current-buffer))) \
1481 current-prefix-arg)",
1482 doc
: /* Change current buffer's name to NEWNAME (a string).
1483 If second arg UNIQUE is nil or omitted, it is an error if a
1484 buffer named NEWNAME already exists.
1485 If UNIQUE is non-nil, come up with a new name using
1486 `generate-new-buffer-name'.
1487 Interactively, you can set UNIQUE with a prefix argument.
1488 We return the name we actually gave the buffer.
1489 This does not change the name of the visited file (if any). */)
1490 (register Lisp_Object newname
, Lisp_Object unique
)
1492 register Lisp_Object tem
, buf
;
1494 CHECK_STRING (newname
);
1496 if (SCHARS (newname
) == 0)
1497 error ("Empty string is invalid as a buffer name");
1499 tem
= Fget_buffer (newname
);
1502 /* Don't short-circuit if UNIQUE is t. That is a useful way to
1503 rename the buffer automatically so you can create another
1504 with the original name. It makes UNIQUE equivalent to
1505 (rename-buffer (generate-new-buffer-name NEWNAME)). */
1506 if (NILP (unique
) && XBUFFER (tem
) == current_buffer
)
1507 return BVAR (current_buffer
, name
);
1509 newname
= Fgenerate_new_buffer_name (newname
, BVAR (current_buffer
, name
));
1511 error ("Buffer name `%s' is in use", SDATA (newname
));
1514 bset_name (current_buffer
, newname
);
1516 /* Catch redisplay's attention. Unless we do this, the mode lines for
1517 any windows displaying current_buffer will stay unchanged. */
1518 update_mode_lines
++;
1520 XSETBUFFER (buf
, current_buffer
);
1521 Fsetcar (Frassq (buf
, Vbuffer_alist
), newname
);
1522 if (NILP (BVAR (current_buffer
, filename
))
1523 && !NILP (BVAR (current_buffer
, auto_save_file_name
)))
1524 call0 (intern ("rename-auto-save-file"));
1526 /* Run buffer-list-update-hook. */
1527 if (!NILP (Vrun_hooks
))
1528 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1530 /* Refetch since that last call may have done GC. */
1531 return BVAR (current_buffer
, name
);
1534 DEFUN ("other-buffer", Fother_buffer
, Sother_buffer
, 0, 3, 0,
1535 doc
: /* Return most recently selected buffer other than BUFFER.
1536 Buffers not visible in windows are preferred to visible buffers, unless
1537 optional second argument VISIBLE-OK is non-nil. Ignore the argument
1538 BUFFER unless it denotes a live buffer. If the optional third argument
1539 FRAME is non-nil, use that frame's buffer list instead of the selected
1540 frame's buffer list.
1542 The buffer is found by scanning the selected or specified frame's buffer
1543 list first, followed by the list of all buffers. If no other buffer
1544 exists, return the buffer `*scratch*' (creating it if necessary). */)
1545 (register Lisp_Object buffer
, Lisp_Object visible_ok
, Lisp_Object frame
)
1547 Lisp_Object tail
, buf
, pred
;
1548 Lisp_Object notsogood
= Qnil
;
1551 frame
= selected_frame
;
1553 CHECK_FRAME (frame
);
1555 pred
= frame_buffer_predicate (frame
);
1556 /* Consider buffers that have been seen in the frame first. */
1557 tail
= XFRAME (frame
)->buffer_list
;
1558 for (; CONSP (tail
); tail
= XCDR (tail
))
1561 if (BUFFERP (buf
) && !EQ (buf
, buffer
)
1562 && BUFFER_LIVE_P (XBUFFER (buf
))
1563 && (SREF (BVAR (XBUFFER (buf
), name
), 0) != ' ')
1564 /* If the frame has a buffer_predicate, disregard buffers that
1565 don't fit the predicate. */
1566 && (NILP (pred
) || !NILP (call1 (pred
, buf
))))
1568 if (!NILP (visible_ok
)
1569 || NILP (Fget_buffer_window (buf
, Qvisible
)))
1571 else if (NILP (notsogood
))
1576 /* Consider alist of all buffers next. */
1577 tail
= Vbuffer_alist
;
1578 for (; CONSP (tail
); tail
= XCDR (tail
))
1580 buf
= Fcdr (XCAR (tail
));
1581 if (BUFFERP (buf
) && !EQ (buf
, buffer
)
1582 && BUFFER_LIVE_P (XBUFFER (buf
))
1583 && (SREF (BVAR (XBUFFER (buf
), name
), 0) != ' ')
1584 /* If the frame has a buffer_predicate, disregard buffers that
1585 don't fit the predicate. */
1586 && (NILP (pred
) || !NILP (call1 (pred
, buf
))))
1588 if (!NILP (visible_ok
)
1589 || NILP (Fget_buffer_window (buf
, Qvisible
)))
1591 else if (NILP (notsogood
))
1596 if (!NILP (notsogood
))
1600 buf
= Fget_buffer (build_string ("*scratch*"));
1603 buf
= Fget_buffer_create (build_string ("*scratch*"));
1604 Fset_buffer_major_mode (buf
);
1610 /* The following function is a safe variant of Fother_buffer: It doesn't
1611 pay attention to any frame-local buffer lists, doesn't care about
1612 visibility of buffers, and doesn't evaluate any frame predicates. */
1615 other_buffer_safely (Lisp_Object buffer
)
1617 Lisp_Object tail
, buf
;
1619 tail
= Vbuffer_alist
;
1620 for (; CONSP (tail
); tail
= XCDR (tail
))
1622 buf
= Fcdr (XCAR (tail
));
1623 if (BUFFERP (buf
) && !EQ (buf
, buffer
)
1624 && BUFFER_LIVE_P (XBUFFER (buf
))
1625 && (SREF (BVAR (XBUFFER (buf
), name
), 0) != ' '))
1629 buf
= Fget_buffer (build_string ("*scratch*"));
1632 buf
= Fget_buffer_create (build_string ("*scratch*"));
1633 Fset_buffer_major_mode (buf
);
1639 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo
, Sbuffer_enable_undo
,
1641 doc
: /* Start keeping undo information for buffer BUFFER.
1642 No argument or nil as argument means do this for the current buffer. */)
1643 (register Lisp_Object buffer
)
1645 Lisp_Object real_buffer
;
1648 XSETBUFFER (real_buffer
, current_buffer
);
1651 real_buffer
= Fget_buffer (buffer
);
1652 if (NILP (real_buffer
))
1656 if (EQ (BVAR (XBUFFER (real_buffer
), undo_list
), Qt
))
1657 bset_undo_list (XBUFFER (real_buffer
), Qnil
);
1662 /* Truncate undo list and shrink the gap of BUFFER. */
1665 compact_buffer (struct buffer
*buffer
)
1667 BUFFER_CHECK_INDIRECTION (buffer
);
1669 /* Skip dead buffers, indirect buffers and buffers
1670 which aren't changed since last compaction. */
1671 if (BUFFER_LIVE_P (buffer
)
1672 && (buffer
->base_buffer
== NULL
)
1673 && (buffer
->text
->compact
!= buffer
->text
->modiff
))
1675 /* If a buffer's undo list is Qt, that means that undo is
1676 turned off in that buffer. Calling truncate_undo_list on
1677 Qt tends to return NULL, which effectively turns undo back on.
1678 So don't call truncate_undo_list if undo_list is Qt. */
1679 if (!EQ (buffer
->INTERNAL_FIELD (undo_list
), Qt
))
1680 truncate_undo_list (buffer
);
1682 /* Shrink buffer gaps. */
1683 if (!buffer
->text
->inhibit_shrinking
)
1685 /* If a buffer's gap size is more than 10% of the buffer
1686 size, or larger than 2000 bytes, then shrink it
1687 accordingly. Keep a minimum size of 20 bytes. */
1688 int size
= min (2000, max (20, (buffer
->text
->z_byte
/ 10)));
1690 if (buffer
->text
->gap_size
> size
)
1692 struct buffer
*save_current
= current_buffer
;
1693 current_buffer
= buffer
;
1694 make_gap (-(buffer
->text
->gap_size
- size
));
1695 current_buffer
= save_current
;
1698 buffer
->text
->compact
= buffer
->text
->modiff
;
1702 DEFUN ("kill-buffer", Fkill_buffer
, Skill_buffer
, 0, 1, "bKill buffer: ",
1703 doc
: /* Kill the buffer specified by BUFFER-OR-NAME.
1704 The argument may be a buffer or the name of an existing buffer.
1705 Argument nil or omitted means kill the current buffer. Return t if the
1706 buffer is actually killed, nil otherwise.
1708 The functions in `kill-buffer-query-functions' are called with the
1709 buffer to be killed as the current buffer. If any of them returns nil,
1710 the buffer is not killed. The hook `kill-buffer-hook' is run before the
1711 buffer is actually killed. The buffer being killed will be current
1712 while the hook is running. Functions called by any of these hooks are
1713 supposed to not change the current buffer.
1715 Any processes that have this buffer as the `process-buffer' are killed
1716 with SIGHUP. This function calls `replace-buffer-in-windows' for
1717 cleaning up all windows currently displaying the buffer to be killed. */)
1718 (Lisp_Object buffer_or_name
)
1721 register struct buffer
*b
;
1722 register Lisp_Object tem
;
1723 register struct Lisp_Marker
*m
;
1724 struct gcpro gcpro1
;
1726 if (NILP (buffer_or_name
))
1727 buffer
= Fcurrent_buffer ();
1729 buffer
= Fget_buffer (buffer_or_name
);
1731 nsberror (buffer_or_name
);
1733 b
= XBUFFER (buffer
);
1735 /* Avoid trouble for buffer already dead. */
1736 if (!BUFFER_LIVE_P (b
))
1739 /* Query if the buffer is still modified. */
1740 if (INTERACTIVE
&& !NILP (BVAR (b
, filename
))
1741 && BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
1744 tem
= do_yes_or_no_p (format2 ("Buffer %s modified; kill anyway? ",
1745 BVAR (b
, name
), make_number (0)));
1751 /* Run hooks with the buffer to be killed the current buffer. */
1753 ptrdiff_t count
= SPECPDL_INDEX ();
1754 Lisp_Object arglist
[1];
1756 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1757 set_buffer_internal (b
);
1759 /* First run the query functions; if any query is answered no,
1760 don't kill the buffer. */
1761 arglist
[0] = Qkill_buffer_query_functions
;
1762 tem
= Frun_hook_with_args_until_failure (1, arglist
);
1764 return unbind_to (count
, Qnil
);
1766 /* Then run the hooks. */
1767 Frun_hooks (1, &Qkill_buffer_hook
);
1768 unbind_to (count
, Qnil
);
1771 /* If the hooks have killed the buffer, exit now. */
1772 if (!BUFFER_LIVE_P (b
))
1775 /* We have no more questions to ask. Verify that it is valid
1776 to kill the buffer. This must be done after the questions
1777 since anything can happen within do_yes_or_no_p. */
1779 /* Don't kill the minibuffer now current. */
1780 if (EQ (buffer
, XWINDOW (minibuf_window
)->buffer
))
1783 /* When we kill an ordinary buffer which shares it's buffer text
1784 with indirect buffer(s), we must kill indirect buffer(s) too.
1785 We do it at this stage so nothing terrible happens if they
1786 ask questions or their hooks get errors. */
1787 if (!b
->base_buffer
&& b
->indirections
> 0)
1789 struct buffer
*other
;
1793 FOR_EACH_BUFFER (other
)
1794 if (other
->base_buffer
== b
)
1797 XSETBUFFER (buf
, other
);
1803 /* Exit if we now have killed the base buffer (Bug#11665). */
1804 if (!BUFFER_LIVE_P (b
))
1808 /* Run replace_buffer_in_windows before making another buffer current
1809 since set-window-buffer-start-and-point will refuse to make another
1810 buffer current if the selected window does not show the current
1811 buffer. (Bug#10114) */
1812 replace_buffer_in_windows (buffer
);
1814 /* Exit if replacing the buffer in windows has killed our buffer. */
1815 if (!BUFFER_LIVE_P (b
))
1818 /* Make this buffer not be current. Exit if it is the sole visible
1820 if (b
== current_buffer
)
1822 tem
= Fother_buffer (buffer
, Qnil
, Qnil
);
1824 if (b
== current_buffer
)
1828 /* If the buffer now current is shown in the minibuffer and our buffer
1829 is the sole other buffer give up. */
1830 XSETBUFFER (tem
, current_buffer
);
1831 if (EQ (tem
, XWINDOW (minibuf_window
)->buffer
)
1832 && EQ (buffer
, Fother_buffer (buffer
, Qnil
, Qnil
)))
1835 /* Now there is no question: we can kill the buffer. */
1837 #ifdef CLASH_DETECTION
1838 /* Unlock this buffer's file, if it is locked. */
1840 #endif /* CLASH_DETECTION */
1843 kill_buffer_processes (buffer
);
1846 /* Killing buffer processes may run sentinels which may have killed
1848 if (!BUFFER_LIVE_P (b
))
1851 /* These may run Lisp code and into infinite loops (if someone
1852 insisted on circular lists) so allow quitting here. */
1853 frames_discard_buffer (buffer
);
1855 clear_charpos_cache (b
);
1857 tem
= Vinhibit_quit
;
1859 /* Remove the buffer from the list of all buffers. */
1860 Vbuffer_alist
= Fdelq (Frassq (buffer
, Vbuffer_alist
), Vbuffer_alist
);
1861 /* If replace_buffer_in_windows didn't do its job fix that now. */
1862 replace_buffer_in_windows_safely (buffer
);
1863 Vinhibit_quit
= tem
;
1865 /* Delete any auto-save file, if we saved it in this session.
1866 But not if the buffer is modified. */
1867 if (STRINGP (BVAR (b
, auto_save_file_name
))
1868 && BUF_AUTOSAVE_MODIFF (b
) != 0
1869 && BUF_SAVE_MODIFF (b
) < BUF_AUTOSAVE_MODIFF (b
)
1870 && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
)
1871 && NILP (Fsymbol_value (intern ("auto-save-visited-file-name"))))
1874 delete = Fsymbol_value (intern ("delete-auto-save-files"));
1875 if (! NILP (delete))
1876 internal_delete_file (BVAR (b
, auto_save_file_name
));
1879 /* Deleting an auto-save file could have killed our buffer. */
1880 if (!BUFFER_LIVE_P (b
))
1885 /* Unchain all markers that belong to this indirect buffer.
1886 Don't unchain the markers that belong to the base buffer
1887 or its other indirect buffers. */
1888 struct Lisp_Marker
**mp
= &BUF_MARKERS (b
);
1902 /* Unchain all markers of this buffer and its indirect buffers.
1903 and leave them pointing nowhere. */
1904 for (m
= BUF_MARKERS (b
); m
; )
1906 struct Lisp_Marker
*next
= m
->next
;
1911 BUF_MARKERS (b
) = NULL
;
1912 set_buffer_intervals (b
, NULL
);
1914 /* Perhaps we should explicitly free the interval tree here... */
1916 /* Since we've unlinked the markers, the overlays can't be here any more
1918 b
->overlays_before
= NULL
;
1919 b
->overlays_after
= NULL
;
1921 /* Reset the local variables, so that this buffer's local values
1922 won't be protected from GC. They would be protected
1923 if they happened to remain cached in their symbols.
1924 This gets rid of them for certain. */
1925 swap_out_buffer_local_variables (b
);
1926 reset_buffer_local_variables (b
, 1);
1928 bset_name (b
, Qnil
);
1933 /* Notify our base buffer that we don't share the text anymore. */
1934 eassert (b
->indirections
== -1);
1935 b
->base_buffer
->indirections
--;
1936 eassert (b
->base_buffer
->indirections
>= 0);
1939 /* No one shares our buffer text, can free it. */
1940 free_buffer_text (b
);
1942 if (b
->newline_cache
)
1944 free_region_cache (b
->newline_cache
);
1945 b
->newline_cache
= 0;
1947 if (b
->width_run_cache
)
1949 free_region_cache (b
->width_run_cache
);
1950 b
->width_run_cache
= 0;
1952 bset_width_table (b
, Qnil
);
1954 bset_undo_list (b
, Qnil
);
1956 /* Run buffer-list-update-hook. */
1957 if (!NILP (Vrun_hooks
))
1958 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1963 /* Move association for BUFFER to the front of buffer (a)lists. Since
1964 we do this each time BUFFER is selected visibly, the more recently
1965 selected buffers are always closer to the front of those lists. This
1966 means that other_buffer is more likely to choose a relevant buffer.
1968 Note that this moves BUFFER to the front of the buffer lists of the
1969 selected frame even if BUFFER is not shown there. If BUFFER is not
1970 shown in the selected frame, consider the present behavior a feature.
1971 `select-window' gets this right since it shows BUFFER in the selected
1972 window when calling us. */
1975 record_buffer (Lisp_Object buffer
)
1977 Lisp_Object aelt
, aelt_cons
, tem
;
1978 register struct frame
*f
= XFRAME (selected_frame
);
1980 CHECK_BUFFER (buffer
);
1982 /* Update Vbuffer_alist (we know that it has an entry for BUFFER).
1983 Don't allow quitting since this might leave the buffer list in an
1984 inconsistent state. */
1985 tem
= Vinhibit_quit
;
1987 aelt
= Frassq (buffer
, Vbuffer_alist
);
1988 aelt_cons
= Fmemq (aelt
, Vbuffer_alist
);
1989 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
1990 XSETCDR (aelt_cons
, Vbuffer_alist
);
1991 Vbuffer_alist
= aelt_cons
;
1992 Vinhibit_quit
= tem
;
1994 /* Update buffer list of selected frame. */
1995 fset_buffer_list (f
, Fcons (buffer
, Fdelq (buffer
, f
->buffer_list
)));
1996 fset_buried_buffer_list (f
, Fdelq (buffer
, f
->buried_buffer_list
));
1998 /* Run buffer-list-update-hook. */
1999 if (!NILP (Vrun_hooks
))
2000 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
2004 /* Move BUFFER to the end of the buffer (a)lists. Do nothing if the
2005 buffer is killed. For the selected frame's buffer list this moves
2006 BUFFER to its end even if it was never shown in that frame. If
2007 this happens we have a feature, hence `bury-buffer-internal' should be
2008 called only when BUFFER was shown in the selected frame. */
2010 DEFUN ("bury-buffer-internal", Fbury_buffer_internal
, Sbury_buffer_internal
,
2012 doc
: /* Move BUFFER to the end of the buffer list. */)
2013 (Lisp_Object buffer
)
2015 Lisp_Object aelt
, aelt_cons
, tem
;
2016 register struct frame
*f
= XFRAME (selected_frame
);
2018 CHECK_BUFFER (buffer
);
2020 /* Update Vbuffer_alist (we know that it has an entry for BUFFER).
2021 Don't allow quitting since this might leave the buffer list in an
2022 inconsistent state. */
2023 tem
= Vinhibit_quit
;
2025 aelt
= Frassq (buffer
, Vbuffer_alist
);
2026 aelt_cons
= Fmemq (aelt
, Vbuffer_alist
);
2027 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
2028 XSETCDR (aelt_cons
, Qnil
);
2029 Vbuffer_alist
= nconc2 (Vbuffer_alist
, aelt_cons
);
2030 Vinhibit_quit
= tem
;
2032 /* Update buffer lists of selected frame. */
2033 fset_buffer_list (f
, Fdelq (buffer
, f
->buffer_list
));
2034 fset_buried_buffer_list
2035 (f
, Fcons (buffer
, Fdelq (buffer
, f
->buried_buffer_list
)));
2037 /* Run buffer-list-update-hook. */
2038 if (!NILP (Vrun_hooks
))
2039 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
2044 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode
, Sset_buffer_major_mode
, 1, 1, 0,
2045 doc
: /* Set an appropriate major mode for BUFFER.
2046 For the *scratch* buffer, use `initial-major-mode', otherwise choose a mode
2047 according to the default value of `major-mode'.
2048 Use this function before selecting the buffer, since it may need to inspect
2049 the current buffer's major mode. */)
2050 (Lisp_Object buffer
)
2053 Lisp_Object function
;
2055 CHECK_BUFFER (buffer
);
2057 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
2058 error ("Attempt to set major mode for a dead buffer");
2060 if (strcmp (SSDATA (BVAR (XBUFFER (buffer
), name
)), "*scratch*") == 0)
2061 function
= find_symbol_value (intern ("initial-major-mode"));
2064 function
= BVAR (&buffer_defaults
, major_mode
);
2066 && NILP (Fget (BVAR (current_buffer
, major_mode
), Qmode_class
)))
2067 function
= BVAR (current_buffer
, major_mode
);
2070 if (NILP (function
) || EQ (function
, Qfundamental_mode
))
2073 count
= SPECPDL_INDEX ();
2075 /* To select a nonfundamental mode,
2076 select the buffer temporarily and then call the mode function. */
2078 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2080 Fset_buffer (buffer
);
2083 return unbind_to (count
, Qnil
);
2086 DEFUN ("current-buffer", Fcurrent_buffer
, Scurrent_buffer
, 0, 0, 0,
2087 doc
: /* Return the current buffer as a Lisp object. */)
2090 register Lisp_Object buf
;
2091 XSETBUFFER (buf
, current_buffer
);
2095 /* Set the current buffer to B, and do not set windows_or_buffers_changed.
2096 This is used by redisplay. */
2099 set_buffer_internal_1 (register struct buffer
*b
)
2101 register struct buffer
*old_buf
;
2102 register Lisp_Object tail
;
2104 #ifdef USE_MMAP_FOR_BUFFERS
2105 if (b
->text
->beg
== NULL
)
2106 enlarge_buffer_text (b
, 0);
2107 #endif /* USE_MMAP_FOR_BUFFERS */
2109 if (current_buffer
== b
)
2112 BUFFER_CHECK_INDIRECTION (b
);
2114 old_buf
= current_buffer
;
2116 last_known_column_point
= -1; /* invalidate indentation cache */
2120 /* Put the undo list back in the base buffer, so that it appears
2121 that an indirect buffer shares the undo list of its base. */
2122 if (old_buf
->base_buffer
)
2123 bset_undo_list (old_buf
->base_buffer
, BVAR (old_buf
, undo_list
));
2125 /* If the old current buffer has markers to record PT, BEGV and ZV
2126 when it is not current, update them now. */
2127 record_buffer_markers (old_buf
);
2130 /* Get the undo list from the base buffer, so that it appears
2131 that an indirect buffer shares the undo list of its base. */
2133 bset_undo_list (b
, BVAR (b
->base_buffer
, undo_list
));
2135 /* If the new current buffer has markers to record PT, BEGV and ZV
2136 when it is not current, fetch them now. */
2137 fetch_buffer_markers (b
);
2139 /* Look down buffer's list of local Lisp variables
2140 to find and update any that forward into C variables. */
2144 for (tail
= BVAR (b
, local_var_alist
); CONSP (tail
); tail
= XCDR (tail
))
2146 Lisp_Object var
= XCAR (XCAR (tail
));
2147 struct Lisp_Symbol
*sym
= XSYMBOL (var
);
2148 if (sym
->redirect
== SYMBOL_LOCALIZED
/* Just to be sure. */
2149 && SYMBOL_BLV (sym
)->fwd
)
2150 /* Just reference the variable
2151 to cause it to become set for this buffer. */
2152 Fsymbol_value (var
);
2155 /* Do the same with any others that were local to the previous buffer */
2156 while (b
!= old_buf
&& (b
= old_buf
, b
));
2159 /* Switch to buffer B temporarily for redisplay purposes.
2160 This avoids certain things that don't need to be done within redisplay. */
2163 set_buffer_temp (struct buffer
*b
)
2165 register struct buffer
*old_buf
;
2167 if (current_buffer
== b
)
2170 old_buf
= current_buffer
;
2173 /* If the old current buffer has markers to record PT, BEGV and ZV
2174 when it is not current, update them now. */
2175 record_buffer_markers (old_buf
);
2177 /* If the new current buffer has markers to record PT, BEGV and ZV
2178 when it is not current, fetch them now. */
2179 fetch_buffer_markers (b
);
2182 DEFUN ("set-buffer", Fset_buffer
, Sset_buffer
, 1, 1, 0,
2183 doc
: /* Make buffer BUFFER-OR-NAME current for editing operations.
2184 BUFFER-OR-NAME may be a buffer or the name of an existing buffer. See
2185 also `with-current-buffer' when you want to make a buffer current
2186 temporarily. This function does not display the buffer, so its effect
2187 ends when the current command terminates. Use `switch-to-buffer' or
2188 `pop-to-buffer' to switch buffers permanently. */)
2189 (register Lisp_Object buffer_or_name
)
2191 register Lisp_Object buffer
;
2192 buffer
= Fget_buffer (buffer_or_name
);
2194 nsberror (buffer_or_name
);
2195 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
2196 error ("Selecting deleted buffer");
2197 set_buffer_internal (XBUFFER (buffer
));
2201 /* Set the current buffer to BUFFER provided if it is alive. */
2204 set_buffer_if_live (Lisp_Object buffer
)
2206 if (BUFFER_LIVE_P (XBUFFER (buffer
)))
2207 set_buffer_internal (XBUFFER (buffer
));
2211 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only
,
2212 Sbarf_if_buffer_read_only
, 0, 0, 0,
2213 doc
: /* Signal a `buffer-read-only' error if the current buffer is read-only. */)
2216 if (!NILP (BVAR (current_buffer
, read_only
))
2217 && NILP (Vinhibit_read_only
))
2218 xsignal1 (Qbuffer_read_only
, Fcurrent_buffer ());
2222 DEFUN ("erase-buffer", Ferase_buffer
, Serase_buffer
, 0, 0, "*",
2223 doc
: /* Delete the entire contents of the current buffer.
2224 Any narrowing restriction in effect (see `narrow-to-region') is removed,
2225 so the buffer is truly empty after this. */)
2232 current_buffer
->last_window_start
= 1;
2233 /* Prevent warnings, or suspension of auto saving, that would happen
2234 if future size is less than past size. Use of erase-buffer
2235 implies that the future text is not really related to the past text. */
2236 XSETFASTINT (BVAR (current_buffer
, save_length
), 0);
2241 validate_region (register Lisp_Object
*b
, register Lisp_Object
*e
)
2243 CHECK_NUMBER_COERCE_MARKER (*b
);
2244 CHECK_NUMBER_COERCE_MARKER (*e
);
2246 if (XINT (*b
) > XINT (*e
))
2249 tem
= *b
; *b
= *e
; *e
= tem
;
2252 if (! (BEGV
<= XINT (*b
) && XINT (*e
) <= ZV
))
2253 args_out_of_range (*b
, *e
);
2256 /* Advance BYTE_POS up to a character boundary
2257 and return the adjusted position. */
2260 advance_to_char_boundary (ptrdiff_t byte_pos
)
2264 if (byte_pos
== BEG
)
2265 /* Beginning of buffer is always a character boundary. */
2268 c
= FETCH_BYTE (byte_pos
);
2269 if (! CHAR_HEAD_P (c
))
2271 /* We should advance BYTE_POS only when C is a constituent of a
2272 multibyte sequence. */
2273 ptrdiff_t orig_byte_pos
= byte_pos
;
2278 c
= FETCH_BYTE (byte_pos
);
2280 while (! CHAR_HEAD_P (c
) && byte_pos
> BEG
);
2282 if (byte_pos
< orig_byte_pos
)
2283 byte_pos
= orig_byte_pos
;
2284 /* If C is a constituent of a multibyte sequence, BYTE_POS was
2285 surely advance to the correct character boundary. If C is
2286 not, BYTE_POS was unchanged. */
2292 DEFUN ("buffer-swap-text", Fbuffer_swap_text
, Sbuffer_swap_text
,
2294 doc
: /* Swap the text between current buffer and BUFFER. */)
2295 (Lisp_Object buffer
)
2297 struct buffer
*other_buffer
;
2298 CHECK_BUFFER (buffer
);
2299 other_buffer
= XBUFFER (buffer
);
2301 if (!BUFFER_LIVE_P (other_buffer
))
2302 error ("Cannot swap a dead buffer's text");
2304 /* Actually, it probably works just fine.
2305 * if (other_buffer == current_buffer)
2306 * error ("Cannot swap a buffer's text with itself"); */
2308 /* Actually, this may be workable as well, tho probably only if they're
2310 if (other_buffer
->base_buffer
2311 || current_buffer
->base_buffer
)
2312 error ("Cannot swap indirect buffers's text");
2314 { /* This is probably harder to make work. */
2315 struct buffer
*other
;
2316 FOR_EACH_BUFFER (other
)
2317 if (other
->base_buffer
== other_buffer
2318 || other
->base_buffer
== current_buffer
)
2319 error ("One of the buffers to swap has indirect buffers");
2322 #define swapfield(field, type) \
2324 type tmp##field = other_buffer->field; \
2325 other_buffer->field = current_buffer->field; \
2326 current_buffer->field = tmp##field; \
2328 #define swapfield_(field, type) \
2330 type tmp##field = BVAR (other_buffer, field); \
2331 bset_##field (other_buffer, BVAR (current_buffer, field)); \
2332 bset_##field (current_buffer, tmp##field); \
2335 swapfield (own_text
, struct buffer_text
);
2336 eassert (current_buffer
->text
== ¤t_buffer
->own_text
);
2337 eassert (other_buffer
->text
== &other_buffer
->own_text
);
2339 r_alloc_reset_variable ((void **) ¤t_buffer
->own_text
.beg
,
2340 (void **) &other_buffer
->own_text
.beg
);
2341 r_alloc_reset_variable ((void **) &other_buffer
->own_text
.beg
,
2342 (void **) ¤t_buffer
->own_text
.beg
);
2343 #endif /* REL_ALLOC */
2345 swapfield (pt
, ptrdiff_t);
2346 swapfield (pt_byte
, ptrdiff_t);
2347 swapfield (begv
, ptrdiff_t);
2348 swapfield (begv_byte
, ptrdiff_t);
2349 swapfield (zv
, ptrdiff_t);
2350 swapfield (zv_byte
, ptrdiff_t);
2351 eassert (!current_buffer
->base_buffer
);
2352 eassert (!other_buffer
->base_buffer
);
2353 swapfield (indirections
, ptrdiff_t);
2354 current_buffer
->clip_changed
= 1; other_buffer
->clip_changed
= 1;
2355 swapfield (newline_cache
, struct region_cache
*);
2356 swapfield (width_run_cache
, struct region_cache
*);
2357 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2358 other_buffer
->prevent_redisplay_optimizations_p
= 1;
2359 swapfield (overlays_before
, struct Lisp_Overlay
*);
2360 swapfield (overlays_after
, struct Lisp_Overlay
*);
2361 swapfield (overlay_center
, ptrdiff_t);
2362 swapfield_ (undo_list
, Lisp_Object
);
2363 swapfield_ (mark
, Lisp_Object
);
2364 swapfield_ (enable_multibyte_characters
, Lisp_Object
);
2365 swapfield_ (bidi_display_reordering
, Lisp_Object
);
2366 swapfield_ (bidi_paragraph_direction
, Lisp_Object
);
2367 /* FIXME: Not sure what we should do with these *_marker fields.
2368 Hopefully they're just nil anyway. */
2369 swapfield_ (pt_marker
, Lisp_Object
);
2370 swapfield_ (begv_marker
, Lisp_Object
);
2371 swapfield_ (zv_marker
, Lisp_Object
);
2372 bset_point_before_scroll (current_buffer
, Qnil
);
2373 bset_point_before_scroll (other_buffer
, Qnil
);
2375 current_buffer
->text
->modiff
++; other_buffer
->text
->modiff
++;
2376 current_buffer
->text
->chars_modiff
++; other_buffer
->text
->chars_modiff
++;
2377 current_buffer
->text
->overlay_modiff
++; other_buffer
->text
->overlay_modiff
++;
2378 current_buffer
->text
->beg_unchanged
= current_buffer
->text
->gpt
;
2379 current_buffer
->text
->end_unchanged
= current_buffer
->text
->gpt
;
2380 other_buffer
->text
->beg_unchanged
= other_buffer
->text
->gpt
;
2381 other_buffer
->text
->end_unchanged
= other_buffer
->text
->gpt
;
2383 struct Lisp_Marker
*m
;
2384 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
2385 if (m
->buffer
== other_buffer
)
2386 m
->buffer
= current_buffer
;
2388 /* Since there's no indirect buffer in sight, markers on
2389 BUF_MARKERS(buf) should either be for `buf' or dead. */
2390 eassert (!m
->buffer
);
2391 for (m
= BUF_MARKERS (other_buffer
); m
; m
= m
->next
)
2392 if (m
->buffer
== current_buffer
)
2393 m
->buffer
= other_buffer
;
2395 /* Since there's no indirect buffer in sight, markers on
2396 BUF_MARKERS(buf) should either be for `buf' or dead. */
2397 eassert (!m
->buffer
);
2399 { /* Some of the C code expects that w->buffer == w->pointm->buffer.
2400 So since we just swapped the markers between the two buffers, we need
2401 to undo the effect of this swap for window markers. */
2402 Lisp_Object w
= Fselected_window (), ws
= Qnil
;
2403 Lisp_Object buf1
, buf2
;
2404 XSETBUFFER (buf1
, current_buffer
); XSETBUFFER (buf2
, other_buffer
);
2406 while (NILP (Fmemq (w
, ws
)))
2409 if (MARKERP (XWINDOW (w
)->pointm
)
2410 && (EQ (XWINDOW (w
)->buffer
, buf1
)
2411 || EQ (XWINDOW (w
)->buffer
, buf2
)))
2412 Fset_marker (XWINDOW (w
)->pointm
,
2414 (BUF_BEGV (XBUFFER (XWINDOW (w
)->buffer
))),
2415 XWINDOW (w
)->buffer
);
2416 w
= Fnext_window (w
, Qt
, Qt
);
2420 if (current_buffer
->text
->intervals
)
2421 (eassert (EQ (current_buffer
->text
->intervals
->up
.obj
, buffer
)),
2422 XSETBUFFER (current_buffer
->text
->intervals
->up
.obj
, current_buffer
));
2423 if (other_buffer
->text
->intervals
)
2424 (eassert (EQ (other_buffer
->text
->intervals
->up
.obj
, Fcurrent_buffer ())),
2425 XSETBUFFER (other_buffer
->text
->intervals
->up
.obj
, other_buffer
));
2430 DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte
, Sset_buffer_multibyte
,
2432 doc
: /* Set the multibyte flag of the current buffer to FLAG.
2433 If FLAG is t, this makes the buffer a multibyte buffer.
2434 If FLAG is nil, this makes the buffer a single-byte buffer.
2435 In these cases, the buffer contents remain unchanged as a sequence of
2436 bytes but the contents viewed as characters do change.
2437 If FLAG is `to', this makes the buffer a multibyte buffer by changing
2438 all eight-bit bytes to eight-bit characters.
2439 If the multibyte flag was really changed, undo information of the
2440 current buffer is cleared. */)
2443 struct Lisp_Marker
*tail
, *markers
;
2444 struct buffer
*other
;
2446 bool narrowed
= (BEG
!= BEGV
|| Z
!= ZV
);
2447 bool modified_p
= !NILP (Fbuffer_modified_p (Qnil
));
2448 Lisp_Object old_undo
= BVAR (current_buffer
, undo_list
);
2449 struct gcpro gcpro1
;
2451 if (current_buffer
->base_buffer
)
2452 error ("Cannot do `set-buffer-multibyte' on an indirect buffer");
2454 /* Do nothing if nothing actually changes. */
2455 if (NILP (flag
) == NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
2460 /* Don't record these buffer changes. We will put a special undo entry
2462 bset_undo_list (current_buffer
, Qt
);
2464 /* If the cached position is for this buffer, clear it out. */
2465 clear_charpos_cache (current_buffer
);
2468 begv
= BEGV_BYTE
, zv
= ZV_BYTE
;
2470 begv
= BEGV
, zv
= ZV
;
2473 error ("Changing multibyteness in a narrowed buffer");
2477 ptrdiff_t pos
, stop
;
2480 /* Do this first, so it can use CHAR_TO_BYTE
2481 to calculate the old correspondences. */
2482 set_intervals_multibyte (0);
2484 bset_enable_multibyte_characters (current_buffer
, Qnil
);
2490 TEMP_SET_PT_BOTH (PT_BYTE
, PT_BYTE
);
2493 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
2494 tail
->charpos
= tail
->bytepos
;
2496 /* Convert multibyte form of 8-bit characters to unibyte. */
2511 if (ASCII_BYTE_P (*p
))
2513 else if (CHAR_BYTE8_HEAD_P (*p
))
2515 c
= STRING_CHAR_AND_LENGTH (p
, bytes
);
2516 /* Delete all bytes for this 8-bit character but the
2517 last one, and change the last one to the character
2520 del_range_2 (pos
, pos
, pos
+ bytes
, pos
+ bytes
, 0);
2532 bytes
= BYTES_BY_CHAR_HEAD (*p
);
2533 p
+= bytes
, pos
+= bytes
;
2537 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2542 ptrdiff_t pos
, stop
;
2543 unsigned char *p
, *pend
;
2545 /* Be sure not to have a multibyte sequence striding over the GAP.
2546 Ex: We change this: "...abc\302 _GAP_ \241def..."
2547 to: "...abc _GAP_ \302\241def..." */
2550 && GPT_BYTE
> 1 && GPT_BYTE
< Z_BYTE
2551 && ! CHAR_HEAD_P (*(GAP_END_ADDR
)))
2553 unsigned char *q
= GPT_ADDR
- 1;
2555 while (! CHAR_HEAD_P (*q
) && q
> BEG_ADDR
) q
--;
2556 if (LEADING_CODE_P (*q
))
2558 ptrdiff_t new_gpt
= GPT_BYTE
- (GPT_ADDR
- q
);
2560 move_gap_both (new_gpt
, new_gpt
);
2564 /* Make the buffer contents valid as multibyte by converting
2565 8-bit characters to multibyte form. */
2583 if (ASCII_BYTE_P (*p
))
2585 else if (EQ (flag
, Qt
)
2586 && ! CHAR_BYTE8_HEAD_P (*p
)
2587 && (bytes
= MULTIBYTE_LENGTH (p
, pend
)) > 0)
2588 p
+= bytes
, pos
+= bytes
;
2591 unsigned char tmp
[MAX_MULTIBYTE_LENGTH
];
2594 c
= BYTE8_TO_CHAR (*p
);
2595 bytes
= CHAR_STRING (c
, tmp
);
2597 TEMP_SET_PT_BOTH (pos
+ 1, pos
+ 1);
2599 insert_1_both ((char *) tmp
+ 1, bytes
, bytes
, 1, 0, 0);
2600 /* Now the gap is after the just inserted data. */
2618 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2620 /* Do this first, so that chars_in_text asks the right question.
2621 set_intervals_multibyte needs it too. */
2622 bset_enable_multibyte_characters (current_buffer
, Qt
);
2624 GPT_BYTE
= advance_to_char_boundary (GPT_BYTE
);
2625 GPT
= chars_in_text (BEG_ADDR
, GPT_BYTE
- BEG_BYTE
) + BEG
;
2627 Z
= chars_in_text (GAP_END_ADDR
, Z_BYTE
- GPT_BYTE
) + GPT
;
2629 BEGV_BYTE
= advance_to_char_boundary (BEGV_BYTE
);
2630 if (BEGV_BYTE
> GPT_BYTE
)
2631 BEGV
= chars_in_text (GAP_END_ADDR
, BEGV_BYTE
- GPT_BYTE
) + GPT
;
2633 BEGV
= chars_in_text (BEG_ADDR
, BEGV_BYTE
- BEG_BYTE
) + BEG
;
2635 ZV_BYTE
= advance_to_char_boundary (ZV_BYTE
);
2636 if (ZV_BYTE
> GPT_BYTE
)
2637 ZV
= chars_in_text (GAP_END_ADDR
, ZV_BYTE
- GPT_BYTE
) + GPT
;
2639 ZV
= chars_in_text (BEG_ADDR
, ZV_BYTE
- BEG_BYTE
) + BEG
;
2642 ptrdiff_t byte
= advance_to_char_boundary (PT_BYTE
);
2645 if (byte
> GPT_BYTE
)
2646 position
= chars_in_text (GAP_END_ADDR
, byte
- GPT_BYTE
) + GPT
;
2648 position
= chars_in_text (BEG_ADDR
, byte
- BEG_BYTE
) + BEG
;
2649 TEMP_SET_PT_BOTH (position
, byte
);
2652 tail
= markers
= BUF_MARKERS (current_buffer
);
2654 /* This prevents BYTE_TO_CHAR (that is, buf_bytepos_to_charpos) from
2655 getting confused by the markers that have not yet been updated.
2656 It is also a signal that it should never create a marker. */
2657 BUF_MARKERS (current_buffer
) = NULL
;
2659 for (; tail
; tail
= tail
->next
)
2661 tail
->bytepos
= advance_to_char_boundary (tail
->bytepos
);
2662 tail
->charpos
= BYTE_TO_CHAR (tail
->bytepos
);
2665 /* Make sure no markers were put on the chain
2666 while the chain value was incorrect. */
2667 if (BUF_MARKERS (current_buffer
))
2670 BUF_MARKERS (current_buffer
) = markers
;
2672 /* Do this last, so it can calculate the new correspondences
2673 between chars and bytes. */
2674 set_intervals_multibyte (1);
2677 if (!EQ (old_undo
, Qt
))
2679 /* Represent all the above changes by a special undo entry. */
2680 bset_undo_list (current_buffer
,
2681 Fcons (list3 (Qapply
,
2682 intern ("set-buffer-multibyte"),
2683 NILP (flag
) ? Qt
: Qnil
),
2689 /* Changing the multibyteness of a buffer means that all windows
2690 showing that buffer must be updated thoroughly. */
2691 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2692 ++windows_or_buffers_changed
;
2694 /* Copy this buffer's new multibyte status
2695 into all of its indirect buffers. */
2696 FOR_EACH_BUFFER (other
)
2697 if (other
->base_buffer
== current_buffer
&& BUFFER_LIVE_P (other
))
2699 BVAR (other
, enable_multibyte_characters
)
2700 = BVAR (current_buffer
, enable_multibyte_characters
);
2701 other
->prevent_redisplay_optimizations_p
= 1;
2704 /* Restore the modifiedness of the buffer. */
2705 if (!modified_p
&& !NILP (Fbuffer_modified_p (Qnil
)))
2706 Fset_buffer_modified_p (Qnil
);
2708 /* Update coding systems of this buffer's process (if any). */
2710 Lisp_Object process
;
2712 process
= Fget_buffer_process (Fcurrent_buffer ());
2713 if (PROCESSP (process
))
2714 setup_process_coding_systems (process
);
2720 DEFUN ("kill-all-local-variables", Fkill_all_local_variables
,
2721 Skill_all_local_variables
, 0, 0, 0,
2722 doc
: /* Switch to Fundamental mode by killing current buffer's local variables.
2723 Most local variable bindings are eliminated so that the default values
2724 become effective once more. Also, the syntax table is set from
2725 `standard-syntax-table', the local keymap is set to nil,
2726 and the abbrev table from `fundamental-mode-abbrev-table'.
2727 This function also forces redisplay of the mode line.
2729 Every function to select a new major mode starts by
2730 calling this function.
2732 As a special exception, local variables whose names have
2733 a non-nil `permanent-local' property are not eliminated by this function.
2735 The first thing this function does is run
2736 the normal hook `change-major-mode-hook'. */)
2739 Frun_hooks (1, &Qchange_major_mode_hook
);
2741 /* Make sure none of the bindings in local_var_alist
2742 remain swapped in, in their symbols. */
2744 swap_out_buffer_local_variables (current_buffer
);
2746 /* Actually eliminate all local bindings of this buffer. */
2748 reset_buffer_local_variables (current_buffer
, 0);
2750 /* Force mode-line redisplay. Useful here because all major mode
2751 commands call this function. */
2752 update_mode_lines
++;
2757 /* Make sure no local variables remain set up with buffer B
2758 for their current values. */
2761 swap_out_buffer_local_variables (struct buffer
*b
)
2763 Lisp_Object oalist
, alist
, buffer
;
2765 XSETBUFFER (buffer
, b
);
2766 oalist
= BVAR (b
, local_var_alist
);
2768 for (alist
= oalist
; CONSP (alist
); alist
= XCDR (alist
))
2770 Lisp_Object sym
= XCAR (XCAR (alist
));
2771 eassert (XSYMBOL (sym
)->redirect
== SYMBOL_LOCALIZED
);
2772 /* Need not do anything if some other buffer's binding is
2774 if (EQ (SYMBOL_BLV (XSYMBOL (sym
))->where
, buffer
))
2776 /* Symbol is set up for this buffer's old local value:
2778 swap_in_global_binding (XSYMBOL (sym
));
2783 /* Find all the overlays in the current buffer that contain position POS.
2784 Return the number found, and store them in a vector in *VEC_PTR.
2785 Store in *LEN_PTR the size allocated for the vector.
2786 Store in *NEXT_PTR the next position after POS where an overlay starts,
2787 or ZV if there are no more overlays between POS and ZV.
2788 Store in *PREV_PTR the previous position before POS where an overlay ends,
2789 or where an overlay starts which ends at or after POS;
2790 or BEGV if there are no such overlays from BEGV to POS.
2791 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2793 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2794 when this function is called.
2796 If EXTEND, make the vector bigger if necessary.
2797 If not, never extend the vector,
2798 and store only as many overlays as will fit.
2799 But still return the total number of overlays.
2801 If CHANGE_REQ, any position written into *PREV_PTR or
2802 *NEXT_PTR is guaranteed to be not equal to POS, unless it is the
2803 default (BEGV or ZV). */
2806 overlays_at (EMACS_INT pos
, bool extend
, Lisp_Object
**vec_ptr
,
2808 ptrdiff_t *next_ptr
, ptrdiff_t *prev_ptr
, bool change_req
)
2810 Lisp_Object overlay
, start
, end
;
2811 struct Lisp_Overlay
*tail
;
2813 ptrdiff_t len
= *len_ptr
;
2814 Lisp_Object
*vec
= *vec_ptr
;
2815 ptrdiff_t next
= ZV
;
2816 ptrdiff_t prev
= BEGV
;
2817 bool inhibit_storing
= 0;
2819 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2821 ptrdiff_t startpos
, endpos
;
2823 XSETMISC (overlay
, tail
);
2825 start
= OVERLAY_START (overlay
);
2826 end
= OVERLAY_END (overlay
);
2827 endpos
= OVERLAY_POSITION (end
);
2834 startpos
= OVERLAY_POSITION (start
);
2835 /* This one ends at or after POS
2836 so its start counts for PREV_PTR if it's before POS. */
2837 if (prev
< startpos
&& startpos
< pos
)
2841 if (startpos
<= pos
)
2845 /* The supplied vector is full.
2846 Either make it bigger, or don't store any more in it. */
2849 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2855 inhibit_storing
= 1;
2858 if (!inhibit_storing
)
2860 /* Keep counting overlays even if we can't return them all. */
2863 else if (startpos
< next
)
2867 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2869 ptrdiff_t startpos
, endpos
;
2871 XSETMISC (overlay
, tail
);
2873 start
= OVERLAY_START (overlay
);
2874 end
= OVERLAY_END (overlay
);
2875 startpos
= OVERLAY_POSITION (start
);
2878 if (startpos
< next
)
2882 endpos
= OVERLAY_POSITION (end
);
2889 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2895 inhibit_storing
= 1;
2898 if (!inhibit_storing
)
2902 if (startpos
< pos
&& startpos
> prev
)
2905 else if (endpos
< pos
&& endpos
> prev
)
2907 else if (endpos
== pos
&& startpos
> prev
2908 && (!change_req
|| startpos
< pos
))
2919 /* Find all the overlays in the current buffer that overlap the range
2920 BEG-END, or are empty at BEG, or are empty at END provided END
2921 denotes the position at the end of the current buffer.
2923 Return the number found, and store them in a vector in *VEC_PTR.
2924 Store in *LEN_PTR the size allocated for the vector.
2925 Store in *NEXT_PTR the next position after POS where an overlay starts,
2926 or ZV if there are no more overlays.
2927 Store in *PREV_PTR the previous position before POS where an overlay ends,
2928 or BEGV if there are no previous overlays.
2929 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2931 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2932 when this function is called.
2934 If EXTEND, make the vector bigger if necessary.
2935 If not, never extend the vector,
2936 and store only as many overlays as will fit.
2937 But still return the total number of overlays. */
2940 overlays_in (EMACS_INT beg
, EMACS_INT end
, bool extend
,
2941 Lisp_Object
**vec_ptr
, ptrdiff_t *len_ptr
,
2942 ptrdiff_t *next_ptr
, ptrdiff_t *prev_ptr
)
2944 Lisp_Object overlay
, ostart
, oend
;
2945 struct Lisp_Overlay
*tail
;
2947 ptrdiff_t len
= *len_ptr
;
2948 Lisp_Object
*vec
= *vec_ptr
;
2949 ptrdiff_t next
= ZV
;
2950 ptrdiff_t prev
= BEGV
;
2951 bool inhibit_storing
= 0;
2952 bool end_is_Z
= end
== Z
;
2954 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2956 ptrdiff_t startpos
, endpos
;
2958 XSETMISC (overlay
, tail
);
2960 ostart
= OVERLAY_START (overlay
);
2961 oend
= OVERLAY_END (overlay
);
2962 endpos
= OVERLAY_POSITION (oend
);
2969 startpos
= OVERLAY_POSITION (ostart
);
2970 /* Count an interval if it overlaps the range, is empty at the
2971 start of the range, or is empty at END provided END denotes the
2972 end of the buffer. */
2973 if ((beg
< endpos
&& startpos
< end
)
2974 || (startpos
== endpos
2975 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
2979 /* The supplied vector is full.
2980 Either make it bigger, or don't store any more in it. */
2983 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2989 inhibit_storing
= 1;
2992 if (!inhibit_storing
)
2994 /* Keep counting overlays even if we can't return them all. */
2997 else if (startpos
< next
)
3001 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
3003 ptrdiff_t startpos
, endpos
;
3005 XSETMISC (overlay
, tail
);
3007 ostart
= OVERLAY_START (overlay
);
3008 oend
= OVERLAY_END (overlay
);
3009 startpos
= OVERLAY_POSITION (ostart
);
3012 if (startpos
< next
)
3016 endpos
= OVERLAY_POSITION (oend
);
3017 /* Count an interval if it overlaps the range, is empty at the
3018 start of the range, or is empty at END provided END denotes the
3019 end of the buffer. */
3020 if ((beg
< endpos
&& startpos
< end
)
3021 || (startpos
== endpos
3022 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
3028 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
3034 inhibit_storing
= 1;
3037 if (!inhibit_storing
)
3041 else if (endpos
< beg
&& endpos
> prev
)
3053 /* Return true if there exists an overlay with a non-nil
3054 `mouse-face' property overlapping OVERLAY. */
3057 mouse_face_overlay_overlaps (Lisp_Object overlay
)
3059 ptrdiff_t start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3060 ptrdiff_t end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3061 ptrdiff_t n
, i
, size
;
3062 Lisp_Object
*v
, tem
;
3065 v
= alloca (size
* sizeof *v
);
3066 n
= overlays_in (start
, end
, 0, &v
, &size
, NULL
, NULL
);
3069 v
= alloca (n
* sizeof *v
);
3070 overlays_in (start
, end
, 0, &v
, &n
, NULL
, NULL
);
3073 for (i
= 0; i
< n
; ++i
)
3074 if (!EQ (v
[i
], overlay
)
3075 && (tem
= Foverlay_get (overlay
, Qmouse_face
),
3084 /* Fast function to just test if we're at an overlay boundary. */
3086 overlay_touches_p (ptrdiff_t pos
)
3088 Lisp_Object overlay
;
3089 struct Lisp_Overlay
*tail
;
3091 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
3095 XSETMISC (overlay
,tail
);
3096 eassert (OVERLAYP (overlay
));
3098 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3101 if (endpos
== pos
|| OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
)
3105 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
3109 XSETMISC (overlay
, tail
);
3110 eassert (OVERLAYP (overlay
));
3112 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3115 if (startpos
== pos
|| OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
)
3123 Lisp_Object overlay
;
3129 compare_overlays (const void *v1
, const void *v2
)
3131 const struct sortvec
*s1
= (const struct sortvec
*) v1
;
3132 const struct sortvec
*s2
= (const struct sortvec
*) v2
;
3133 if (s1
->priority
!= s2
->priority
)
3134 return s1
->priority
< s2
->priority
? -1 : 1;
3135 if (s1
->beg
!= s2
->beg
)
3136 return s1
->beg
< s2
->beg
? -1 : 1;
3137 if (s1
->end
!= s2
->end
)
3138 return s2
->end
< s1
->end
? -1 : 1;
3139 /* Avoid the non-determinism of qsort by choosing an arbitrary ordering
3140 between "equal" overlays. The result can still change between
3141 invocations of Emacs, but it won't change in the middle of
3142 `find_field' (bug#6830). */
3143 if (XHASH (s1
->overlay
) != XHASH (s2
->overlay
))
3144 return XHASH (s1
->overlay
) < XHASH (s2
->overlay
) ? -1 : 1;
3148 /* Sort an array of overlays by priority. The array is modified in place.
3149 The return value is the new size; this may be smaller than the original
3150 size if some of the overlays were invalid or were window-specific. */
3152 sort_overlays (Lisp_Object
*overlay_vec
, ptrdiff_t noverlays
, struct window
*w
)
3155 struct sortvec
*sortvec
= alloca (noverlays
* sizeof *sortvec
);
3157 /* Put the valid and relevant overlays into sortvec. */
3159 for (i
= 0, j
= 0; i
< noverlays
; i
++)
3162 Lisp_Object overlay
;
3164 overlay
= overlay_vec
[i
];
3165 if (OVERLAYP (overlay
)
3166 && OVERLAY_POSITION (OVERLAY_START (overlay
)) > 0
3167 && OVERLAY_POSITION (OVERLAY_END (overlay
)) > 0)
3169 /* If we're interested in a specific window, then ignore
3170 overlays that are limited to some other window. */
3175 window
= Foverlay_get (overlay
, Qwindow
);
3176 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3180 /* This overlay is good and counts: put it into sortvec. */
3181 sortvec
[j
].overlay
= overlay
;
3182 sortvec
[j
].beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3183 sortvec
[j
].end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3184 tem
= Foverlay_get (overlay
, Qpriority
);
3186 sortvec
[j
].priority
= XINT (tem
);
3188 sortvec
[j
].priority
= 0;
3194 /* Sort the overlays into the proper order: increasing priority. */
3197 qsort (sortvec
, noverlays
, sizeof (struct sortvec
), compare_overlays
);
3199 for (i
= 0; i
< noverlays
; i
++)
3200 overlay_vec
[i
] = sortvec
[i
].overlay
;
3206 Lisp_Object string
, string2
;
3213 struct sortstr
*buf
; /* An array that expands as needed; never freed. */
3214 ptrdiff_t size
; /* Allocated length of that array. */
3215 ptrdiff_t used
; /* How much of the array is currently in use. */
3216 ptrdiff_t bytes
; /* Total length of the strings in buf. */
3219 /* Buffers for storing information about the overlays touching a given
3220 position. These could be automatic variables in overlay_strings, but
3221 it's more efficient to hold onto the memory instead of repeatedly
3222 allocating and freeing it. */
3223 static struct sortstrlist overlay_heads
, overlay_tails
;
3224 static unsigned char *overlay_str_buf
;
3226 /* Allocated length of overlay_str_buf. */
3227 static ptrdiff_t overlay_str_len
;
3229 /* A comparison function suitable for passing to qsort. */
3231 cmp_for_strings (const void *as1
, const void *as2
)
3233 struct sortstr
*s1
= (struct sortstr
*)as1
;
3234 struct sortstr
*s2
= (struct sortstr
*)as2
;
3235 if (s1
->size
!= s2
->size
)
3236 return s2
->size
< s1
->size
? -1 : 1;
3237 if (s1
->priority
!= s2
->priority
)
3238 return s1
->priority
< s2
->priority
? -1 : 1;
3243 record_overlay_string (struct sortstrlist
*ssl
, Lisp_Object str
,
3244 Lisp_Object str2
, Lisp_Object pri
, ptrdiff_t size
)
3248 if (ssl
->used
== ssl
->size
)
3249 ssl
->buf
= xpalloc (ssl
->buf
, &ssl
->size
, 5, -1, sizeof *ssl
->buf
);
3250 ssl
->buf
[ssl
->used
].string
= str
;
3251 ssl
->buf
[ssl
->used
].string2
= str2
;
3252 ssl
->buf
[ssl
->used
].size
= size
;
3253 ssl
->buf
[ssl
->used
].priority
= (INTEGERP (pri
) ? XINT (pri
) : 0);
3256 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3257 nbytes
= SCHARS (str
);
3258 else if (! STRING_MULTIBYTE (str
))
3259 nbytes
= count_size_as_multibyte (SDATA (str
),
3262 nbytes
= SBYTES (str
);
3264 if (INT_ADD_OVERFLOW (ssl
->bytes
, nbytes
))
3265 memory_full (SIZE_MAX
);
3266 ssl
->bytes
+= nbytes
;
3270 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3271 nbytes
= SCHARS (str2
);
3272 else if (! STRING_MULTIBYTE (str2
))
3273 nbytes
= count_size_as_multibyte (SDATA (str2
),
3276 nbytes
= SBYTES (str2
);
3278 if (INT_ADD_OVERFLOW (ssl
->bytes
, nbytes
))
3279 memory_full (SIZE_MAX
);
3280 ssl
->bytes
+= nbytes
;
3284 /* Return the concatenation of the strings associated with overlays that
3285 begin or end at POS, ignoring overlays that are specific to a window
3286 other than W. The strings are concatenated in the appropriate order:
3287 shorter overlays nest inside longer ones, and higher priority inside
3288 lower. Normally all of the after-strings come first, but zero-sized
3289 overlays have their after-strings ride along with the before-strings
3290 because it would look strange to print them inside-out.
3292 Returns the string length, and stores the contents indirectly through
3293 PSTR, if that variable is non-null. The string may be overwritten by
3294 subsequent calls. */
3297 overlay_strings (ptrdiff_t pos
, struct window
*w
, unsigned char **pstr
)
3299 Lisp_Object overlay
, window
, str
;
3300 struct Lisp_Overlay
*ov
;
3301 ptrdiff_t startpos
, endpos
;
3302 bool multibyte
= ! NILP (BVAR (current_buffer
, enable_multibyte_characters
));
3304 overlay_heads
.used
= overlay_heads
.bytes
= 0;
3305 overlay_tails
.used
= overlay_tails
.bytes
= 0;
3306 for (ov
= current_buffer
->overlays_before
; ov
; ov
= ov
->next
)
3308 XSETMISC (overlay
, ov
);
3309 eassert (OVERLAYP (overlay
));
3311 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3312 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3315 if (endpos
!= pos
&& startpos
!= pos
)
3317 window
= Foverlay_get (overlay
, Qwindow
);
3318 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3321 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3322 record_overlay_string (&overlay_heads
, str
,
3324 ? Foverlay_get (overlay
, Qafter_string
)
3326 Foverlay_get (overlay
, Qpriority
),
3328 else if (endpos
== pos
3329 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3330 record_overlay_string (&overlay_tails
, str
, Qnil
,
3331 Foverlay_get (overlay
, Qpriority
),
3334 for (ov
= current_buffer
->overlays_after
; ov
; ov
= ov
->next
)
3336 XSETMISC (overlay
, ov
);
3337 eassert (OVERLAYP (overlay
));
3339 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3340 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3343 if (endpos
!= pos
&& startpos
!= pos
)
3345 window
= Foverlay_get (overlay
, Qwindow
);
3346 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3349 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3350 record_overlay_string (&overlay_heads
, str
,
3352 ? Foverlay_get (overlay
, Qafter_string
)
3354 Foverlay_get (overlay
, Qpriority
),
3356 else if (endpos
== pos
3357 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3358 record_overlay_string (&overlay_tails
, str
, Qnil
,
3359 Foverlay_get (overlay
, Qpriority
),
3362 if (overlay_tails
.used
> 1)
3363 qsort (overlay_tails
.buf
, overlay_tails
.used
, sizeof (struct sortstr
),
3365 if (overlay_heads
.used
> 1)
3366 qsort (overlay_heads
.buf
, overlay_heads
.used
, sizeof (struct sortstr
),
3368 if (overlay_heads
.bytes
|| overlay_tails
.bytes
)
3375 if (INT_ADD_OVERFLOW (overlay_heads
.bytes
, overlay_tails
.bytes
))
3376 memory_full (SIZE_MAX
);
3377 total
= overlay_heads
.bytes
+ overlay_tails
.bytes
;
3378 if (total
> overlay_str_len
)
3379 overlay_str_buf
= xpalloc (overlay_str_buf
, &overlay_str_len
,
3380 total
- overlay_str_len
, -1, 1);
3382 p
= overlay_str_buf
;
3383 for (i
= overlay_tails
.used
; --i
>= 0;)
3386 tem
= overlay_tails
.buf
[i
].string
;
3387 nbytes
= copy_text (SDATA (tem
), p
,
3389 STRING_MULTIBYTE (tem
), multibyte
);
3392 for (i
= 0; i
< overlay_heads
.used
; ++i
)
3395 tem
= overlay_heads
.buf
[i
].string
;
3396 nbytes
= copy_text (SDATA (tem
), p
,
3398 STRING_MULTIBYTE (tem
), multibyte
);
3400 tem
= overlay_heads
.buf
[i
].string2
;
3403 nbytes
= copy_text (SDATA (tem
), p
,
3405 STRING_MULTIBYTE (tem
), multibyte
);
3409 if (p
!= overlay_str_buf
+ total
)
3412 *pstr
= overlay_str_buf
;
3418 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
3421 recenter_overlay_lists (struct buffer
*buf
, ptrdiff_t pos
)
3423 Lisp_Object overlay
, beg
, end
;
3424 struct Lisp_Overlay
*prev
, *tail
, *next
;
3426 /* See if anything in overlays_before should move to overlays_after. */
3428 /* We don't strictly need prev in this loop; it should always be nil.
3429 But we use it for symmetry and in case that should cease to be true
3430 with some future change. */
3432 for (tail
= buf
->overlays_before
; tail
; prev
= tail
, tail
= next
)
3435 XSETMISC (overlay
, tail
);
3436 eassert (OVERLAYP (overlay
));
3438 beg
= OVERLAY_START (overlay
);
3439 end
= OVERLAY_END (overlay
);
3441 if (OVERLAY_POSITION (end
) > pos
)
3443 /* OVERLAY needs to be moved. */
3444 ptrdiff_t where
= OVERLAY_POSITION (beg
);
3445 struct Lisp_Overlay
*other
, *other_prev
;
3447 /* Splice the cons cell TAIL out of overlays_before. */
3451 set_buffer_overlays_before (buf
, next
);
3453 /* Search thru overlays_after for where to put it. */
3455 for (other
= buf
->overlays_after
; other
;
3456 other_prev
= other
, other
= other
->next
)
3458 Lisp_Object otherbeg
, otheroverlay
;
3460 XSETMISC (otheroverlay
, other
);
3461 eassert (OVERLAYP (otheroverlay
));
3463 otherbeg
= OVERLAY_START (otheroverlay
);
3464 if (OVERLAY_POSITION (otherbeg
) >= where
)
3468 /* Add TAIL to overlays_after before OTHER. */
3471 other_prev
->next
= tail
;
3473 set_buffer_overlays_after (buf
, tail
);
3477 /* We've reached the things that should stay in overlays_before.
3478 All the rest of overlays_before must end even earlier,
3483 /* See if anything in overlays_after should be in overlays_before. */
3485 for (tail
= buf
->overlays_after
; tail
; prev
= tail
, tail
= next
)
3488 XSETMISC (overlay
, tail
);
3489 eassert (OVERLAYP (overlay
));
3491 beg
= OVERLAY_START (overlay
);
3492 end
= OVERLAY_END (overlay
);
3494 /* Stop looking, when we know that nothing further
3495 can possibly end before POS. */
3496 if (OVERLAY_POSITION (beg
) > pos
)
3499 if (OVERLAY_POSITION (end
) <= pos
)
3501 /* OVERLAY needs to be moved. */
3502 ptrdiff_t where
= OVERLAY_POSITION (end
);
3503 struct Lisp_Overlay
*other
, *other_prev
;
3505 /* Splice the cons cell TAIL out of overlays_after. */
3509 set_buffer_overlays_after (buf
, next
);
3511 /* Search thru overlays_before for where to put it. */
3513 for (other
= buf
->overlays_before
; other
;
3514 other_prev
= other
, other
= other
->next
)
3516 Lisp_Object otherend
, otheroverlay
;
3518 XSETMISC (otheroverlay
, other
);
3519 eassert (OVERLAYP (otheroverlay
));
3521 otherend
= OVERLAY_END (otheroverlay
);
3522 if (OVERLAY_POSITION (otherend
) <= where
)
3526 /* Add TAIL to overlays_before before OTHER. */
3529 other_prev
->next
= tail
;
3531 set_buffer_overlays_before (buf
, tail
);
3536 buf
->overlay_center
= pos
;
3540 adjust_overlays_for_insert (ptrdiff_t pos
, ptrdiff_t length
)
3542 /* After an insertion, the lists are still sorted properly,
3543 but we may need to update the value of the overlay center. */
3544 if (current_buffer
->overlay_center
>= pos
)
3545 current_buffer
->overlay_center
+= length
;
3549 adjust_overlays_for_delete (ptrdiff_t pos
, ptrdiff_t length
)
3551 if (current_buffer
->overlay_center
< pos
)
3552 /* The deletion was to our right. No change needed; the before- and
3553 after-lists are still consistent. */
3555 else if (current_buffer
->overlay_center
- pos
> length
)
3556 /* The deletion was to our left. We need to adjust the center value
3557 to account for the change in position, but the lists are consistent
3558 given the new value. */
3559 current_buffer
->overlay_center
-= length
;
3561 /* We're right in the middle. There might be things on the after-list
3562 that now belong on the before-list. Recentering will move them,
3563 and also update the center point. */
3564 recenter_overlay_lists (current_buffer
, pos
);
3567 /* Fix up overlays that were garbled as a result of permuting markers
3568 in the range START through END. Any overlay with at least one
3569 endpoint in this range will need to be unlinked from the overlay
3570 list and reinserted in its proper place.
3571 Such an overlay might even have negative size at this point.
3572 If so, we'll make the overlay empty. */
3574 fix_start_end_in_overlays (register ptrdiff_t start
, register ptrdiff_t end
)
3576 Lisp_Object overlay
;
3577 struct Lisp_Overlay
*before_list
IF_LINT (= NULL
);
3578 struct Lisp_Overlay
*after_list
IF_LINT (= NULL
);
3579 /* These are either nil, indicating that before_list or after_list
3580 should be assigned, or the cons cell the cdr of which should be
3582 struct Lisp_Overlay
*beforep
= NULL
, *afterp
= NULL
;
3583 /* 'Parent', likewise, indicates a cons cell or
3584 current_buffer->overlays_before or overlays_after, depending
3585 which loop we're in. */
3586 struct Lisp_Overlay
*tail
, *parent
;
3587 ptrdiff_t startpos
, endpos
;
3589 /* This algorithm shifts links around instead of consing and GCing.
3590 The loop invariant is that before_list (resp. after_list) is a
3591 well-formed list except that its last element, the CDR of beforep
3592 (resp. afterp) if beforep (afterp) isn't nil or before_list
3593 (after_list) if it is, is still uninitialized. So it's not a bug
3594 that before_list isn't initialized, although it may look
3596 for (parent
= NULL
, tail
= current_buffer
->overlays_before
; tail
;)
3598 XSETMISC (overlay
, tail
);
3600 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3601 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3603 /* If the overlay is backwards, make it empty. */
3604 if (endpos
< startpos
)
3607 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3615 || (startpos
>= start
&& startpos
< end
))
3617 /* Add it to the end of the wrong list. Later on,
3618 recenter_overlay_lists will move it to the right place. */
3619 if (endpos
< current_buffer
->overlay_center
)
3624 afterp
->next
= tail
;
3632 beforep
->next
= tail
;
3636 set_buffer_overlays_before (current_buffer
, tail
->next
);
3638 parent
->next
= tail
->next
;
3642 parent
= tail
, tail
= parent
->next
;
3644 for (parent
= NULL
, tail
= current_buffer
->overlays_after
; tail
;)
3646 XSETMISC (overlay
, tail
);
3648 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3649 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3651 /* If the overlay is backwards, make it empty. */
3652 if (endpos
< startpos
)
3655 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3659 if (startpos
>= end
)
3662 if (startpos
>= start
3663 || (endpos
>= start
&& endpos
< end
))
3665 if (endpos
< current_buffer
->overlay_center
)
3670 afterp
->next
= tail
;
3678 beforep
->next
= tail
;
3682 set_buffer_overlays_after (current_buffer
, tail
->next
);
3684 parent
->next
= tail
->next
;
3688 parent
= tail
, tail
= parent
->next
;
3691 /* Splice the constructed (wrong) lists into the buffer's lists,
3692 and let the recenter function make it sane again. */
3695 beforep
->next
= current_buffer
->overlays_before
;
3696 set_buffer_overlays_before (current_buffer
, before_list
);
3701 afterp
->next
= current_buffer
->overlays_after
;
3702 set_buffer_overlays_after (current_buffer
, after_list
);
3704 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3707 /* We have two types of overlay: the one whose ending marker is
3708 after-insertion-marker (this is the usual case) and the one whose
3709 ending marker is before-insertion-marker. When `overlays_before'
3710 contains overlays of the latter type and the former type in this
3711 order and both overlays end at inserting position, inserting a text
3712 increases only the ending marker of the latter type, which results
3713 in incorrect ordering of `overlays_before'.
3715 This function fixes ordering of overlays in the slot
3716 `overlays_before' of the buffer *BP. Before the insertion, `point'
3717 was at PREV, and now is at POS. */
3720 fix_overlays_before (struct buffer
*bp
, ptrdiff_t prev
, ptrdiff_t pos
)
3722 /* If parent is nil, replace overlays_before; otherwise, parent->next. */
3723 struct Lisp_Overlay
*tail
= bp
->overlays_before
, *parent
= NULL
, *right_pair
;
3725 ptrdiff_t end
IF_LINT (= 0);
3727 /* After the insertion, the several overlays may be in incorrect
3728 order. The possibility is that, in the list `overlays_before',
3729 an overlay which ends at POS appears after an overlay which ends
3730 at PREV. Since POS is greater than PREV, we must fix the
3731 ordering of these overlays, by moving overlays ends at POS before
3732 the overlays ends at PREV. */
3734 /* At first, find a place where disordered overlays should be linked
3735 in. It is where an overlay which end before POS exists. (i.e. an
3736 overlay whose ending marker is after-insertion-marker if disorder
3739 && (XSETMISC (tem
, tail
),
3740 (end
= OVERLAY_POSITION (OVERLAY_END (tem
))) >= pos
))
3746 /* If we don't find such an overlay,
3747 or the found one ends before PREV,
3748 or the found one is the last one in the list,
3749 we don't have to fix anything. */
3750 if (!tail
|| end
< prev
|| !tail
->next
)
3753 right_pair
= parent
;
3757 /* Now, end position of overlays in the list TAIL should be before
3758 or equal to PREV. In the loop, an overlay which ends at POS is
3759 moved ahead to the place indicated by the CDR of RIGHT_PAIR. If
3760 we found an overlay which ends before PREV, the remaining
3761 overlays are in correct order. */
3764 XSETMISC (tem
, tail
);
3765 end
= OVERLAY_POSITION (OVERLAY_END (tem
));
3768 { /* This overlay is disordered. */
3769 struct Lisp_Overlay
*found
= tail
;
3771 /* Unlink the found overlay. */
3773 parent
->next
= tail
;
3774 /* Move an overlay at RIGHT_PLACE to the next of the found one,
3775 and link it into the right place. */
3778 found
->next
= bp
->overlays_before
;
3779 set_buffer_overlays_before (bp
, found
);
3783 found
->next
= right_pair
->next
;
3784 right_pair
->next
= found
;
3787 else if (end
== prev
)
3792 else /* No more disordered overlay. */
3797 DEFUN ("overlayp", Foverlayp
, Soverlayp
, 1, 1, 0,
3798 doc
: /* Return t if OBJECT is an overlay. */)
3799 (Lisp_Object object
)
3801 return (OVERLAYP (object
) ? Qt
: Qnil
);
3804 DEFUN ("make-overlay", Fmake_overlay
, Smake_overlay
, 2, 5, 0,
3805 doc
: /* Create a new overlay with range BEG to END in BUFFER.
3806 If omitted, BUFFER defaults to the current buffer.
3807 BEG and END may be integers or markers.
3808 The fourth arg FRONT-ADVANCE, if non-nil, makes the marker
3809 for the front of the overlay advance when text is inserted there
3810 \(which means the text *is not* included in the overlay).
3811 The fifth arg REAR-ADVANCE, if non-nil, makes the marker
3812 for the rear of the overlay advance when text is inserted there
3813 \(which means the text *is* included in the overlay). */)
3814 (Lisp_Object beg
, Lisp_Object end
, Lisp_Object buffer
, Lisp_Object front_advance
, Lisp_Object rear_advance
)
3816 Lisp_Object overlay
;
3820 XSETBUFFER (buffer
, current_buffer
);
3822 CHECK_BUFFER (buffer
);
3824 && ! EQ (Fmarker_buffer (beg
), buffer
))
3825 error ("Marker points into wrong buffer");
3827 && ! EQ (Fmarker_buffer (end
), buffer
))
3828 error ("Marker points into wrong buffer");
3830 CHECK_NUMBER_COERCE_MARKER (beg
);
3831 CHECK_NUMBER_COERCE_MARKER (end
);
3833 if (XINT (beg
) > XINT (end
))
3836 temp
= beg
; beg
= end
; end
= temp
;
3839 b
= XBUFFER (buffer
);
3841 beg
= Fset_marker (Fmake_marker (), beg
, buffer
);
3842 end
= Fset_marker (Fmake_marker (), end
, buffer
);
3844 if (!NILP (front_advance
))
3845 XMARKER (beg
)->insertion_type
= 1;
3846 if (!NILP (rear_advance
))
3847 XMARKER (end
)->insertion_type
= 1;
3849 overlay
= build_overlay (beg
, end
, Qnil
);
3851 /* Put the new overlay on the wrong list. */
3852 end
= OVERLAY_END (overlay
);
3853 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
3855 eassert (b
->overlays_after
|| (XOVERLAY (overlay
)->next
== NULL
));
3856 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3857 set_buffer_overlays_after (b
, XOVERLAY (overlay
));
3861 eassert (b
->overlays_before
|| (XOVERLAY (overlay
)->next
== NULL
));
3862 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3863 set_buffer_overlays_before (b
, XOVERLAY (overlay
));
3865 /* This puts it in the right list, and in the right order. */
3866 recenter_overlay_lists (b
, b
->overlay_center
);
3868 /* We don't need to redisplay the region covered by the overlay, because
3869 the overlay has no properties at the moment. */
3874 /* Mark a section of BUF as needing redisplay because of overlays changes. */
3877 modify_overlay (struct buffer
*buf
, ptrdiff_t start
, ptrdiff_t end
)
3881 ptrdiff_t temp
= start
;
3886 BUF_COMPUTE_UNCHANGED (buf
, start
, end
);
3888 /* If this is a buffer not in the selected window,
3889 we must do other windows. */
3890 if (buf
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
3891 windows_or_buffers_changed
= 1;
3892 /* If multiple windows show this buffer, we must do other windows. */
3893 else if (buffer_shared
> 1)
3894 windows_or_buffers_changed
= 1;
3895 /* If we modify an overlay at the end of the buffer, we cannot
3896 be sure that window end is still valid. */
3897 else if (end
>= ZV
&& start
<= ZV
)
3898 windows_or_buffers_changed
= 1;
3900 ++BUF_OVERLAY_MODIFF (buf
);
3903 /* Remove OVERLAY from LIST. */
3905 static struct Lisp_Overlay
*
3906 unchain_overlay (struct Lisp_Overlay
*list
, struct Lisp_Overlay
*overlay
)
3908 register struct Lisp_Overlay
*tail
, **prev
= &list
;
3910 for (tail
= list
; tail
; prev
= &tail
->next
, tail
= *prev
)
3911 if (tail
== overlay
)
3913 *prev
= overlay
->next
;
3914 overlay
->next
= NULL
;
3920 /* Remove OVERLAY from both overlay lists of B. */
3923 unchain_both (struct buffer
*b
, Lisp_Object overlay
)
3925 struct Lisp_Overlay
*ov
= XOVERLAY (overlay
);
3927 set_buffer_overlays_before (b
, unchain_overlay (b
->overlays_before
, ov
));
3928 set_buffer_overlays_after (b
, unchain_overlay (b
->overlays_after
, ov
));
3929 eassert (XOVERLAY (overlay
)->next
== NULL
);
3932 DEFUN ("move-overlay", Fmove_overlay
, Smove_overlay
, 3, 4, 0,
3933 doc
: /* Set the endpoints of OVERLAY to BEG and END in BUFFER.
3934 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.
3935 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current
3937 (Lisp_Object overlay
, Lisp_Object beg
, Lisp_Object end
, Lisp_Object buffer
)
3939 struct buffer
*b
, *ob
= 0;
3940 Lisp_Object obuffer
;
3941 ptrdiff_t count
= SPECPDL_INDEX ();
3942 ptrdiff_t n_beg
, n_end
, o_beg
IF_LINT (= 0), o_end
IF_LINT (= 0);
3944 CHECK_OVERLAY (overlay
);
3946 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3948 XSETBUFFER (buffer
, current_buffer
);
3949 CHECK_BUFFER (buffer
);
3951 if (NILP (Fbuffer_live_p (buffer
)))
3952 error ("Attempt to move overlay to a dead buffer");
3955 && ! EQ (Fmarker_buffer (beg
), buffer
))
3956 error ("Marker points into wrong buffer");
3958 && ! EQ (Fmarker_buffer (end
), buffer
))
3959 error ("Marker points into wrong buffer");
3961 CHECK_NUMBER_COERCE_MARKER (beg
);
3962 CHECK_NUMBER_COERCE_MARKER (end
);
3964 if (XINT (beg
) > XINT (end
))
3967 temp
= beg
; beg
= end
; end
= temp
;
3970 specbind (Qinhibit_quit
, Qt
);
3972 obuffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3973 b
= XBUFFER (buffer
);
3975 if (!NILP (obuffer
))
3977 ob
= XBUFFER (obuffer
);
3979 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3980 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3982 unchain_both (ob
, overlay
);
3985 /* Set the overlay boundaries, which may clip them. */
3986 Fset_marker (OVERLAY_START (overlay
), beg
, buffer
);
3987 Fset_marker (OVERLAY_END (overlay
), end
, buffer
);
3989 n_beg
= marker_position (OVERLAY_START (overlay
));
3990 n_end
= marker_position (OVERLAY_END (overlay
));
3992 /* If the overlay has changed buffers, do a thorough redisplay. */
3993 if (!EQ (buffer
, obuffer
))
3995 /* Redisplay where the overlay was. */
3997 modify_overlay (ob
, o_beg
, o_end
);
3999 /* Redisplay where the overlay is going to be. */
4000 modify_overlay (b
, n_beg
, n_end
);
4003 /* Redisplay the area the overlay has just left, or just enclosed. */
4006 modify_overlay (b
, o_end
, n_end
);
4007 else if (o_end
== n_end
)
4008 modify_overlay (b
, o_beg
, n_beg
);
4010 modify_overlay (b
, min (o_beg
, n_beg
), max (o_end
, n_end
));
4013 /* Delete the overlay if it is empty after clipping and has the
4014 evaporate property. */
4015 if (n_beg
== n_end
&& !NILP (Foverlay_get (overlay
, Qevaporate
)))
4016 return unbind_to (count
, Fdelete_overlay (overlay
));
4018 /* Put the overlay into the new buffer's overlay lists, first on the
4020 if (n_end
< b
->overlay_center
)
4022 XOVERLAY (overlay
)->next
= b
->overlays_after
;
4023 set_buffer_overlays_after (b
, XOVERLAY (overlay
));
4027 XOVERLAY (overlay
)->next
= b
->overlays_before
;
4028 set_buffer_overlays_before (b
, XOVERLAY (overlay
));
4031 /* This puts it in the right list, and in the right order. */
4032 recenter_overlay_lists (b
, b
->overlay_center
);
4034 return unbind_to (count
, overlay
);
4037 DEFUN ("delete-overlay", Fdelete_overlay
, Sdelete_overlay
, 1, 1, 0,
4038 doc
: /* Delete the overlay OVERLAY from its buffer. */)
4039 (Lisp_Object overlay
)
4043 ptrdiff_t count
= SPECPDL_INDEX ();
4045 CHECK_OVERLAY (overlay
);
4047 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4051 b
= XBUFFER (buffer
);
4052 specbind (Qinhibit_quit
, Qt
);
4054 unchain_both (b
, overlay
);
4055 drop_overlay (b
, XOVERLAY (overlay
));
4057 /* When deleting an overlay with before or after strings, turn off
4058 display optimizations for the affected buffer, on the basis that
4059 these strings may contain newlines. This is easier to do than to
4060 check for that situation during redisplay. */
4061 if (!windows_or_buffers_changed
4062 && (!NILP (Foverlay_get (overlay
, Qbefore_string
))
4063 || !NILP (Foverlay_get (overlay
, Qafter_string
))))
4064 b
->prevent_redisplay_optimizations_p
= 1;
4066 return unbind_to (count
, Qnil
);
4069 DEFUN ("delete-all-overlays", Fdelete_all_overlays
, Sdelete_all_overlays
, 0, 1, 0,
4070 doc
: /* Delete all overlays of BUFFER.
4071 BUFFER omitted or nil means delete all overlays of the current
4073 (Lisp_Object buffer
)
4075 register struct buffer
*buf
;
4078 buf
= current_buffer
;
4081 CHECK_BUFFER (buffer
);
4082 buf
= XBUFFER (buffer
);
4085 delete_all_overlays (buf
);
4089 /* Overlay dissection functions. */
4091 DEFUN ("overlay-start", Foverlay_start
, Soverlay_start
, 1, 1, 0,
4092 doc
: /* Return the position at which OVERLAY starts. */)
4093 (Lisp_Object overlay
)
4095 CHECK_OVERLAY (overlay
);
4097 return (Fmarker_position (OVERLAY_START (overlay
)));
4100 DEFUN ("overlay-end", Foverlay_end
, Soverlay_end
, 1, 1, 0,
4101 doc
: /* Return the position at which OVERLAY ends. */)
4102 (Lisp_Object overlay
)
4104 CHECK_OVERLAY (overlay
);
4106 return (Fmarker_position (OVERLAY_END (overlay
)));
4109 DEFUN ("overlay-buffer", Foverlay_buffer
, Soverlay_buffer
, 1, 1, 0,
4110 doc
: /* Return the buffer OVERLAY belongs to.
4111 Return nil if OVERLAY has been deleted. */)
4112 (Lisp_Object overlay
)
4114 CHECK_OVERLAY (overlay
);
4116 return Fmarker_buffer (OVERLAY_START (overlay
));
4119 DEFUN ("overlay-properties", Foverlay_properties
, Soverlay_properties
, 1, 1, 0,
4120 doc
: /* Return a list of the properties on OVERLAY.
4121 This is a copy of OVERLAY's plist; modifying its conses has no effect on
4123 (Lisp_Object overlay
)
4125 CHECK_OVERLAY (overlay
);
4127 return Fcopy_sequence (XOVERLAY (overlay
)->plist
);
4131 DEFUN ("overlays-at", Foverlays_at
, Soverlays_at
, 1, 1, 0,
4132 doc
: /* Return a list of the overlays that contain the character at POS. */)
4135 ptrdiff_t len
, noverlays
;
4136 Lisp_Object
*overlay_vec
;
4139 CHECK_NUMBER_COERCE_MARKER (pos
);
4142 /* We can't use alloca here because overlays_at can call xrealloc. */
4143 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4145 /* Put all the overlays we want in a vector in overlay_vec.
4146 Store the length in len. */
4147 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4150 /* Make a list of them all. */
4151 result
= Flist (noverlays
, overlay_vec
);
4153 xfree (overlay_vec
);
4157 DEFUN ("overlays-in", Foverlays_in
, Soverlays_in
, 2, 2, 0,
4158 doc
: /* Return a list of the overlays that overlap the region BEG ... END.
4159 Overlap means that at least one character is contained within the overlay
4160 and also contained within the specified region.
4161 Empty overlays are included in the result if they are located at BEG,
4162 between BEG and END, or at END provided END denotes the position at the
4163 end of the buffer. */)
4164 (Lisp_Object beg
, Lisp_Object end
)
4166 ptrdiff_t len
, noverlays
;
4167 Lisp_Object
*overlay_vec
;
4170 CHECK_NUMBER_COERCE_MARKER (beg
);
4171 CHECK_NUMBER_COERCE_MARKER (end
);
4174 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4176 /* Put all the overlays we want in a vector in overlay_vec.
4177 Store the length in len. */
4178 noverlays
= overlays_in (XINT (beg
), XINT (end
), 1, &overlay_vec
, &len
,
4181 /* Make a list of them all. */
4182 result
= Flist (noverlays
, overlay_vec
);
4184 xfree (overlay_vec
);
4188 DEFUN ("next-overlay-change", Fnext_overlay_change
, Snext_overlay_change
,
4190 doc
: /* Return the next position after POS where an overlay starts or ends.
4191 If there are no overlay boundaries from POS to (point-max),
4192 the value is (point-max). */)
4195 ptrdiff_t i
, len
, noverlays
;
4197 Lisp_Object
*overlay_vec
;
4199 CHECK_NUMBER_COERCE_MARKER (pos
);
4202 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4204 /* Put all the overlays we want in a vector in overlay_vec.
4205 Store the length in len.
4206 endpos gets the position where the next overlay starts. */
4207 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4210 /* If any of these overlays ends before endpos,
4211 use its ending point instead. */
4212 for (i
= 0; i
< noverlays
; i
++)
4217 oend
= OVERLAY_END (overlay_vec
[i
]);
4218 oendpos
= OVERLAY_POSITION (oend
);
4219 if (oendpos
< endpos
)
4223 xfree (overlay_vec
);
4224 return make_number (endpos
);
4227 DEFUN ("previous-overlay-change", Fprevious_overlay_change
,
4228 Sprevious_overlay_change
, 1, 1, 0,
4229 doc
: /* Return the previous position before POS where an overlay starts or ends.
4230 If there are no overlay boundaries from (point-min) to POS,
4231 the value is (point-min). */)
4235 Lisp_Object
*overlay_vec
;
4238 CHECK_NUMBER_COERCE_MARKER (pos
);
4240 /* At beginning of buffer, we know the answer;
4241 avoid bug subtracting 1 below. */
4242 if (XINT (pos
) == BEGV
)
4246 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4248 /* Put all the overlays we want in a vector in overlay_vec.
4249 Store the length in len.
4250 prevpos gets the position of the previous change. */
4251 overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4254 xfree (overlay_vec
);
4255 return make_number (prevpos
);
4258 /* These functions are for debugging overlays. */
4260 DEFUN ("overlay-lists", Foverlay_lists
, Soverlay_lists
, 0, 0, 0,
4261 doc
: /* Return a pair of lists giving all the overlays of the current buffer.
4262 The car has all the overlays before the overlay center;
4263 the cdr has all the overlays after the overlay center.
4264 Recentering overlays moves overlays between these lists.
4265 The lists you get are copies, so that changing them has no effect.
4266 However, the overlays you get are the real objects that the buffer uses. */)
4269 struct Lisp_Overlay
*ol
;
4270 Lisp_Object before
= Qnil
, after
= Qnil
, tmp
;
4272 for (ol
= current_buffer
->overlays_before
; ol
; ol
= ol
->next
)
4275 before
= Fcons (tmp
, before
);
4277 for (ol
= current_buffer
->overlays_after
; ol
; ol
= ol
->next
)
4280 after
= Fcons (tmp
, after
);
4283 return Fcons (Fnreverse (before
), Fnreverse (after
));
4286 DEFUN ("overlay-recenter", Foverlay_recenter
, Soverlay_recenter
, 1, 1, 0,
4287 doc
: /* Recenter the overlays of the current buffer around position POS.
4288 That makes overlay lookup faster for positions near POS (but perhaps slower
4289 for positions far away from POS). */)
4293 CHECK_NUMBER_COERCE_MARKER (pos
);
4295 p
= clip_to_bounds (PTRDIFF_MIN
, XINT (pos
), PTRDIFF_MAX
);
4296 recenter_overlay_lists (current_buffer
, p
);
4300 DEFUN ("overlay-get", Foverlay_get
, Soverlay_get
, 2, 2, 0,
4301 doc
: /* Get the property of overlay OVERLAY with property name PROP. */)
4302 (Lisp_Object overlay
, Lisp_Object prop
)
4304 CHECK_OVERLAY (overlay
);
4305 return lookup_char_property (XOVERLAY (overlay
)->plist
, prop
, 0);
4308 DEFUN ("overlay-put", Foverlay_put
, Soverlay_put
, 3, 3, 0,
4309 doc
: /* Set one property of overlay OVERLAY: give property PROP value VALUE.
4310 VALUE will be returned.*/)
4311 (Lisp_Object overlay
, Lisp_Object prop
, Lisp_Object value
)
4313 Lisp_Object tail
, buffer
;
4316 CHECK_OVERLAY (overlay
);
4318 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4320 for (tail
= XOVERLAY (overlay
)->plist
;
4321 CONSP (tail
) && CONSP (XCDR (tail
));
4322 tail
= XCDR (XCDR (tail
)))
4323 if (EQ (XCAR (tail
), prop
))
4325 changed
= !EQ (XCAR (XCDR (tail
)), value
);
4326 XSETCAR (XCDR (tail
), value
);
4329 /* It wasn't in the list, so add it to the front. */
4330 changed
= !NILP (value
);
4332 (overlay
, Fcons (prop
, Fcons (value
, XOVERLAY (overlay
)->plist
)));
4334 if (! NILP (buffer
))
4337 modify_overlay (XBUFFER (buffer
),
4338 marker_position (OVERLAY_START (overlay
)),
4339 marker_position (OVERLAY_END (overlay
)));
4340 if (EQ (prop
, Qevaporate
) && ! NILP (value
)
4341 && (OVERLAY_POSITION (OVERLAY_START (overlay
))
4342 == OVERLAY_POSITION (OVERLAY_END (overlay
))))
4343 Fdelete_overlay (overlay
);
4349 /* Subroutine of report_overlay_modification. */
4351 /* Lisp vector holding overlay hook functions to call.
4352 Vector elements come in pairs.
4353 Each even-index element is a list of hook functions.
4354 The following odd-index element is the overlay they came from.
4356 Before the buffer change, we fill in this vector
4357 as we call overlay hook functions.
4358 After the buffer change, we get the functions to call from this vector.
4359 This way we always call the same functions before and after the change. */
4360 static Lisp_Object last_overlay_modification_hooks
;
4362 /* Number of elements actually used in last_overlay_modification_hooks. */
4363 static ptrdiff_t last_overlay_modification_hooks_used
;
4365 /* Add one functionlist/overlay pair
4366 to the end of last_overlay_modification_hooks. */
4369 add_overlay_mod_hooklist (Lisp_Object functionlist
, Lisp_Object overlay
)
4371 ptrdiff_t oldsize
= ASIZE (last_overlay_modification_hooks
);
4373 if (oldsize
- 1 <= last_overlay_modification_hooks_used
)
4374 last_overlay_modification_hooks
=
4375 larger_vector (last_overlay_modification_hooks
, 2, -1);
4376 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4377 functionlist
); last_overlay_modification_hooks_used
++;
4378 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4379 overlay
); last_overlay_modification_hooks_used
++;
4382 /* Run the modification-hooks of overlays that include
4383 any part of the text in START to END.
4384 If this change is an insertion, also
4385 run the insert-before-hooks of overlay starting at END,
4386 and the insert-after-hooks of overlay ending at START.
4388 This is called both before and after the modification.
4389 AFTER is true when we call after the modification.
4391 ARG1, ARG2, ARG3 are arguments to pass to the hook functions.
4392 When AFTER is nonzero, they are the start position,
4393 the position after the inserted new text,
4394 and the length of deleted or replaced old text. */
4397 report_overlay_modification (Lisp_Object start
, Lisp_Object end
, bool after
,
4398 Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
)
4400 Lisp_Object prop
, overlay
;
4401 struct Lisp_Overlay
*tail
;
4402 /* True if this change is an insertion. */
4403 bool insertion
= (after
? XFASTINT (arg3
) == 0 : EQ (start
, end
));
4404 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4409 /* We used to run the functions as soon as we found them and only register
4410 them in last_overlay_modification_hooks for the purpose of the `after'
4411 case. But running elisp code as we traverse the list of overlays is
4412 painful because the list can be modified by the elisp code so we had to
4413 copy at several places. We now simply do a read-only traversal that
4414 only collects the functions to run and we run them afterwards. It's
4415 simpler, especially since all the code was already there. -stef */
4419 /* We are being called before a change.
4420 Scan the overlays to find the functions to call. */
4421 last_overlay_modification_hooks_used
= 0;
4422 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4424 ptrdiff_t startpos
, endpos
;
4425 Lisp_Object ostart
, oend
;
4427 XSETMISC (overlay
, tail
);
4429 ostart
= OVERLAY_START (overlay
);
4430 oend
= OVERLAY_END (overlay
);
4431 endpos
= OVERLAY_POSITION (oend
);
4432 if (XFASTINT (start
) > endpos
)
4434 startpos
= OVERLAY_POSITION (ostart
);
4435 if (insertion
&& (XFASTINT (start
) == startpos
4436 || XFASTINT (end
) == startpos
))
4438 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4440 add_overlay_mod_hooklist (prop
, overlay
);
4442 if (insertion
&& (XFASTINT (start
) == endpos
4443 || XFASTINT (end
) == endpos
))
4445 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4447 add_overlay_mod_hooklist (prop
, overlay
);
4449 /* Test for intersecting intervals. This does the right thing
4450 for both insertion and deletion. */
4451 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4453 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4455 add_overlay_mod_hooklist (prop
, overlay
);
4459 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4461 ptrdiff_t startpos
, endpos
;
4462 Lisp_Object ostart
, oend
;
4464 XSETMISC (overlay
, tail
);
4466 ostart
= OVERLAY_START (overlay
);
4467 oend
= OVERLAY_END (overlay
);
4468 startpos
= OVERLAY_POSITION (ostart
);
4469 endpos
= OVERLAY_POSITION (oend
);
4470 if (XFASTINT (end
) < startpos
)
4472 if (insertion
&& (XFASTINT (start
) == startpos
4473 || XFASTINT (end
) == startpos
))
4475 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4477 add_overlay_mod_hooklist (prop
, overlay
);
4479 if (insertion
&& (XFASTINT (start
) == endpos
4480 || XFASTINT (end
) == endpos
))
4482 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4484 add_overlay_mod_hooklist (prop
, overlay
);
4486 /* Test for intersecting intervals. This does the right thing
4487 for both insertion and deletion. */
4488 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4490 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4492 add_overlay_mod_hooklist (prop
, overlay
);
4497 GCPRO4 (overlay
, arg1
, arg2
, arg3
);
4499 /* Call the functions recorded in last_overlay_modification_hooks.
4500 First copy the vector contents, in case some of these hooks
4501 do subsequent modification of the buffer. */
4502 ptrdiff_t size
= last_overlay_modification_hooks_used
;
4503 Lisp_Object
*copy
= alloca (size
* sizeof *copy
);
4506 memcpy (copy
, XVECTOR (last_overlay_modification_hooks
)->contents
,
4509 gcpro1
.nvars
= size
;
4511 for (i
= 0; i
< size
;)
4513 Lisp_Object prop_i
, overlay_i
;
4515 overlay_i
= copy
[i
++];
4516 call_overlay_mod_hooks (prop_i
, overlay_i
, after
, arg1
, arg2
, arg3
);
4523 call_overlay_mod_hooks (Lisp_Object list
, Lisp_Object overlay
, bool after
,
4524 Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
)
4526 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4528 GCPRO4 (list
, arg1
, arg2
, arg3
);
4530 while (CONSP (list
))
4533 call4 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
);
4535 call5 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
, arg3
);
4541 /* Delete any zero-sized overlays at position POS, if the `evaporate'
4544 evaporate_overlays (ptrdiff_t pos
)
4546 Lisp_Object overlay
, hit_list
;
4547 struct Lisp_Overlay
*tail
;
4550 if (pos
<= current_buffer
->overlay_center
)
4551 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4554 XSETMISC (overlay
, tail
);
4555 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4558 if (endpos
== pos
&& OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
4559 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4560 hit_list
= Fcons (overlay
, hit_list
);
4563 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4566 XSETMISC (overlay
, tail
);
4567 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4570 if (startpos
== pos
&& OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
4571 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4572 hit_list
= Fcons (overlay
, hit_list
);
4574 for (; CONSP (hit_list
); hit_list
= XCDR (hit_list
))
4575 Fdelete_overlay (XCAR (hit_list
));
4578 /* Somebody has tried to store a value with an unacceptable type
4579 in the slot with offset OFFSET. */
4582 buffer_slot_type_mismatch (Lisp_Object newval
, int type
)
4584 Lisp_Object predicate
;
4588 case_Lisp_Int
: predicate
= Qintegerp
; break;
4589 case Lisp_String
: predicate
= Qstringp
; break;
4590 case Lisp_Symbol
: predicate
= Qsymbolp
; break;
4591 default: emacs_abort ();
4594 wrong_type_argument (predicate
, newval
);
4598 /***********************************************************************
4599 Allocation with mmap
4600 ***********************************************************************/
4602 #ifdef USE_MMAP_FOR_BUFFERS
4604 #include <sys/types.h>
4605 #include <sys/mman.h>
4608 #ifdef MAP_ANONYMOUS
4609 #define MAP_ANON MAP_ANONYMOUS
4616 #define MAP_FAILED ((void *) -1)
4628 /* Memory is allocated in regions which are mapped using mmap(2).
4629 The current implementation lets the system select mapped
4630 addresses; we're not using MAP_FIXED in general, except when
4631 trying to enlarge regions.
4633 Each mapped region starts with a mmap_region structure, the user
4634 area starts after that structure, aligned to MEM_ALIGN.
4636 +-----------------------+
4637 | struct mmap_info + |
4639 +-----------------------+
4643 +-----------------------+ */
4647 /* User-specified size. */
4648 size_t nbytes_specified
;
4650 /* Number of bytes mapped */
4651 size_t nbytes_mapped
;
4653 /* Pointer to the location holding the address of the memory
4654 allocated with the mmap'd block. The variable actually points
4655 after this structure. */
4658 /* Next and previous in list of all mmap'd regions. */
4659 struct mmap_region
*next
, *prev
;
4662 /* Doubly-linked list of mmap'd regions. */
4664 static struct mmap_region
*mmap_regions
;
4666 /* File descriptor for mmap. If we don't have anonymous mapping,
4667 /dev/zero will be opened on it. */
4671 /* Temporary storage for mmap_set_vars, see there. */
4673 static struct mmap_region
*mmap_regions_1
;
4674 static int mmap_fd_1
;
4676 /* Page size on this system. */
4678 static int mmap_page_size
;
4680 /* 1 means mmap has been initialized. */
4682 static bool mmap_initialized_p
;
4684 /* Value is X rounded up to the next multiple of N. */
4686 #define ROUND(X, N) (((X) + (N) - 1) / (N) * (N))
4688 /* Size of mmap_region structure plus padding. */
4690 #define MMAP_REGION_STRUCT_SIZE \
4691 ROUND (sizeof (struct mmap_region), MEM_ALIGN)
4693 /* Given a pointer P to the start of the user-visible part of a mapped
4694 region, return a pointer to the start of the region. */
4696 #define MMAP_REGION(P) \
4697 ((struct mmap_region *) ((char *) (P) - MMAP_REGION_STRUCT_SIZE))
4699 /* Given a pointer P to the start of a mapped region, return a pointer
4700 to the start of the user-visible part of the region. */
4702 #define MMAP_USER_AREA(P) \
4703 ((void *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
4705 #define MEM_ALIGN sizeof (double)
4707 /* Predicate returning true if part of the address range [START .. END]
4708 is currently mapped. Used to prevent overwriting an existing
4711 Default is to conservatively assume the address range is occupied by
4712 something else. This can be overridden by system configuration
4713 files if system-specific means to determine this exists. */
4715 #ifndef MMAP_ALLOCATED_P
4716 #define MMAP_ALLOCATED_P(start, end) 1
4719 /* Perform necessary initializations for the use of mmap. */
4725 /* The value of mmap_fd is initially 0 in temacs, and -1
4726 in a dumped Emacs. */
4729 /* No anonymous mmap -- we need the file descriptor. */
4730 mmap_fd
= open ("/dev/zero", O_RDONLY
);
4732 fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno
));
4734 #endif /* MAP_ANON == 0 */
4736 if (mmap_initialized_p
)
4738 mmap_initialized_p
= 1;
4744 mmap_page_size
= getpagesize ();
4747 /* Return a region overlapping address range START...END, or null if
4748 none. END is not including, i.e. the last byte in the range
4751 static struct mmap_region
*
4752 mmap_find (void *start
, void *end
)
4754 struct mmap_region
*r
;
4755 char *s
= (char *) start
, *e
= (char *) end
;
4757 for (r
= mmap_regions
; r
; r
= r
->next
)
4759 char *rstart
= (char *) r
;
4760 char *rend
= rstart
+ r
->nbytes_mapped
;
4762 if (/* First byte of range, i.e. START, in this region? */
4763 (s
>= rstart
&& s
< rend
)
4764 /* Last byte of range, i.e. END - 1, in this region? */
4765 || (e
> rstart
&& e
<= rend
)
4766 /* First byte of this region in the range? */
4767 || (rstart
>= s
&& rstart
< e
)
4768 /* Last byte of this region in the range? */
4769 || (rend
> s
&& rend
<= e
))
4777 /* Unmap a region. P is a pointer to the start of the user-araa of
4781 mmap_free_1 (struct mmap_region
*r
)
4784 r
->next
->prev
= r
->prev
;
4786 r
->prev
->next
= r
->next
;
4788 mmap_regions
= r
->next
;
4790 if (munmap (r
, r
->nbytes_mapped
) == -1)
4791 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4795 /* Enlarge region R by NPAGES pages. NPAGES < 0 means shrink R.
4796 Value is true if successful. */
4799 mmap_enlarge (struct mmap_region
*r
, int npages
)
4801 char *region_end
= (char *) r
+ r
->nbytes_mapped
;
4807 /* Unmap pages at the end of the region. */
4808 nbytes
= - npages
* mmap_page_size
;
4809 if (munmap (region_end
- nbytes
, nbytes
) == -1)
4810 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4813 r
->nbytes_mapped
-= nbytes
;
4817 else if (npages
> 0)
4819 nbytes
= npages
* mmap_page_size
;
4821 /* Try to map additional pages at the end of the region. We
4822 cannot do this if the address range is already occupied by
4823 something else because mmap deletes any previous mapping.
4824 I'm not sure this is worth doing, let's see. */
4825 if (!MMAP_ALLOCATED_P (region_end
, region_end
+ nbytes
))
4829 p
= mmap (region_end
, nbytes
, PROT_READ
| PROT_WRITE
,
4830 MAP_ANON
| MAP_PRIVATE
| MAP_FIXED
, mmap_fd
, 0);
4831 if (p
== MAP_FAILED
)
4832 ; /* fprintf (stderr, "mmap: %s\n", emacs_strerror (errno)); */
4833 else if (p
!= region_end
)
4835 /* Kernels are free to choose a different address. In
4836 that case, unmap what we've mapped above; we have
4838 if (munmap (p
, nbytes
) == -1)
4839 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4843 r
->nbytes_mapped
+= nbytes
;
4853 /* Set or reset variables holding references to mapped regions.
4854 If not RESTORE_P, set all variables to null. If RESTORE_P, set all
4855 variables to the start of the user-areas of mapped regions.
4857 This function is called from Fdump_emacs to ensure that the dumped
4858 Emacs doesn't contain references to memory that won't be mapped
4859 when Emacs starts. */
4862 mmap_set_vars (bool restore_p
)
4864 struct mmap_region
*r
;
4868 mmap_regions
= mmap_regions_1
;
4869 mmap_fd
= mmap_fd_1
;
4870 for (r
= mmap_regions
; r
; r
= r
->next
)
4871 *r
->var
= MMAP_USER_AREA (r
);
4875 for (r
= mmap_regions
; r
; r
= r
->next
)
4877 mmap_regions_1
= mmap_regions
;
4878 mmap_regions
= NULL
;
4879 mmap_fd_1
= mmap_fd
;
4885 /* Allocate a block of storage large enough to hold NBYTES bytes of
4886 data. A pointer to the data is returned in *VAR. VAR is thus the
4887 address of some variable which will use the data area.
4889 The allocation of 0 bytes is valid.
4891 If we can't allocate the necessary memory, set *VAR to null, and
4895 mmap_alloc (void **var
, size_t nbytes
)
4902 map
= ROUND (nbytes
+ MMAP_REGION_STRUCT_SIZE
, mmap_page_size
);
4903 p
= mmap (NULL
, map
, PROT_READ
| PROT_WRITE
, MAP_ANON
| MAP_PRIVATE
,
4906 if (p
== MAP_FAILED
)
4908 if (errno
!= ENOMEM
)
4909 fprintf (stderr
, "mmap: %s\n", emacs_strerror (errno
));
4914 struct mmap_region
*r
= (struct mmap_region
*) p
;
4916 r
->nbytes_specified
= nbytes
;
4917 r
->nbytes_mapped
= map
;
4920 r
->next
= mmap_regions
;
4925 p
= MMAP_USER_AREA (p
);
4932 /* Free a block of relocatable storage whose data is pointed to by
4933 PTR. Store 0 in *PTR to show there's no block allocated. */
4936 mmap_free (void **var
)
4942 mmap_free_1 (MMAP_REGION (*var
));
4948 /* Given a pointer at address VAR to data allocated with mmap_alloc,
4949 resize it to size NBYTES. Change *VAR to reflect the new block,
4950 and return this value. If more memory cannot be allocated, then
4951 leave *VAR unchanged, and return null. */
4954 mmap_realloc (void **var
, size_t nbytes
)
4961 result
= mmap_alloc (var
, nbytes
);
4962 else if (nbytes
== 0)
4965 result
= mmap_alloc (var
, nbytes
);
4969 struct mmap_region
*r
= MMAP_REGION (*var
);
4970 size_t room
= r
->nbytes_mapped
- MMAP_REGION_STRUCT_SIZE
;
4975 void *old_ptr
= *var
;
4977 /* Try to map additional pages at the end of the region.
4978 If that fails, allocate a new region, copy data
4979 from the old region, then free it. */
4980 if (mmap_enlarge (r
, (ROUND (nbytes
- room
, mmap_page_size
)
4983 r
->nbytes_specified
= nbytes
;
4984 *var
= result
= old_ptr
;
4986 else if (mmap_alloc (var
, nbytes
))
4988 memcpy (*var
, old_ptr
, r
->nbytes_specified
);
4989 mmap_free_1 (MMAP_REGION (old_ptr
));
4991 r
= MMAP_REGION (result
);
4992 r
->nbytes_specified
= nbytes
;
5000 else if (room
- nbytes
>= mmap_page_size
)
5002 /* Shrinking by at least a page. Let's give some
5003 memory back to the system.
5005 The extra parens are to make the division happens first,
5006 on positive values, so we know it will round towards
5008 mmap_enlarge (r
, - ((room
- nbytes
) / mmap_page_size
));
5010 r
->nbytes_specified
= nbytes
;
5014 /* Leave it alone. */
5016 r
->nbytes_specified
= nbytes
;
5024 #endif /* USE_MMAP_FOR_BUFFERS */
5028 /***********************************************************************
5029 Buffer-text Allocation
5030 ***********************************************************************/
5032 /* Allocate NBYTES bytes for buffer B's text buffer. */
5035 alloc_buffer_text (struct buffer
*b
, ptrdiff_t nbytes
)
5040 #if defined USE_MMAP_FOR_BUFFERS
5041 p
= mmap_alloc ((void **) &b
->text
->beg
, nbytes
);
5042 #elif defined REL_ALLOC
5043 p
= r_alloc ((void **) &b
->text
->beg
, nbytes
);
5045 p
= xmalloc (nbytes
);
5051 memory_full (nbytes
);
5054 b
->text
->beg
= (unsigned char *) p
;
5058 /* Enlarge buffer B's text buffer by DELTA bytes. DELTA < 0 means
5062 enlarge_buffer_text (struct buffer
*b
, ptrdiff_t delta
)
5065 ptrdiff_t nbytes
= (BUF_Z_BYTE (b
) - BUF_BEG_BYTE (b
) + BUF_GAP_SIZE (b
) + 1
5068 #if defined USE_MMAP_FOR_BUFFERS
5069 p
= mmap_realloc ((void **) &b
->text
->beg
, nbytes
);
5070 #elif defined REL_ALLOC
5071 p
= r_re_alloc ((void **) &b
->text
->beg
, nbytes
);
5073 p
= xrealloc (b
->text
->beg
, nbytes
);
5079 memory_full (nbytes
);
5082 BUF_BEG_ADDR (b
) = (unsigned char *) p
;
5087 /* Free buffer B's text buffer. */
5090 free_buffer_text (struct buffer
*b
)
5094 #if defined USE_MMAP_FOR_BUFFERS
5095 mmap_free ((void **) &b
->text
->beg
);
5096 #elif defined REL_ALLOC
5097 r_alloc_free ((void **) &b
->text
->beg
);
5099 xfree (b
->text
->beg
);
5102 BUF_BEG_ADDR (b
) = NULL
;
5108 /***********************************************************************
5110 ***********************************************************************/
5113 init_buffer_once (void)
5116 /* If you add, remove, or reorder Lisp_Objects in a struct buffer, make
5117 sure that this is still correct. Otherwise, mark_vectorlike may not
5118 trace all Lisp_Objects in buffer_defaults and buffer_local_symbols. */
5120 = (offsetof (struct buffer
, own_text
) - header_size
) / word_size
;
5122 memset (buffer_permanent_local_flags
, 0, sizeof buffer_permanent_local_flags
);
5124 /* Make sure all markable slots in buffer_defaults
5125 are initialized reasonably, so mark_buffer won't choke. */
5126 reset_buffer (&buffer_defaults
);
5127 eassert (EQ (BVAR (&buffer_defaults
, name
), make_number (0)));
5128 reset_buffer_local_variables (&buffer_defaults
, 1);
5129 eassert (EQ (BVAR (&buffer_local_symbols
, name
), make_number (0)));
5130 reset_buffer (&buffer_local_symbols
);
5131 reset_buffer_local_variables (&buffer_local_symbols
, 1);
5132 /* Prevent GC from getting confused. */
5133 buffer_defaults
.text
= &buffer_defaults
.own_text
;
5134 buffer_local_symbols
.text
= &buffer_local_symbols
.own_text
;
5135 /* No one will share the text with these buffers, but let's play it safe. */
5136 buffer_defaults
.indirections
= 0;
5137 buffer_local_symbols
.indirections
= 0;
5138 set_buffer_intervals (&buffer_defaults
, NULL
);
5139 set_buffer_intervals (&buffer_local_symbols
, NULL
);
5140 /* This is not strictly necessary, but let's make them initialized. */
5141 bset_name (&buffer_defaults
, build_pure_c_string (" *buffer-defaults*"));
5142 bset_name (&buffer_local_symbols
, build_pure_c_string (" *buffer-local-symbols*"));
5143 XSETPVECTYPESIZE (&buffer_defaults
, PVEC_BUFFER
, pvecsize
);
5144 XSETPVECTYPESIZE (&buffer_local_symbols
, PVEC_BUFFER
, pvecsize
);
5146 /* Set up the default values of various buffer slots. */
5147 /* Must do these before making the first buffer! */
5149 /* real setup is done in bindings.el */
5150 bset_mode_line_format (&buffer_defaults
, build_pure_c_string ("%-"));
5151 bset_header_line_format (&buffer_defaults
, Qnil
);
5152 bset_abbrev_mode (&buffer_defaults
, Qnil
);
5153 bset_overwrite_mode (&buffer_defaults
, Qnil
);
5154 bset_case_fold_search (&buffer_defaults
, Qt
);
5155 bset_auto_fill_function (&buffer_defaults
, Qnil
);
5156 bset_selective_display (&buffer_defaults
, Qnil
);
5157 bset_selective_display_ellipses (&buffer_defaults
, Qt
);
5158 bset_abbrev_table (&buffer_defaults
, Qnil
);
5159 bset_display_table (&buffer_defaults
, Qnil
);
5160 bset_undo_list (&buffer_defaults
, Qnil
);
5161 bset_mark_active (&buffer_defaults
, Qnil
);
5162 bset_file_format (&buffer_defaults
, Qnil
);
5163 bset_auto_save_file_format (&buffer_defaults
, Qt
);
5164 set_buffer_overlays_before (&buffer_defaults
, NULL
);
5165 set_buffer_overlays_after (&buffer_defaults
, NULL
);
5166 buffer_defaults
.overlay_center
= BEG
;
5168 XSETFASTINT (BVAR (&buffer_defaults
, tab_width
), 8);
5169 bset_truncate_lines (&buffer_defaults
, Qnil
);
5170 bset_word_wrap (&buffer_defaults
, Qnil
);
5171 bset_ctl_arrow (&buffer_defaults
, Qt
);
5172 bset_bidi_display_reordering (&buffer_defaults
, Qt
);
5173 bset_bidi_paragraph_direction (&buffer_defaults
, Qnil
);
5174 bset_cursor_type (&buffer_defaults
, Qt
);
5175 bset_extra_line_spacing (&buffer_defaults
, Qnil
);
5176 bset_cursor_in_non_selected_windows (&buffer_defaults
, Qt
);
5178 bset_enable_multibyte_characters (&buffer_defaults
, Qt
);
5179 bset_buffer_file_coding_system (&buffer_defaults
, Qnil
);
5180 XSETFASTINT (BVAR (&buffer_defaults
, fill_column
), 70);
5181 XSETFASTINT (BVAR (&buffer_defaults
, left_margin
), 0);
5182 bset_cache_long_line_scans (&buffer_defaults
, Qnil
);
5183 bset_file_truename (&buffer_defaults
, Qnil
);
5184 XSETFASTINT (BVAR (&buffer_defaults
, display_count
), 0);
5185 XSETFASTINT (BVAR (&buffer_defaults
, left_margin_cols
), 0);
5186 XSETFASTINT (BVAR (&buffer_defaults
, right_margin_cols
), 0);
5187 bset_left_fringe_width (&buffer_defaults
, Qnil
);
5188 bset_right_fringe_width (&buffer_defaults
, Qnil
);
5189 bset_fringes_outside_margins (&buffer_defaults
, Qnil
);
5190 bset_scroll_bar_width (&buffer_defaults
, Qnil
);
5191 bset_vertical_scroll_bar_type (&buffer_defaults
, Qt
);
5192 bset_indicate_empty_lines (&buffer_defaults
, Qnil
);
5193 bset_indicate_buffer_boundaries (&buffer_defaults
, Qnil
);
5194 bset_fringe_indicator_alist (&buffer_defaults
, Qnil
);
5195 bset_fringe_cursor_alist (&buffer_defaults
, Qnil
);
5196 bset_scroll_up_aggressively (&buffer_defaults
, Qnil
);
5197 bset_scroll_down_aggressively (&buffer_defaults
, Qnil
);
5198 bset_display_time (&buffer_defaults
, Qnil
);
5200 /* Assign the local-flags to the slots that have default values.
5201 The local flag is a bit that is used in the buffer
5202 to say that it has its own local value for the slot.
5203 The local flag bits are in the local_var_flags slot of the buffer. */
5205 /* Nothing can work if this isn't true */
5206 { verify (sizeof (EMACS_INT
) == word_size
); }
5208 /* 0 means not a lisp var, -1 means always local, else mask */
5209 memset (&buffer_local_flags
, 0, sizeof buffer_local_flags
);
5210 bset_filename (&buffer_local_flags
, make_number (-1));
5211 bset_directory (&buffer_local_flags
, make_number (-1));
5212 bset_backed_up (&buffer_local_flags
, make_number (-1));
5213 bset_save_length (&buffer_local_flags
, make_number (-1));
5214 bset_auto_save_file_name (&buffer_local_flags
, make_number (-1));
5215 bset_read_only (&buffer_local_flags
, make_number (-1));
5216 bset_major_mode (&buffer_local_flags
, make_number (-1));
5217 bset_mode_name (&buffer_local_flags
, make_number (-1));
5218 bset_undo_list (&buffer_local_flags
, make_number (-1));
5219 bset_mark_active (&buffer_local_flags
, make_number (-1));
5220 bset_point_before_scroll (&buffer_local_flags
, make_number (-1));
5221 bset_file_truename (&buffer_local_flags
, make_number (-1));
5222 bset_invisibility_spec (&buffer_local_flags
, make_number (-1));
5223 bset_file_format (&buffer_local_flags
, make_number (-1));
5224 bset_auto_save_file_format (&buffer_local_flags
, make_number (-1));
5225 bset_display_count (&buffer_local_flags
, make_number (-1));
5226 bset_display_time (&buffer_local_flags
, make_number (-1));
5227 bset_enable_multibyte_characters (&buffer_local_flags
, make_number (-1));
5230 XSETFASTINT (BVAR (&buffer_local_flags
, mode_line_format
), idx
); ++idx
;
5231 XSETFASTINT (BVAR (&buffer_local_flags
, abbrev_mode
), idx
); ++idx
;
5232 XSETFASTINT (BVAR (&buffer_local_flags
, overwrite_mode
), idx
); ++idx
;
5233 XSETFASTINT (BVAR (&buffer_local_flags
, case_fold_search
), idx
); ++idx
;
5234 XSETFASTINT (BVAR (&buffer_local_flags
, auto_fill_function
), idx
); ++idx
;
5235 XSETFASTINT (BVAR (&buffer_local_flags
, selective_display
), idx
); ++idx
;
5236 XSETFASTINT (BVAR (&buffer_local_flags
, selective_display_ellipses
), idx
); ++idx
;
5237 XSETFASTINT (BVAR (&buffer_local_flags
, tab_width
), idx
); ++idx
;
5238 XSETFASTINT (BVAR (&buffer_local_flags
, truncate_lines
), idx
); ++idx
;
5239 XSETFASTINT (BVAR (&buffer_local_flags
, word_wrap
), idx
); ++idx
;
5240 XSETFASTINT (BVAR (&buffer_local_flags
, ctl_arrow
), idx
); ++idx
;
5241 XSETFASTINT (BVAR (&buffer_local_flags
, fill_column
), idx
); ++idx
;
5242 XSETFASTINT (BVAR (&buffer_local_flags
, left_margin
), idx
); ++idx
;
5243 XSETFASTINT (BVAR (&buffer_local_flags
, abbrev_table
), idx
); ++idx
;
5244 XSETFASTINT (BVAR (&buffer_local_flags
, display_table
), idx
); ++idx
;
5245 XSETFASTINT (BVAR (&buffer_local_flags
, syntax_table
), idx
); ++idx
;
5246 XSETFASTINT (BVAR (&buffer_local_flags
, cache_long_line_scans
), idx
); ++idx
;
5247 XSETFASTINT (BVAR (&buffer_local_flags
, category_table
), idx
); ++idx
;
5248 XSETFASTINT (BVAR (&buffer_local_flags
, bidi_display_reordering
), idx
); ++idx
;
5249 XSETFASTINT (BVAR (&buffer_local_flags
, bidi_paragraph_direction
), idx
); ++idx
;
5250 XSETFASTINT (BVAR (&buffer_local_flags
, buffer_file_coding_system
), idx
);
5251 /* Make this one a permanent local. */
5252 buffer_permanent_local_flags
[idx
++] = 1;
5253 XSETFASTINT (BVAR (&buffer_local_flags
, left_margin_cols
), idx
); ++idx
;
5254 XSETFASTINT (BVAR (&buffer_local_flags
, right_margin_cols
), idx
); ++idx
;
5255 XSETFASTINT (BVAR (&buffer_local_flags
, left_fringe_width
), idx
); ++idx
;
5256 XSETFASTINT (BVAR (&buffer_local_flags
, right_fringe_width
), idx
); ++idx
;
5257 XSETFASTINT (BVAR (&buffer_local_flags
, fringes_outside_margins
), idx
); ++idx
;
5258 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_bar_width
), idx
); ++idx
;
5259 XSETFASTINT (BVAR (&buffer_local_flags
, vertical_scroll_bar_type
), idx
); ++idx
;
5260 XSETFASTINT (BVAR (&buffer_local_flags
, indicate_empty_lines
), idx
); ++idx
;
5261 XSETFASTINT (BVAR (&buffer_local_flags
, indicate_buffer_boundaries
), idx
); ++idx
;
5262 XSETFASTINT (BVAR (&buffer_local_flags
, fringe_indicator_alist
), idx
); ++idx
;
5263 XSETFASTINT (BVAR (&buffer_local_flags
, fringe_cursor_alist
), idx
); ++idx
;
5264 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_up_aggressively
), idx
); ++idx
;
5265 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_down_aggressively
), idx
); ++idx
;
5266 XSETFASTINT (BVAR (&buffer_local_flags
, header_line_format
), idx
); ++idx
;
5267 XSETFASTINT (BVAR (&buffer_local_flags
, cursor_type
), idx
); ++idx
;
5268 XSETFASTINT (BVAR (&buffer_local_flags
, extra_line_spacing
), idx
); ++idx
;
5269 XSETFASTINT (BVAR (&buffer_local_flags
, cursor_in_non_selected_windows
), idx
); ++idx
;
5271 /* Need more room? */
5272 if (idx
>= MAX_PER_BUFFER_VARS
)
5274 last_per_buffer_idx
= idx
;
5276 Vbuffer_alist
= Qnil
;
5280 QSFundamental
= build_pure_c_string ("Fundamental");
5282 Qfundamental_mode
= intern_c_string ("fundamental-mode");
5283 bset_major_mode (&buffer_defaults
, Qfundamental_mode
);
5285 Qmode_class
= intern_c_string ("mode-class");
5287 Qprotected_field
= intern_c_string ("protected-field");
5289 Qpermanent_local
= intern_c_string ("permanent-local");
5291 Qkill_buffer_hook
= intern_c_string ("kill-buffer-hook");
5292 Fput (Qkill_buffer_hook
, Qpermanent_local
, Qt
);
5294 /* super-magic invisible buffer */
5295 Vprin1_to_string_buffer
= Fget_buffer_create (build_pure_c_string (" prin1"));
5296 Vbuffer_alist
= Qnil
;
5298 Fset_buffer (Fget_buffer_create (build_pure_c_string ("*scratch*")));
5300 inhibit_modification_hooks
= 0;
5310 #ifdef USE_MMAP_FOR_BUFFERS
5312 /* When using the ralloc implementation based on mmap(2), buffer
5313 text pointers will have been set to null in the dumped Emacs.
5318 if (b
->text
->beg
== NULL
)
5319 enlarge_buffer_text (b
, 0);
5321 #endif /* USE_MMAP_FOR_BUFFERS */
5323 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
5324 if (NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
)))
5325 Fset_buffer_multibyte (Qnil
);
5327 pwd
= get_current_dir_name ();
5330 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5332 /* Maybe this should really use some standard subroutine
5333 whose definition is filename syntax dependent. */
5335 if (!(IS_DIRECTORY_SEP (pwd
[len
- 1])))
5337 /* Grow buffer to add directory separator and '\0'. */
5338 pwd
= realloc (pwd
, len
+ 2);
5340 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5341 pwd
[len
] = DIRECTORY_SEP
;
5342 pwd
[len
+ 1] = '\0';
5346 bset_directory (current_buffer
, make_unibyte_string (pwd
, len
));
5347 if (! NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
)))
5348 /* At this moment, we still don't know how to decode the
5349 directory name. So, we keep the bytes in multibyte form so
5350 that ENCODE_FILE correctly gets the original bytes. */
5352 (current_buffer
, string_to_multibyte (BVAR (current_buffer
, directory
)));
5354 /* Add /: to the front of the name
5355 if it would otherwise be treated as magic. */
5356 temp
= Ffind_file_name_handler (BVAR (current_buffer
, directory
), Qt
);
5358 /* If the default dir is just /, TEMP is non-nil
5359 because of the ange-ftp completion handler.
5360 However, it is not necessary to turn / into /:/.
5361 So avoid doing that. */
5362 && strcmp ("/", SSDATA (BVAR (current_buffer
, directory
))))
5365 concat2 (build_string ("/:"), BVAR (current_buffer
, directory
)));
5367 temp
= get_minibuffer (0);
5368 bset_directory (XBUFFER (temp
), BVAR (current_buffer
, directory
));
5373 /* Similar to defvar_lisp but define a variable whose value is the Lisp
5374 Object stored in the current buffer. address is the address of the slot
5375 in the buffer that is current now. */
5377 /* TYPE is nil for a general Lisp variable.
5378 An integer specifies a type; then only Lisp values
5379 with that type code are allowed (except that nil is allowed too).
5380 LNAME is the Lisp-level variable name.
5381 VNAME is the name of the buffer slot.
5382 DOC is a dummy where you write the doc string as a comment. */
5383 #define DEFVAR_PER_BUFFER(lname, vname, type, doc) \
5385 static struct Lisp_Buffer_Objfwd bo_fwd; \
5386 defvar_per_buffer (&bo_fwd, lname, vname, type); \
5390 defvar_per_buffer (struct Lisp_Buffer_Objfwd
*bo_fwd
, const char *namestring
,
5391 Lisp_Object
*address
, Lisp_Object type
)
5393 struct Lisp_Symbol
*sym
;
5396 sym
= XSYMBOL (intern (namestring
));
5397 offset
= (char *)address
- (char *)current_buffer
;
5399 bo_fwd
->type
= Lisp_Fwd_Buffer_Obj
;
5400 bo_fwd
->offset
= offset
;
5401 bo_fwd
->slottype
= type
;
5402 sym
->declared_special
= 1;
5403 sym
->redirect
= SYMBOL_FORWARDED
;
5405 /* I tried to do the job without a cast, but it seems impossible.
5406 union Lisp_Fwd *fwd; &(fwd->u_buffer_objfwd) = bo_fwd; */
5407 SET_SYMBOL_FWD (sym
, (union Lisp_Fwd
*)bo_fwd
);
5409 XSETSYMBOL (PER_BUFFER_SYMBOL (offset
), sym
);
5411 if (PER_BUFFER_IDX (offset
) == 0)
5412 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
5413 slot of buffer_local_flags */
5418 /* initialize the buffer routines */
5420 syms_of_buffer (void)
5422 staticpro (&last_overlay_modification_hooks
);
5423 last_overlay_modification_hooks
5424 = Fmake_vector (make_number (10), Qnil
);
5426 staticpro (&Qfundamental_mode
);
5427 staticpro (&Qmode_class
);
5428 staticpro (&QSFundamental
);
5429 staticpro (&Vbuffer_alist
);
5430 staticpro (&Qprotected_field
);
5431 staticpro (&Qpermanent_local
);
5432 staticpro (&Qkill_buffer_hook
);
5434 DEFSYM (Qpermanent_local_hook
, "permanent-local-hook");
5435 DEFSYM (Qoverlayp
, "overlayp");
5436 DEFSYM (Qevaporate
, "evaporate");
5437 DEFSYM (Qmodification_hooks
, "modification-hooks");
5438 DEFSYM (Qinsert_in_front_hooks
, "insert-in-front-hooks");
5439 DEFSYM (Qinsert_behind_hooks
, "insert-behind-hooks");
5440 DEFSYM (Qget_file_buffer
, "get-file-buffer");
5441 DEFSYM (Qpriority
, "priority");
5442 DEFSYM (Qbefore_string
, "before-string");
5443 DEFSYM (Qafter_string
, "after-string");
5444 DEFSYM (Qfirst_change_hook
, "first-change-hook");
5445 DEFSYM (Qbefore_change_functions
, "before-change-functions");
5446 DEFSYM (Qafter_change_functions
, "after-change-functions");
5447 DEFSYM (Qkill_buffer_query_functions
, "kill-buffer-query-functions");
5449 Fput (Qprotected_field
, Qerror_conditions
,
5450 listn (CONSTYPE_PURE
, 2, Qprotected_field
, Qerror
));
5451 Fput (Qprotected_field
, Qerror_message
,
5452 build_pure_c_string ("Attempt to modify a protected field"));
5454 DEFVAR_BUFFER_DEFAULTS ("default-mode-line-format",
5456 doc
: /* Default value of `mode-line-format' for buffers that don't override it.
5457 This is the same as (default-value 'mode-line-format). */);
5459 DEFVAR_BUFFER_DEFAULTS ("default-header-line-format",
5461 doc
: /* Default value of `header-line-format' for buffers that don't override it.
5462 This is the same as (default-value 'header-line-format). */);
5464 DEFVAR_BUFFER_DEFAULTS ("default-cursor-type", cursor_type
,
5465 doc
: /* Default value of `cursor-type' for buffers that don't override it.
5466 This is the same as (default-value 'cursor-type). */);
5468 DEFVAR_BUFFER_DEFAULTS ("default-line-spacing",
5470 doc
: /* Default value of `line-spacing' for buffers that don't override it.
5471 This is the same as (default-value 'line-spacing). */);
5473 DEFVAR_BUFFER_DEFAULTS ("default-cursor-in-non-selected-windows",
5474 cursor_in_non_selected_windows
,
5475 doc
: /* Default value of `cursor-in-non-selected-windows'.
5476 This is the same as (default-value 'cursor-in-non-selected-windows). */);
5478 DEFVAR_BUFFER_DEFAULTS ("default-abbrev-mode",
5480 doc
: /* Default value of `abbrev-mode' for buffers that do not override it.
5481 This is the same as (default-value 'abbrev-mode). */);
5483 DEFVAR_BUFFER_DEFAULTS ("default-ctl-arrow",
5485 doc
: /* Default value of `ctl-arrow' for buffers that do not override it.
5486 This is the same as (default-value 'ctl-arrow). */);
5488 DEFVAR_BUFFER_DEFAULTS ("default-enable-multibyte-characters",
5489 enable_multibyte_characters
,
5490 doc
: /* Default value of `enable-multibyte-characters' for buffers not overriding it.
5491 This is the same as (default-value 'enable-multibyte-characters). */);
5493 DEFVAR_BUFFER_DEFAULTS ("default-buffer-file-coding-system",
5494 buffer_file_coding_system
,
5495 doc
: /* Default value of `buffer-file-coding-system' for buffers not overriding it.
5496 This is the same as (default-value 'buffer-file-coding-system). */);
5498 DEFVAR_BUFFER_DEFAULTS ("default-truncate-lines",
5500 doc
: /* Default value of `truncate-lines' for buffers that do not override it.
5501 This is the same as (default-value 'truncate-lines). */);
5503 DEFVAR_BUFFER_DEFAULTS ("default-fill-column",
5505 doc
: /* Default value of `fill-column' for buffers that do not override it.
5506 This is the same as (default-value 'fill-column). */);
5508 DEFVAR_BUFFER_DEFAULTS ("default-left-margin",
5510 doc
: /* Default value of `left-margin' for buffers that do not override it.
5511 This is the same as (default-value 'left-margin). */);
5513 DEFVAR_BUFFER_DEFAULTS ("default-tab-width",
5515 doc
: /* Default value of `tab-width' for buffers that do not override it.
5516 This is the same as (default-value 'tab-width). */);
5518 DEFVAR_BUFFER_DEFAULTS ("default-case-fold-search",
5520 doc
: /* Default value of `case-fold-search' for buffers that don't override it.
5521 This is the same as (default-value 'case-fold-search). */);
5523 DEFVAR_BUFFER_DEFAULTS ("default-left-margin-width",
5525 doc
: /* Default value of `left-margin-width' for buffers that don't override it.
5526 This is the same as (default-value 'left-margin-width). */);
5528 DEFVAR_BUFFER_DEFAULTS ("default-right-margin-width",
5530 doc
: /* Default value of `right-margin-width' for buffers that don't override it.
5531 This is the same as (default-value 'right-margin-width). */);
5533 DEFVAR_BUFFER_DEFAULTS ("default-left-fringe-width",
5535 doc
: /* Default value of `left-fringe-width' for buffers that don't override it.
5536 This is the same as (default-value 'left-fringe-width). */);
5538 DEFVAR_BUFFER_DEFAULTS ("default-right-fringe-width",
5540 doc
: /* Default value of `right-fringe-width' for buffers that don't override it.
5541 This is the same as (default-value 'right-fringe-width). */);
5543 DEFVAR_BUFFER_DEFAULTS ("default-fringes-outside-margins",
5544 fringes_outside_margins
,
5545 doc
: /* Default value of `fringes-outside-margins' for buffers that don't override it.
5546 This is the same as (default-value 'fringes-outside-margins). */);
5548 DEFVAR_BUFFER_DEFAULTS ("default-scroll-bar-width",
5550 doc
: /* Default value of `scroll-bar-width' for buffers that don't override it.
5551 This is the same as (default-value 'scroll-bar-width). */);
5553 DEFVAR_BUFFER_DEFAULTS ("default-vertical-scroll-bar",
5554 vertical_scroll_bar_type
,
5555 doc
: /* Default value of `vertical-scroll-bar' for buffers that don't override it.
5556 This is the same as (default-value 'vertical-scroll-bar). */);
5558 DEFVAR_BUFFER_DEFAULTS ("default-indicate-empty-lines",
5559 indicate_empty_lines
,
5560 doc
: /* Default value of `indicate-empty-lines' for buffers that don't override it.
5561 This is the same as (default-value 'indicate-empty-lines). */);
5563 DEFVAR_BUFFER_DEFAULTS ("default-indicate-buffer-boundaries",
5564 indicate_buffer_boundaries
,
5565 doc
: /* Default value of `indicate-buffer-boundaries' for buffers that don't override it.
5566 This is the same as (default-value 'indicate-buffer-boundaries). */);
5568 DEFVAR_BUFFER_DEFAULTS ("default-fringe-indicator-alist",
5569 fringe_indicator_alist
,
5570 doc
: /* Default value of `fringe-indicator-alist' for buffers that don't override it.
5571 This is the same as (default-value 'fringe-indicator-alist'). */);
5573 DEFVAR_BUFFER_DEFAULTS ("default-fringe-cursor-alist",
5574 fringe_cursor_alist
,
5575 doc
: /* Default value of `fringe-cursor-alist' for buffers that don't override it.
5576 This is the same as (default-value 'fringe-cursor-alist'). */);
5578 DEFVAR_BUFFER_DEFAULTS ("default-scroll-up-aggressively",
5579 scroll_up_aggressively
,
5580 doc
: /* Default value of `scroll-up-aggressively'.
5581 This value applies in buffers that don't have their own local values.
5582 This is the same as (default-value 'scroll-up-aggressively). */);
5584 DEFVAR_BUFFER_DEFAULTS ("default-scroll-down-aggressively",
5585 scroll_down_aggressively
,
5586 doc
: /* Default value of `scroll-down-aggressively'.
5587 This value applies in buffers that don't have their own local values.
5588 This is the same as (default-value 'scroll-down-aggressively). */);
5590 DEFVAR_PER_BUFFER ("header-line-format",
5591 &BVAR (current_buffer
, header_line_format
),
5593 doc
: /* Analogous to `mode-line-format', but controls the header line.
5594 The header line appears, optionally, at the top of a window;
5595 the mode line appears at the bottom. */);
5597 DEFVAR_PER_BUFFER ("mode-line-format", &BVAR (current_buffer
, mode_line_format
),
5599 doc
: /* Template for displaying mode line for current buffer.
5601 The value may be nil, a string, a symbol or a list.
5603 A value of nil means don't display a mode line.
5605 For any symbol other than t or nil, the symbol's value is processed as
5606 a mode line construct. As a special exception, if that value is a
5607 string, the string is processed verbatim, without handling any
5608 %-constructs (see below). Also, unless the symbol has a non-nil
5609 `risky-local-variable' property, all properties in any strings, as
5610 well as all :eval and :propertize forms in the value, are ignored.
5612 A list whose car is a string or list is processed by processing each
5613 of the list elements recursively, as separate mode line constructs,
5614 and concatenating the results.
5616 A list of the form `(:eval FORM)' is processed by evaluating FORM and
5617 using the result as a mode line construct. Be careful--FORM should
5618 not load any files, because that can cause an infinite recursion.
5620 A list of the form `(:propertize ELT PROPS...)' is processed by
5621 processing ELT as the mode line construct, and adding the text
5622 properties PROPS to the result.
5624 A list whose car is a symbol is processed by examining the symbol's
5625 value, and, if that value is non-nil, processing the cadr of the list
5626 recursively; and if that value is nil, processing the caddr of the
5629 A list whose car is an integer is processed by processing the cadr of
5630 the list, and padding (if the number is positive) or truncating (if
5631 negative) to the width specified by that number.
5633 A string is printed verbatim in the mode line except for %-constructs:
5634 %b -- print buffer name. %f -- print visited file name.
5635 %F -- print frame name.
5636 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
5637 %& is like %*, but ignore read-only-ness.
5638 % means buffer is read-only and * means it is modified.
5639 For a modified read-only buffer, %* gives % and %+ gives *.
5640 %s -- print process status. %l -- print the current line number.
5641 %c -- print the current column number (this makes editing slower).
5642 To make the column number update correctly in all cases,
5643 `column-number-mode' must be non-nil.
5644 %i -- print the size of the buffer.
5645 %I -- like %i, but use k, M, G, etc., to abbreviate.
5646 %p -- print percent of buffer above top of window, or Top, Bot or All.
5647 %P -- print percent of buffer above bottom of window, perhaps plus Top,
5648 or print Bottom or All.
5649 %n -- print Narrow if appropriate.
5650 %t -- visited file is text or binary (if OS supports this distinction).
5651 %z -- print mnemonics of keyboard, terminal, and buffer coding systems.
5652 %Z -- like %z, but including the end-of-line format.
5653 %e -- print error message about full memory.
5654 %@ -- print @ or hyphen. @ means that default-directory is on a
5656 %[ -- print one [ for each recursive editing level. %] similar.
5657 %% -- print %. %- -- print infinitely many dashes.
5658 Decimal digits after the % specify field width to which to pad. */);
5660 DEFVAR_BUFFER_DEFAULTS ("default-major-mode", major_mode
,
5661 doc
: /* Value of `major-mode' for new buffers. */);
5663 DEFVAR_PER_BUFFER ("major-mode", &BVAR (current_buffer
, major_mode
),
5664 make_number (Lisp_Symbol
),
5665 doc
: /* Symbol for current buffer's major mode.
5666 The default value (normally `fundamental-mode') affects new buffers.
5667 A value of nil means to use the current buffer's major mode, provided
5668 it is not marked as "special".
5670 When a mode is used by default, `find-file' switches to it before it
5671 reads the contents into the buffer and before it finishes setting up
5672 the buffer. Thus, the mode and its hooks should not expect certain
5673 variables such as `buffer-read-only' and `buffer-file-coding-system'
5676 DEFVAR_PER_BUFFER ("mode-name", &BVAR (current_buffer
, mode_name
),
5678 doc
: /* Pretty name of current buffer's major mode.
5679 Usually a string, but can use any of the constructs for `mode-line-format',
5681 Format with `format-mode-line' to produce a string value. */);
5683 DEFVAR_PER_BUFFER ("local-abbrev-table", &BVAR (current_buffer
, abbrev_table
), Qnil
,
5684 doc
: /* Local (mode-specific) abbrev table of current buffer. */);
5686 DEFVAR_PER_BUFFER ("abbrev-mode", &BVAR (current_buffer
, abbrev_mode
), Qnil
,
5687 doc
: /* Non-nil if Abbrev mode is enabled.
5688 Use the command `abbrev-mode' to change this variable. */);
5690 DEFVAR_PER_BUFFER ("case-fold-search", &BVAR (current_buffer
, case_fold_search
),
5692 doc
: /* Non-nil if searches and matches should ignore case. */);
5694 DEFVAR_PER_BUFFER ("fill-column", &BVAR (current_buffer
, fill_column
),
5695 make_number (Lisp_Int0
),
5696 doc
: /* Column beyond which automatic line-wrapping should happen.
5697 Interactively, you can set the buffer local value using \\[set-fill-column]. */);
5699 DEFVAR_PER_BUFFER ("left-margin", &BVAR (current_buffer
, left_margin
),
5700 make_number (Lisp_Int0
),
5701 doc
: /* Column for the default `indent-line-function' to indent to.
5702 Linefeed indents to this column in Fundamental mode. */);
5704 DEFVAR_PER_BUFFER ("tab-width", &BVAR (current_buffer
, tab_width
),
5705 make_number (Lisp_Int0
),
5706 doc
: /* Distance between tab stops (for display of tab characters), in columns.
5707 This should be an integer greater than zero. */);
5709 DEFVAR_PER_BUFFER ("ctl-arrow", &BVAR (current_buffer
, ctl_arrow
), Qnil
,
5710 doc
: /* Non-nil means display control chars with uparrow.
5711 A value of nil means use backslash and octal digits.
5712 This variable does not apply to characters whose display is specified
5713 in the current display table (if there is one). */);
5715 DEFVAR_PER_BUFFER ("enable-multibyte-characters",
5716 &BVAR (current_buffer
, enable_multibyte_characters
),
5718 doc
: /* Non-nil means the buffer contents are regarded as multi-byte characters.
5719 Otherwise they are regarded as unibyte. This affects the display,
5720 file I/O and the behavior of various editing commands.
5722 This variable is buffer-local but you cannot set it directly;
5723 use the function `set-buffer-multibyte' to change a buffer's representation.
5724 See also Info node `(elisp)Text Representations'. */);
5725 XSYMBOL (intern_c_string ("enable-multibyte-characters"))->constant
= 1;
5727 DEFVAR_PER_BUFFER ("buffer-file-coding-system",
5728 &BVAR (current_buffer
, buffer_file_coding_system
), Qnil
,
5729 doc
: /* Coding system to be used for encoding the buffer contents on saving.
5730 This variable applies to saving the buffer, and also to `write-region'
5731 and other functions that use `write-region'.
5732 It does not apply to sending output to subprocesses, however.
5734 If this is nil, the buffer is saved without any code conversion
5735 unless some coding system is specified in `file-coding-system-alist'
5736 for the buffer file.
5738 If the text to be saved cannot be encoded as specified by this variable,
5739 an alternative encoding is selected by `select-safe-coding-system', which see.
5741 The variable `coding-system-for-write', if non-nil, overrides this variable.
5743 This variable is never applied to a way of decoding a file while reading it. */);
5745 DEFVAR_PER_BUFFER ("bidi-display-reordering",
5746 &BVAR (current_buffer
, bidi_display_reordering
), Qnil
,
5747 doc
: /* Non-nil means reorder bidirectional text for display in the visual order. */);
5749 DEFVAR_PER_BUFFER ("bidi-paragraph-direction",
5750 &BVAR (current_buffer
, bidi_paragraph_direction
), Qnil
,
5751 doc
: /* If non-nil, forces directionality of text paragraphs in the buffer.
5753 If this is nil (the default), the direction of each paragraph is
5754 determined by the first strong directional character of its text.
5755 The values of `right-to-left' and `left-to-right' override that.
5756 Any other value is treated as nil.
5758 This variable has no effect unless the buffer's value of
5759 \`bidi-display-reordering' is non-nil. */);
5761 DEFVAR_PER_BUFFER ("truncate-lines", &BVAR (current_buffer
, truncate_lines
), Qnil
,
5762 doc
: /* Non-nil means do not display continuation lines.
5763 Instead, give each line of text just one screen line.
5765 Note that this is overridden by the variable
5766 `truncate-partial-width-windows' if that variable is non-nil
5767 and this buffer is not full-frame width.
5769 Minibuffers set this variable to nil. */);
5771 DEFVAR_PER_BUFFER ("word-wrap", &BVAR (current_buffer
, word_wrap
), Qnil
,
5772 doc
: /* Non-nil means to use word-wrapping for continuation lines.
5773 When word-wrapping is on, continuation lines are wrapped at the space
5774 or tab character nearest to the right window edge.
5775 If nil, continuation lines are wrapped at the right screen edge.
5777 This variable has no effect if long lines are truncated (see
5778 `truncate-lines' and `truncate-partial-width-windows'). If you use
5779 word-wrapping, you might want to reduce the value of
5780 `truncate-partial-width-windows', since wrapping can make text readable
5781 in narrower windows.
5783 Instead of setting this variable directly, most users should use
5784 Visual Line mode . Visual Line mode, when enabled, sets `word-wrap'
5785 to t, and additionally redefines simple editing commands to act on
5786 visual lines rather than logical lines. See the documentation of
5787 `visual-line-mode'. */);
5789 DEFVAR_PER_BUFFER ("default-directory", &BVAR (current_buffer
, directory
),
5790 make_number (Lisp_String
),
5791 doc
: /* Name of default directory of current buffer. Should end with slash.
5792 To interactively change the default directory, use command `cd'. */);
5794 DEFVAR_PER_BUFFER ("auto-fill-function", &BVAR (current_buffer
, auto_fill_function
),
5796 doc
: /* Function called (if non-nil) to perform auto-fill.
5797 It is called after self-inserting any character specified in
5798 the `auto-fill-chars' table.
5799 NOTE: This variable is not a hook;
5800 its value may not be a list of functions. */);
5802 DEFVAR_PER_BUFFER ("buffer-file-name", &BVAR (current_buffer
, filename
),
5803 make_number (Lisp_String
),
5804 doc
: /* Name of file visited in current buffer, or nil if not visiting a file. */);
5806 DEFVAR_PER_BUFFER ("buffer-file-truename", &BVAR (current_buffer
, file_truename
),
5807 make_number (Lisp_String
),
5808 doc
: /* Abbreviated truename of file visited in current buffer, or nil if none.
5809 The truename of a file is calculated by `file-truename'
5810 and then abbreviated with `abbreviate-file-name'. */);
5812 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
5813 &BVAR (current_buffer
, auto_save_file_name
),
5814 make_number (Lisp_String
),
5815 doc
: /* Name of file for auto-saving current buffer.
5816 If it is nil, that means don't auto-save this buffer. */);
5818 DEFVAR_PER_BUFFER ("buffer-read-only", &BVAR (current_buffer
, read_only
), Qnil
,
5819 doc
: /* Non-nil if this buffer is read-only. */);
5821 DEFVAR_PER_BUFFER ("buffer-backed-up", &BVAR (current_buffer
, backed_up
), Qnil
,
5822 doc
: /* Non-nil if this buffer's file has been backed up.
5823 Backing up is done before the first time the file is saved. */);
5825 DEFVAR_PER_BUFFER ("buffer-saved-size", &BVAR (current_buffer
, save_length
),
5826 make_number (Lisp_Int0
),
5827 doc
: /* Length of current buffer when last read in, saved or auto-saved.
5829 -1 means auto-saving turned off until next real save.
5831 If you set this to -2, that means don't turn off auto-saving in this buffer
5832 if its text size shrinks. If you use `buffer-swap-text' on a buffer,
5833 you probably should set this to -2 in that buffer. */);
5835 DEFVAR_PER_BUFFER ("selective-display", &BVAR (current_buffer
, selective_display
),
5837 doc
: /* Non-nil enables selective display.
5838 An integer N as value means display only lines
5839 that start with less than N columns of space.
5840 A value of t means that the character ^M makes itself and
5841 all the rest of the line invisible; also, when saving the buffer
5842 in a file, save the ^M as a newline. */);
5844 DEFVAR_PER_BUFFER ("selective-display-ellipses",
5845 &BVAR (current_buffer
, selective_display_ellipses
),
5847 doc
: /* Non-nil means display ... on previous line when a line is invisible. */);
5849 DEFVAR_PER_BUFFER ("overwrite-mode", &BVAR (current_buffer
, overwrite_mode
), Qnil
,
5850 doc
: /* Non-nil if self-insertion should replace existing text.
5851 The value should be one of `overwrite-mode-textual',
5852 `overwrite-mode-binary', or nil.
5853 If it is `overwrite-mode-textual', self-insertion still
5854 inserts at the end of a line, and inserts when point is before a tab,
5855 until the tab is filled in.
5856 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too. */);
5858 DEFVAR_PER_BUFFER ("buffer-display-table", &BVAR (current_buffer
, display_table
),
5860 doc
: /* Display table that controls display of the contents of current buffer.
5862 If this variable is nil, the value of `standard-display-table' is used.
5863 Each window can have its own, overriding display table, see
5864 `set-window-display-table' and `window-display-table'.
5866 The display table is a char-table created with `make-display-table'.
5867 A char-table is an array indexed by character codes. Normal array
5868 primitives `aref' and `aset' can be used to access elements of a char-table.
5870 Each of the char-table elements control how to display the corresponding
5871 text character: the element at index C in the table says how to display
5872 the character whose code is C. Each element should be a vector of
5873 characters or nil. The value nil means display the character in the
5874 default fashion; otherwise, the characters from the vector are delivered
5875 to the screen instead of the original character.
5877 For example, (aset buffer-display-table ?X [?Y]) tells Emacs
5878 to display a capital Y instead of each X character.
5880 In addition, a char-table has six extra slots to control the display of:
5882 the end of a truncated screen line (extra-slot 0, a single character);
5883 the end of a continued line (extra-slot 1, a single character);
5884 the escape character used to display character codes in octal
5885 (extra-slot 2, a single character);
5886 the character used as an arrow for control characters (extra-slot 3,
5887 a single character);
5888 the decoration indicating the presence of invisible lines (extra-slot 4,
5889 a vector of characters);
5890 the character used to draw the border between side-by-side windows
5891 (extra-slot 5, a single character).
5893 See also the functions `display-table-slot' and `set-display-table-slot'. */);
5895 DEFVAR_PER_BUFFER ("left-margin-width", &BVAR (current_buffer
, left_margin_cols
),
5897 doc
: /* Width of left marginal area for display of a buffer.
5898 A value of nil means no marginal area. */);
5900 DEFVAR_PER_BUFFER ("right-margin-width", &BVAR (current_buffer
, right_margin_cols
),
5902 doc
: /* Width of right marginal area for display of a buffer.
5903 A value of nil means no marginal area. */);
5905 DEFVAR_PER_BUFFER ("left-fringe-width", &BVAR (current_buffer
, left_fringe_width
),
5907 doc
: /* Width of this buffer's left fringe (in pixels).
5908 A value of 0 means no left fringe is shown in this buffer's window.
5909 A value of nil means to use the left fringe width from the window's frame. */);
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 DEFVAR_PER_BUFFER ("fringes-outside-margins", &BVAR (current_buffer
, fringes_outside_margins
),
5919 doc
: /* Non-nil means to display fringes outside display margins.
5920 A value of nil means to display fringes between margins and buffer text. */);
5922 DEFVAR_PER_BUFFER ("scroll-bar-width", &BVAR (current_buffer
, scroll_bar_width
),
5924 doc
: /* Width of this buffer's scroll bars in pixels.
5925 A value of nil means to use the scroll bar width from the window's frame. */);
5927 DEFVAR_PER_BUFFER ("vertical-scroll-bar", &BVAR (current_buffer
, vertical_scroll_bar_type
),
5929 doc
: /* Position of this buffer's vertical scroll bar.
5930 The value takes effect whenever you tell a window to display this buffer;
5931 for instance, with `set-window-buffer' or when `display-buffer' displays it.
5933 A value of `left' or `right' means put the vertical scroll bar at that side
5934 of the window; a value of nil means don't show any vertical scroll bars.
5935 A value of t (the default) means do whatever the window's frame specifies. */);
5937 DEFVAR_PER_BUFFER ("indicate-empty-lines",
5938 &BVAR (current_buffer
, indicate_empty_lines
), Qnil
,
5939 doc
: /* Visually indicate empty lines after the buffer end.
5940 If non-nil, a bitmap is displayed in the left fringe of a window on
5941 window-systems. */);
5943 DEFVAR_PER_BUFFER ("indicate-buffer-boundaries",
5944 &BVAR (current_buffer
, indicate_buffer_boundaries
), Qnil
,
5945 doc
: /* Visually indicate buffer boundaries and scrolling.
5946 If non-nil, the first and last line of the buffer are marked in the fringe
5947 of a window on window-systems with angle bitmaps, or if the window can be
5948 scrolled, the top and bottom line of the window are marked with up and down
5951 If value is a symbol `left' or `right', both angle and arrow bitmaps
5952 are displayed in the left or right fringe, resp. Any other value
5953 that doesn't look like an alist means display the angle bitmaps in
5954 the left fringe but no arrows.
5956 You can exercise more precise control by using an alist as the
5957 value. Each alist element (INDICATOR . POSITION) specifies
5958 where to show one of the indicators. INDICATOR is one of `top',
5959 `bottom', `up', `down', or t, which specifies the default position,
5960 and POSITION is one of `left', `right', or nil, meaning do not show
5963 For example, ((top . left) (t . right)) places the top angle bitmap in
5964 left fringe, the bottom angle bitmap in right fringe, and both arrow
5965 bitmaps in right fringe. To show just the angle bitmaps in the left
5966 fringe, but no arrow bitmaps, use ((top . left) (bottom . left)). */);
5968 DEFVAR_PER_BUFFER ("fringe-indicator-alist",
5969 &BVAR (current_buffer
, fringe_indicator_alist
), Qnil
,
5970 doc
: /* Mapping from logical to physical fringe indicator bitmaps.
5971 The value is an alist where each element (INDICATOR . BITMAPS)
5972 specifies the fringe bitmaps used to display a specific logical
5975 INDICATOR specifies the logical indicator type which is one of the
5976 following symbols: `truncation' , `continuation', `overlay-arrow',
5977 `top', `bottom', `top-bottom', `up', `down', empty-line', or `unknown'.
5979 BITMAPS is a list of symbols (LEFT RIGHT [LEFT1 RIGHT1]) which specifies
5980 the actual bitmap shown in the left or right fringe for the logical
5981 indicator. LEFT and RIGHT are the bitmaps shown in the left and/or
5982 right fringe for the specific indicator. The LEFT1 or RIGHT1 bitmaps
5983 are used only for the `bottom' and `top-bottom' indicators when the
5984 last (only) line has no final newline. BITMAPS may also be a single
5985 symbol which is used in both left and right fringes. */);
5987 DEFVAR_PER_BUFFER ("fringe-cursor-alist",
5988 &BVAR (current_buffer
, fringe_cursor_alist
), Qnil
,
5989 doc
: /* Mapping from logical to physical fringe cursor bitmaps.
5990 The value is an alist where each element (CURSOR . BITMAP)
5991 specifies the fringe bitmaps used to display a specific logical
5992 cursor type in the fringe.
5994 CURSOR specifies the logical cursor type which is one of the following
5995 symbols: `box' , `hollow', `bar', `hbar', or `hollow-small'. The last
5996 one is used to show a hollow cursor on narrow lines display lines
5997 where the normal hollow cursor will not fit.
5999 BITMAP is the corresponding fringe bitmap shown for the logical
6002 DEFVAR_PER_BUFFER ("scroll-up-aggressively",
6003 &BVAR (current_buffer
, scroll_up_aggressively
), Qnil
,
6004 doc
: /* How far to scroll windows upward.
6005 If you move point off the bottom, the window scrolls automatically.
6006 This variable controls how far it scrolls. The value nil, the default,
6007 means scroll to center point. A fraction means scroll to put point
6008 that fraction of the window's height from the bottom of the window.
6009 When the value is 0.0, point goes at the bottom line, which in the
6010 simple case that you moved off with C-f means scrolling just one line.
6011 1.0 means point goes at the top, so that in that simple case, the
6012 window scrolls by a full window height. Meaningful values are
6013 between 0.0 and 1.0, inclusive. */);
6015 DEFVAR_PER_BUFFER ("scroll-down-aggressively",
6016 &BVAR (current_buffer
, scroll_down_aggressively
), Qnil
,
6017 doc
: /* How far to scroll windows downward.
6018 If you move point off the top, the window scrolls automatically.
6019 This variable controls how far it scrolls. The value nil, the default,
6020 means scroll to center point. A fraction means scroll to put point
6021 that fraction of the window's height from the top of the window.
6022 When the value is 0.0, point goes at the top line, which in the
6023 simple case that you moved off with C-b means scrolling just one line.
6024 1.0 means point goes at the bottom, so that in that simple case, the
6025 window scrolls by a full window height. Meaningful values are
6026 between 0.0 and 1.0, inclusive. */);
6028 /*DEFVAR_LISP ("debug-check-symbol", &Vcheck_symbol,
6032 DEFVAR_LISP ("before-change-functions", Vbefore_change_functions
,
6033 doc
: /* List of functions to call before each text change.
6034 Two arguments are passed to each function: the positions of
6035 the beginning and end of the range of old text to be changed.
6036 \(For an insertion, the beginning and end are at the same place.)
6037 No information is given about the length of the text after the change.
6039 Buffer changes made while executing the `before-change-functions'
6040 don't call any before-change or after-change functions.
6041 That's because `inhibit-modification-hooks' is temporarily set non-nil.
6043 If an unhandled error happens in running these functions,
6044 the variable's value remains nil. That prevents the error
6045 from happening repeatedly and making Emacs nonfunctional. */);
6046 Vbefore_change_functions
= Qnil
;
6048 DEFVAR_LISP ("after-change-functions", Vafter_change_functions
,
6049 doc
: /* List of functions to call after each text change.
6050 Three arguments are passed to each function: the positions of
6051 the beginning and end of the range of changed text,
6052 and the length in bytes of the pre-change text replaced by that range.
6053 \(For an insertion, the pre-change length is zero;
6054 for a deletion, that length is the number of bytes deleted,
6055 and the post-change beginning and end are at the same place.)
6057 Buffer changes made while executing the `after-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 Vafter_change_functions
= Qnil
;
6066 DEFVAR_LISP ("first-change-hook", Vfirst_change_hook
,
6067 doc
: /* A list of functions to call before changing a buffer which is unmodified.
6068 The functions are run using the `run-hooks' function. */);
6069 Vfirst_change_hook
= Qnil
;
6071 DEFVAR_PER_BUFFER ("buffer-undo-list", &BVAR (current_buffer
, undo_list
), Qnil
,
6072 doc
: /* List of undo entries in current buffer.
6073 Recent changes come first; older changes follow newer.
6075 An entry (BEG . END) represents an insertion which begins at
6076 position BEG and ends at position END.
6078 An entry (TEXT . POSITION) represents the deletion of the string TEXT
6079 from (abs POSITION). If POSITION is positive, point was at the front
6080 of the text being deleted; if negative, point was at the end.
6082 An entry (t HIGH LOW USEC PSEC) indicates that the buffer was previously
6083 unmodified; (HIGH LOW USEC PSEC) is in the same style as (current-time)
6084 and is the visited file's modification time, as of that time. If the
6085 modification time of the most recent save is different, this entry is
6088 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
6089 was modified between BEG and END. PROPERTY is the property name,
6090 and VALUE is the old value.
6092 An entry (apply FUN-NAME . ARGS) means undo the change with
6093 \(apply FUN-NAME ARGS).
6095 An entry (apply DELTA BEG END FUN-NAME . ARGS) supports selective undo
6096 in the active region. BEG and END is the range affected by this entry
6097 and DELTA is the number of bytes added or deleted in that range by
6100 An entry (MARKER . DISTANCE) indicates that the marker MARKER
6101 was adjusted in position by the offset DISTANCE (an integer).
6103 An entry of the form POSITION indicates that point was at the buffer
6104 location given by the integer. Undoing an entry of this form places
6107 Entries with value `nil' mark undo boundaries. The undo command treats
6108 the changes between two undo boundaries as a single step to be undone.
6110 If the value of the variable is t, undo information is not recorded. */);
6112 DEFVAR_PER_BUFFER ("mark-active", &BVAR (current_buffer
, mark_active
), Qnil
,
6113 doc
: /* Non-nil means the mark and region are currently active in this buffer. */);
6115 DEFVAR_PER_BUFFER ("cache-long-line-scans", &BVAR (current_buffer
, cache_long_line_scans
), Qnil
,
6116 doc
: /* Non-nil means that Emacs should use caches to handle long lines more quickly.
6118 Normally, the line-motion functions work by scanning the buffer for
6119 newlines. Columnar operations (like `move-to-column' and
6120 `compute-motion') also work by scanning the buffer, summing character
6121 widths as they go. This works well for ordinary text, but if the
6122 buffer's lines are very long (say, more than 500 characters), these
6123 motion functions will take longer to execute. Emacs may also take
6124 longer to update the display.
6126 If `cache-long-line-scans' is non-nil, these motion functions cache the
6127 results of their scans, and consult the cache to avoid rescanning
6128 regions of the buffer until the text is modified. The caches are most
6129 beneficial when they prevent the most searching---that is, when the
6130 buffer contains long lines and large regions of characters with the
6131 same, fixed screen width.
6133 When `cache-long-line-scans' is non-nil, processing short lines will
6134 become slightly slower (because of the overhead of consulting the
6135 cache), and the caches will use memory roughly proportional to the
6136 number of newlines and characters whose screen width varies.
6138 The caches require no explicit maintenance; their accuracy is
6139 maintained internally by the Emacs primitives. Enabling or disabling
6140 the cache should not affect the behavior of any of the motion
6141 functions; it should only affect their performance. */);
6143 DEFVAR_PER_BUFFER ("point-before-scroll", &BVAR (current_buffer
, point_before_scroll
), Qnil
,
6144 doc
: /* Value of point before the last series of scroll operations, or nil. */);
6146 DEFVAR_PER_BUFFER ("buffer-file-format", &BVAR (current_buffer
, file_format
), Qnil
,
6147 doc
: /* List of formats to use when saving this buffer.
6148 Formats are defined by `format-alist'. This variable is
6149 set when a file is visited. */);
6151 DEFVAR_PER_BUFFER ("buffer-auto-save-file-format",
6152 &BVAR (current_buffer
, auto_save_file_format
), Qnil
,
6153 doc
: /* Format in which to write auto-save files.
6154 Should be a list of symbols naming formats that are defined in `format-alist'.
6155 If it is t, which is the default, auto-save files are written in the
6156 same format as a regular save would use. */);
6158 DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
6159 &BVAR (current_buffer
, invisibility_spec
), Qnil
,
6160 doc
: /* Invisibility spec of this buffer.
6161 The default is t, which means that text is invisible
6162 if it has a non-nil `invisible' property.
6163 If the value is a list, a text character is invisible if its `invisible'
6164 property is an element in that list (or is a list with members in common).
6165 If an element is a cons cell of the form (PROP . ELLIPSIS),
6166 then characters with property value PROP are invisible,
6167 and they have an ellipsis as well if ELLIPSIS is non-nil. */);
6169 DEFVAR_PER_BUFFER ("buffer-display-count",
6170 &BVAR (current_buffer
, display_count
), Qnil
,
6171 doc
: /* A number incremented each time this buffer is displayed in a window.
6172 The function `set-window-buffer' increments it. */);
6174 DEFVAR_PER_BUFFER ("buffer-display-time",
6175 &BVAR (current_buffer
, display_time
), Qnil
,
6176 doc
: /* Time stamp updated each time this buffer is displayed in a window.
6177 The function `set-window-buffer' updates this variable
6178 to the value obtained by calling `current-time'.
6179 If the buffer has never been shown in a window, the value is nil. */);
6181 DEFVAR_LISP ("transient-mark-mode", Vtransient_mark_mode
,
6182 doc
: /* Non-nil if Transient Mark mode is enabled.
6183 See the command `transient-mark-mode' for a description of this minor mode.
6185 Non-nil also enables highlighting of the region whenever the mark is active.
6186 The variable `highlight-nonselected-windows' controls whether to highlight
6187 all windows or just the selected window.
6189 Lisp programs may give this variable certain special values:
6191 - A value of `lambda' enables Transient Mark mode temporarily.
6192 It is disabled again after any subsequent action that would
6193 normally deactivate the mark (e.g. buffer modification).
6195 - A value of (only . OLDVAL) enables Transient Mark mode
6196 temporarily. After any subsequent point motion command that is
6197 not shift-translated, or any other action that would normally
6198 deactivate the mark (e.g. buffer modification), the value of
6199 `transient-mark-mode' is set to OLDVAL. */);
6200 Vtransient_mark_mode
= Qnil
;
6202 DEFVAR_LISP ("inhibit-read-only", Vinhibit_read_only
,
6203 doc
: /* Non-nil means disregard read-only status of buffers or characters.
6204 If the value is t, disregard `buffer-read-only' and all `read-only'
6205 text properties. If the value is a list, disregard `buffer-read-only'
6206 and disregard a `read-only' text property if the property value
6207 is a member of the list. */);
6208 Vinhibit_read_only
= Qnil
;
6210 DEFVAR_PER_BUFFER ("cursor-type", &BVAR (current_buffer
, cursor_type
), Qnil
,
6211 doc
: /* Cursor to use when this buffer is in the selected window.
6212 Values are interpreted as follows:
6214 t use the cursor specified for the frame
6215 nil don't display a cursor
6216 box display a filled box cursor
6217 hollow display a hollow box cursor
6218 bar display a vertical bar cursor with default width
6219 (bar . WIDTH) display a vertical bar cursor with width WIDTH
6220 hbar display a horizontal bar cursor with default height
6221 (hbar . HEIGHT) display a horizontal bar cursor with height HEIGHT
6222 ANYTHING ELSE display a hollow box cursor
6224 When the buffer is displayed in a non-selected window, the
6225 cursor's appearance is instead controlled by the variable
6226 `cursor-in-non-selected-windows'. */);
6228 DEFVAR_PER_BUFFER ("line-spacing",
6229 &BVAR (current_buffer
, extra_line_spacing
), Qnil
,
6230 doc
: /* Additional space to put between lines when displaying a buffer.
6231 The space is measured in pixels, and put below lines on graphic displays,
6232 see `display-graphic-p'.
6233 If value is a floating point number, it specifies the spacing relative
6234 to the default frame line height. A value of nil means add no extra space. */);
6236 DEFVAR_PER_BUFFER ("cursor-in-non-selected-windows",
6237 &BVAR (current_buffer
, cursor_in_non_selected_windows
), Qnil
,
6238 doc
: /* Non-nil means show a cursor in non-selected windows.
6239 If nil, only shows a cursor in the selected window.
6240 If t, displays a cursor related to the usual cursor type
6241 \(a solid box becomes hollow, a bar becomes a narrower bar).
6242 You can also specify the cursor type as in the `cursor-type' variable.
6243 Use Custom to set this variable and update the display." */);
6245 DEFVAR_LISP ("kill-buffer-query-functions", Vkill_buffer_query_functions
,
6246 doc
: /* List of functions called with no args to query before killing a buffer.
6247 The buffer being killed will be current while the functions are running.
6249 If any of them returns nil, the buffer is not killed. Functions run by
6250 this hook are supposed to not change the current buffer. */);
6251 Vkill_buffer_query_functions
= Qnil
;
6253 DEFVAR_LISP ("change-major-mode-hook", Vchange_major_mode_hook
,
6254 doc
: /* Normal hook run before changing the major mode of a buffer.
6255 The function `kill-all-local-variables' runs this before doing anything else. */);
6256 Vchange_major_mode_hook
= Qnil
;
6257 DEFSYM (Qchange_major_mode_hook
, "change-major-mode-hook");
6259 DEFVAR_LISP ("buffer-list-update-hook", Vbuffer_list_update_hook
,
6260 doc
: /* Hook run when the buffer list changes.
6261 Functions running this hook are `get-buffer-create',
6262 `make-indirect-buffer', `rename-buffer', `kill-buffer',
6263 and `bury-buffer-internal'. */);
6264 Vbuffer_list_update_hook
= Qnil
;
6265 DEFSYM (Qbuffer_list_update_hook
, "buffer-list-update-hook");
6267 defsubr (&Sbuffer_live_p
);
6268 defsubr (&Sbuffer_list
);
6269 defsubr (&Sget_buffer
);
6270 defsubr (&Sget_file_buffer
);
6271 defsubr (&Sget_buffer_create
);
6272 defsubr (&Smake_indirect_buffer
);
6273 defsubr (&Sgenerate_new_buffer_name
);
6274 defsubr (&Sbuffer_name
);
6275 defsubr (&Sbuffer_file_name
);
6276 defsubr (&Sbuffer_base_buffer
);
6277 defsubr (&Sbuffer_local_value
);
6278 defsubr (&Sbuffer_local_variables
);
6279 defsubr (&Sbuffer_modified_p
);
6280 defsubr (&Sset_buffer_modified_p
);
6281 defsubr (&Sbuffer_modified_tick
);
6282 defsubr (&Sbuffer_chars_modified_tick
);
6283 defsubr (&Srename_buffer
);
6284 defsubr (&Sother_buffer
);
6285 defsubr (&Sbuffer_enable_undo
);
6286 defsubr (&Skill_buffer
);
6287 defsubr (&Sbury_buffer_internal
);
6288 defsubr (&Sset_buffer_major_mode
);
6289 defsubr (&Scurrent_buffer
);
6290 defsubr (&Sset_buffer
);
6291 defsubr (&Sbarf_if_buffer_read_only
);
6292 defsubr (&Serase_buffer
);
6293 defsubr (&Sbuffer_swap_text
);
6294 defsubr (&Sset_buffer_multibyte
);
6295 defsubr (&Skill_all_local_variables
);
6297 defsubr (&Soverlayp
);
6298 defsubr (&Smake_overlay
);
6299 defsubr (&Sdelete_overlay
);
6300 defsubr (&Sdelete_all_overlays
);
6301 defsubr (&Smove_overlay
);
6302 defsubr (&Soverlay_start
);
6303 defsubr (&Soverlay_end
);
6304 defsubr (&Soverlay_buffer
);
6305 defsubr (&Soverlay_properties
);
6306 defsubr (&Soverlays_at
);
6307 defsubr (&Soverlays_in
);
6308 defsubr (&Snext_overlay_change
);
6309 defsubr (&Sprevious_overlay_change
);
6310 defsubr (&Soverlay_recenter
);
6311 defsubr (&Soverlay_lists
);
6312 defsubr (&Soverlay_get
);
6313 defsubr (&Soverlay_put
);
6314 defsubr (&Srestore_buffer_modified_p
);
6318 keys_of_buffer (void)
6320 initial_define_key (control_x_map
, 'b', "switch-to-buffer");
6321 initial_define_key (control_x_map
, 'k', "kill-buffer");
6323 /* This must not be in syms_of_buffer, because Qdisabled is not
6324 initialized when that function gets called. */
6325 Fput (intern_c_string ("erase-buffer"), Qdisabled
, Qt
);