1 /* Buffer manipulation primitives for GNU Emacs.
3 Copyright (C) 1985-1989, 1993-1995, 1997-2014 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
22 #include <sys/types.h>
24 #include <sys/param.h>
32 #include "intervals.h"
35 #include "character.h"
37 #include "region-cache.h"
39 #include "blockinput.h"
44 struct buffer
*current_buffer
; /* The current buffer. */
46 /* First buffer in chain of all buffers (in reverse order of creation).
47 Threaded through ->header.next.buffer. */
49 struct buffer
*all_buffers
;
51 /* This structure holds the default values of the buffer-local variables
52 defined with DEFVAR_PER_BUFFER, that have special slots in each buffer.
53 The default value occupies the same slot in this structure
54 as an individual buffer's value occupies in that buffer.
55 Setting the default value also goes through the alist of buffers
56 and stores into each buffer that does not say it has a local value. */
58 struct buffer
alignas (GCALIGNMENT
) buffer_defaults
;
60 /* This structure marks which slots in a buffer have corresponding
61 default values in buffer_defaults.
62 Each such slot has a nonzero value in this structure.
63 The value has only one nonzero bit.
65 When a buffer has its own local value for a slot,
66 the entry for that slot (found in the same slot in this structure)
67 is turned on in the buffer's local_flags array.
69 If a slot in this structure is -1, then even though there may
70 be a DEFVAR_PER_BUFFER for the slot, there is no default value for it;
71 and the corresponding slot in buffer_defaults is not used.
73 If a slot in this structure corresponding to a DEFVAR_PER_BUFFER is
74 zero, that is a bug. */
76 struct buffer buffer_local_flags
;
78 /* This structure holds the names of symbols whose values may be
79 buffer-local. It is indexed and accessed in the same way as the above. */
81 struct buffer
alignas (GCALIGNMENT
) buffer_local_symbols
;
83 /* Return the symbol of the per-buffer variable at offset OFFSET in
84 the buffer structure. */
86 #define PER_BUFFER_SYMBOL(OFFSET) \
87 (*(Lisp_Object *)((OFFSET) + (char *) &buffer_local_symbols))
89 /* Maximum length of an overlay vector. */
90 #define OVERLAY_COUNT_MAX \
91 ((ptrdiff_t) min (MOST_POSITIVE_FIXNUM, \
92 min (PTRDIFF_MAX, SIZE_MAX) / word_size))
94 /* Flags indicating which built-in buffer-local variables
95 are permanent locals. */
96 static char buffer_permanent_local_flags
[MAX_PER_BUFFER_VARS
];
98 /* Number of per-buffer variables used. */
100 int last_per_buffer_idx
;
102 static void call_overlay_mod_hooks (Lisp_Object list
, Lisp_Object overlay
,
103 bool after
, Lisp_Object arg1
,
104 Lisp_Object arg2
, Lisp_Object arg3
);
105 static void swap_out_buffer_local_variables (struct buffer
*b
);
106 static void reset_buffer_local_variables (struct buffer
*, bool);
108 /* Alist of all buffer names vs the buffers. This used to be
109 a Lisp-visible variable, but is no longer, to prevent lossage
110 due to user rplac'ing this alist or its elements. */
111 Lisp_Object Vbuffer_alist
;
113 static Lisp_Object Qkill_buffer_query_functions
;
115 /* Hook run before changing a major mode. */
116 static Lisp_Object Qchange_major_mode_hook
;
118 Lisp_Object Qfirst_change_hook
;
119 Lisp_Object Qbefore_change_functions
;
120 Lisp_Object Qafter_change_functions
;
122 static Lisp_Object Qfundamental_mode
, Qmode_class
, Qpermanent_local
;
123 static Lisp_Object Qpermanent_local_hook
;
125 static Lisp_Object Qprotected_field
;
127 static Lisp_Object QSFundamental
; /* A string "Fundamental". */
129 static Lisp_Object Qkill_buffer_hook
;
130 static Lisp_Object Qbuffer_list_update_hook
;
132 static Lisp_Object Qget_file_buffer
;
134 static Lisp_Object Qoverlayp
;
136 Lisp_Object Qpriority
, Qbefore_string
, Qafter_string
;
138 static Lisp_Object Qevaporate
;
140 Lisp_Object Qmodification_hooks
;
141 Lisp_Object Qinsert_in_front_hooks
;
142 Lisp_Object Qinsert_behind_hooks
;
144 static void alloc_buffer_text (struct buffer
*, ptrdiff_t);
145 static void free_buffer_text (struct buffer
*b
);
146 static struct Lisp_Overlay
* copy_overlays (struct buffer
*, struct Lisp_Overlay
*);
147 static void modify_overlay (struct buffer
*, ptrdiff_t, ptrdiff_t);
148 static Lisp_Object
buffer_lisp_local_variables (struct buffer
*, bool);
151 CHECK_OVERLAY (Lisp_Object x
)
153 CHECK_TYPE (OVERLAYP (x
), Qoverlayp
, x
);
156 /* These setters are used only in this file, so they can be private.
157 The public setters are inline functions defined in buffer.h. */
159 bset_abbrev_mode (struct buffer
*b
, Lisp_Object val
)
161 b
->INTERNAL_FIELD (abbrev_mode
) = val
;
164 bset_abbrev_table (struct buffer
*b
, Lisp_Object val
)
166 b
->INTERNAL_FIELD (abbrev_table
) = val
;
169 bset_auto_fill_function (struct buffer
*b
, Lisp_Object val
)
171 b
->INTERNAL_FIELD (auto_fill_function
) = val
;
174 bset_auto_save_file_format (struct buffer
*b
, Lisp_Object val
)
176 b
->INTERNAL_FIELD (auto_save_file_format
) = val
;
179 bset_auto_save_file_name (struct buffer
*b
, Lisp_Object val
)
181 b
->INTERNAL_FIELD (auto_save_file_name
) = val
;
184 bset_backed_up (struct buffer
*b
, Lisp_Object val
)
186 b
->INTERNAL_FIELD (backed_up
) = val
;
189 bset_begv_marker (struct buffer
*b
, Lisp_Object val
)
191 b
->INTERNAL_FIELD (begv_marker
) = val
;
194 bset_bidi_display_reordering (struct buffer
*b
, Lisp_Object val
)
196 b
->INTERNAL_FIELD (bidi_display_reordering
) = val
;
199 bset_buffer_file_coding_system (struct buffer
*b
, Lisp_Object val
)
201 b
->INTERNAL_FIELD (buffer_file_coding_system
) = val
;
204 bset_case_fold_search (struct buffer
*b
, Lisp_Object val
)
206 b
->INTERNAL_FIELD (case_fold_search
) = val
;
209 bset_ctl_arrow (struct buffer
*b
, Lisp_Object val
)
211 b
->INTERNAL_FIELD (ctl_arrow
) = val
;
214 bset_cursor_in_non_selected_windows (struct buffer
*b
, Lisp_Object val
)
216 b
->INTERNAL_FIELD (cursor_in_non_selected_windows
) = val
;
219 bset_cursor_type (struct buffer
*b
, Lisp_Object val
)
221 b
->INTERNAL_FIELD (cursor_type
) = val
;
224 bset_display_table (struct buffer
*b
, Lisp_Object val
)
226 b
->INTERNAL_FIELD (display_table
) = val
;
229 bset_extra_line_spacing (struct buffer
*b
, Lisp_Object val
)
231 b
->INTERNAL_FIELD (extra_line_spacing
) = val
;
234 bset_file_format (struct buffer
*b
, Lisp_Object val
)
236 b
->INTERNAL_FIELD (file_format
) = val
;
239 bset_file_truename (struct buffer
*b
, Lisp_Object val
)
241 b
->INTERNAL_FIELD (file_truename
) = val
;
244 bset_fringe_cursor_alist (struct buffer
*b
, Lisp_Object val
)
246 b
->INTERNAL_FIELD (fringe_cursor_alist
) = val
;
249 bset_fringe_indicator_alist (struct buffer
*b
, Lisp_Object val
)
251 b
->INTERNAL_FIELD (fringe_indicator_alist
) = val
;
254 bset_fringes_outside_margins (struct buffer
*b
, Lisp_Object val
)
256 b
->INTERNAL_FIELD (fringes_outside_margins
) = val
;
259 bset_header_line_format (struct buffer
*b
, Lisp_Object val
)
261 b
->INTERNAL_FIELD (header_line_format
) = val
;
264 bset_indicate_buffer_boundaries (struct buffer
*b
, Lisp_Object val
)
266 b
->INTERNAL_FIELD (indicate_buffer_boundaries
) = val
;
269 bset_indicate_empty_lines (struct buffer
*b
, Lisp_Object val
)
271 b
->INTERNAL_FIELD (indicate_empty_lines
) = val
;
274 bset_invisibility_spec (struct buffer
*b
, Lisp_Object val
)
276 b
->INTERNAL_FIELD (invisibility_spec
) = val
;
279 bset_left_fringe_width (struct buffer
*b
, Lisp_Object val
)
281 b
->INTERNAL_FIELD (left_fringe_width
) = val
;
284 bset_major_mode (struct buffer
*b
, Lisp_Object val
)
286 b
->INTERNAL_FIELD (major_mode
) = val
;
289 bset_mark (struct buffer
*b
, Lisp_Object val
)
291 b
->INTERNAL_FIELD (mark
) = val
;
294 bset_minor_modes (struct buffer
*b
, Lisp_Object val
)
296 b
->INTERNAL_FIELD (minor_modes
) = val
;
299 bset_mode_line_format (struct buffer
*b
, Lisp_Object val
)
301 b
->INTERNAL_FIELD (mode_line_format
) = val
;
304 bset_mode_name (struct buffer
*b
, Lisp_Object val
)
306 b
->INTERNAL_FIELD (mode_name
) = val
;
309 bset_name (struct buffer
*b
, Lisp_Object val
)
311 b
->INTERNAL_FIELD (name
) = val
;
314 bset_overwrite_mode (struct buffer
*b
, Lisp_Object val
)
316 b
->INTERNAL_FIELD (overwrite_mode
) = val
;
319 bset_pt_marker (struct buffer
*b
, Lisp_Object val
)
321 b
->INTERNAL_FIELD (pt_marker
) = val
;
324 bset_right_fringe_width (struct buffer
*b
, Lisp_Object val
)
326 b
->INTERNAL_FIELD (right_fringe_width
) = val
;
329 bset_save_length (struct buffer
*b
, Lisp_Object val
)
331 b
->INTERNAL_FIELD (save_length
) = val
;
334 bset_scroll_bar_width (struct buffer
*b
, Lisp_Object val
)
336 b
->INTERNAL_FIELD (scroll_bar_width
) = val
;
339 bset_scroll_down_aggressively (struct buffer
*b
, Lisp_Object val
)
341 b
->INTERNAL_FIELD (scroll_down_aggressively
) = val
;
344 bset_scroll_up_aggressively (struct buffer
*b
, Lisp_Object val
)
346 b
->INTERNAL_FIELD (scroll_up_aggressively
) = val
;
349 bset_selective_display (struct buffer
*b
, Lisp_Object val
)
351 b
->INTERNAL_FIELD (selective_display
) = val
;
354 bset_selective_display_ellipses (struct buffer
*b
, Lisp_Object val
)
356 b
->INTERNAL_FIELD (selective_display_ellipses
) = val
;
359 bset_vertical_scroll_bar_type (struct buffer
*b
, Lisp_Object val
)
361 b
->INTERNAL_FIELD (vertical_scroll_bar_type
) = val
;
364 bset_word_wrap (struct buffer
*b
, Lisp_Object val
)
366 b
->INTERNAL_FIELD (word_wrap
) = val
;
369 bset_zv_marker (struct buffer
*b
, Lisp_Object val
)
371 b
->INTERNAL_FIELD (zv_marker
) = val
;
375 nsberror (Lisp_Object spec
)
378 error ("No buffer named %s", SDATA (spec
));
379 error ("Invalid buffer argument");
382 DEFUN ("buffer-live-p", Fbuffer_live_p
, Sbuffer_live_p
, 1, 1, 0,
383 doc
: /* Return non-nil if OBJECT is a buffer which has not been killed.
384 Value is nil if OBJECT is not a buffer or if it has been killed. */)
387 return ((BUFFERP (object
) && BUFFER_LIVE_P (XBUFFER (object
)))
391 DEFUN ("buffer-list", Fbuffer_list
, Sbuffer_list
, 0, 1, 0,
392 doc
: /* Return a list of all existing live buffers.
393 If the optional arg FRAME is a frame, we return the buffer list in the
394 proper order for that frame: the buffers show in FRAME come first,
395 followed by the rest of the buffers. */)
399 general
= Fmapcar (Qcdr
, Vbuffer_alist
);
403 Lisp_Object framelist
, prevlist
, tail
;
406 framelist
= Fcopy_sequence (XFRAME (frame
)->buffer_list
);
407 prevlist
= Fnreverse (Fcopy_sequence
408 (XFRAME (frame
)->buried_buffer_list
));
410 /* Remove from GENERAL any buffer that duplicates one in
411 FRAMELIST or PREVLIST. */
415 general
= Fdelq (XCAR (tail
), general
);
421 general
= Fdelq (XCAR (tail
), general
);
428 return Fnconc (3, args
);
434 /* Like Fassoc, but use Fstring_equal to compare
435 (which ignores text properties),
436 and don't ever QUIT. */
439 assoc_ignore_text_properties (register Lisp_Object key
, Lisp_Object list
)
441 register Lisp_Object tail
;
442 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
444 register Lisp_Object elt
, tem
;
446 tem
= Fstring_equal (Fcar (elt
), key
);
453 DEFUN ("get-buffer", Fget_buffer
, Sget_buffer
, 1, 1, 0,
454 doc
: /* Return the buffer named BUFFER-OR-NAME.
455 BUFFER-OR-NAME must be either a string or a buffer. If BUFFER-OR-NAME
456 is a string and there is no buffer with that name, return nil. If
457 BUFFER-OR-NAME is a buffer, return it as given. */)
458 (register Lisp_Object buffer_or_name
)
460 if (BUFFERP (buffer_or_name
))
461 return buffer_or_name
;
462 CHECK_STRING (buffer_or_name
);
464 return Fcdr (assoc_ignore_text_properties (buffer_or_name
, Vbuffer_alist
));
467 DEFUN ("get-file-buffer", Fget_file_buffer
, Sget_file_buffer
, 1, 1, 0,
468 doc
: /* Return the buffer visiting file FILENAME (a string).
469 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
470 If there is no such live buffer, return nil.
471 See also `find-buffer-visiting'. */)
472 (register Lisp_Object filename
)
474 register Lisp_Object tail
, buf
, handler
;
476 CHECK_STRING (filename
);
477 filename
= Fexpand_file_name (filename
, Qnil
);
479 /* If the file name has special constructs in it,
480 call the corresponding file handler. */
481 handler
= Ffind_file_name_handler (filename
, Qget_file_buffer
);
484 Lisp_Object handled_buf
= call2 (handler
, Qget_file_buffer
,
486 return BUFFERP (handled_buf
) ? handled_buf
: Qnil
;
489 FOR_EACH_LIVE_BUFFER (tail
, buf
)
491 if (!STRINGP (BVAR (XBUFFER (buf
), filename
))) continue;
492 if (!NILP (Fstring_equal (BVAR (XBUFFER (buf
), filename
), filename
)))
499 get_truename_buffer (register Lisp_Object filename
)
501 register Lisp_Object tail
, buf
;
503 FOR_EACH_LIVE_BUFFER (tail
, buf
)
505 if (!STRINGP (BVAR (XBUFFER (buf
), file_truename
))) continue;
506 if (!NILP (Fstring_equal (BVAR (XBUFFER (buf
), file_truename
), filename
)))
512 DEFUN ("get-buffer-create", Fget_buffer_create
, Sget_buffer_create
, 1, 1, 0,
513 doc
: /* Return the buffer specified by BUFFER-OR-NAME, creating a new one if needed.
514 If BUFFER-OR-NAME is a string and a live buffer with that name exists,
515 return that buffer. If no such buffer exists, create a new buffer with
516 that name and return it. If BUFFER-OR-NAME starts with a space, the new
517 buffer does not keep undo information.
519 If BUFFER-OR-NAME is a buffer instead of a string, return it as given,
520 even if it is dead. The return value is never nil. */)
521 (register Lisp_Object buffer_or_name
)
523 register Lisp_Object buffer
, name
;
524 register struct buffer
*b
;
526 buffer
= Fget_buffer (buffer_or_name
);
530 if (SCHARS (buffer_or_name
) == 0)
531 error ("Empty string for buffer name is not allowed");
533 b
= allocate_buffer ();
535 /* An ordinary buffer uses its own struct buffer_text. */
536 b
->text
= &b
->own_text
;
537 b
->base_buffer
= NULL
;
538 /* No one shares the text with us now. */
540 /* No one shows us now. */
543 BUF_GAP_SIZE (b
) = 20;
545 /* We allocate extra 1-byte at the tail and keep it always '\0' for
546 anchoring a search. */
547 alloc_buffer_text (b
, BUF_GAP_SIZE (b
) + 1);
549 if (! BUF_BEG_ADDR (b
))
550 buffer_memory_full (BUF_GAP_SIZE (b
) + 1);
555 b
->pt_byte
= BEG_BYTE
;
556 b
->begv_byte
= BEG_BYTE
;
557 b
->zv_byte
= BEG_BYTE
;
560 BUF_GPT_BYTE (b
) = BEG_BYTE
;
563 BUF_Z_BYTE (b
) = BEG_BYTE
;
565 BUF_CHARS_MODIFF (b
) = 1;
566 BUF_OVERLAY_MODIFF (b
) = 1;
567 BUF_SAVE_MODIFF (b
) = 1;
569 set_buffer_intervals (b
, NULL
);
570 BUF_UNCHANGED_MODIFIED (b
) = 1;
571 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = 1;
572 BUF_END_UNCHANGED (b
) = 0;
573 BUF_BEG_UNCHANGED (b
) = 0;
574 *(BUF_GPT_ADDR (b
)) = *(BUF_Z_ADDR (b
)) = 0; /* Put an anchor '\0'. */
575 b
->text
->inhibit_shrinking
= false;
576 b
->text
->redisplay
= false;
578 b
->newline_cache
= 0;
579 b
->width_run_cache
= 0;
580 b
->bidi_paragraph_cache
= 0;
581 bset_width_table (b
, Qnil
);
582 b
->prevent_redisplay_optimizations_p
= 1;
584 /* An ordinary buffer normally doesn't need markers
585 to handle BEGV and ZV. */
586 bset_pt_marker (b
, Qnil
);
587 bset_begv_marker (b
, Qnil
);
588 bset_zv_marker (b
, Qnil
);
590 name
= Fcopy_sequence (buffer_or_name
);
591 set_string_intervals (name
, NULL
);
594 bset_undo_list (b
, SREF (name
, 0) != ' ' ? Qnil
: Qt
);
597 reset_buffer_local_variables (b
, 1);
599 bset_mark (b
, Fmake_marker ());
600 BUF_MARKERS (b
) = NULL
;
602 /* Put this in the alist of all live buffers. */
603 XSETBUFFER (buffer
, b
);
604 Vbuffer_alist
= nconc2 (Vbuffer_alist
, list1 (Fcons (name
, buffer
)));
605 /* And run buffer-list-update-hook. */
606 if (!NILP (Vrun_hooks
))
607 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
613 /* Return a list of overlays which is a copy of the overlay list
614 LIST, but for buffer B. */
616 static struct Lisp_Overlay
*
617 copy_overlays (struct buffer
*b
, struct Lisp_Overlay
*list
)
619 struct Lisp_Overlay
*result
= NULL
, *tail
= NULL
;
621 for (; list
; list
= list
->next
)
623 Lisp_Object overlay
, start
, end
;
624 struct Lisp_Marker
*m
;
626 eassert (MARKERP (list
->start
));
627 m
= XMARKER (list
->start
);
628 start
= build_marker (b
, m
->charpos
, m
->bytepos
);
629 XMARKER (start
)->insertion_type
= m
->insertion_type
;
631 eassert (MARKERP (list
->end
));
632 m
= XMARKER (list
->end
);
633 end
= build_marker (b
, m
->charpos
, m
->bytepos
);
634 XMARKER (end
)->insertion_type
= m
->insertion_type
;
636 overlay
= build_overlay (start
, end
, Fcopy_sequence (list
->plist
));
638 tail
= tail
->next
= XOVERLAY (overlay
);
640 result
= tail
= XOVERLAY (overlay
);
646 /* Set an appropriate overlay of B. */
649 set_buffer_overlays_before (struct buffer
*b
, struct Lisp_Overlay
*o
)
651 b
->overlays_before
= o
;
655 set_buffer_overlays_after (struct buffer
*b
, struct Lisp_Overlay
*o
)
657 b
->overlays_after
= o
;
660 /* Clone per-buffer values of buffer FROM.
662 Buffer TO gets the same per-buffer values as FROM, with the
663 following exceptions: (1) TO's name is left untouched, (2) markers
664 are copied and made to refer to TO, and (3) overlay lists are
668 clone_per_buffer_values (struct buffer
*from
, struct buffer
*to
)
672 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
676 /* Don't touch the `name' which should be unique for every buffer. */
677 if (offset
== PER_BUFFER_VAR_OFFSET (name
))
680 obj
= per_buffer_value (from
, offset
);
681 if (MARKERP (obj
) && XMARKER (obj
)->buffer
== from
)
683 struct Lisp_Marker
*m
= XMARKER (obj
);
685 obj
= build_marker (to
, m
->charpos
, m
->bytepos
);
686 XMARKER (obj
)->insertion_type
= m
->insertion_type
;
689 set_per_buffer_value (to
, offset
, obj
);
692 memcpy (to
->local_flags
, from
->local_flags
, sizeof to
->local_flags
);
694 set_buffer_overlays_before (to
, copy_overlays (to
, from
->overlays_before
));
695 set_buffer_overlays_after (to
, copy_overlays (to
, from
->overlays_after
));
697 /* Get (a copy of) the alist of Lisp-level local variables of FROM
698 and install that in TO. */
699 bset_local_var_alist (to
, buffer_lisp_local_variables (from
, 1));
703 /* If buffer B has markers to record PT, BEGV and ZV when it is not
704 current, update these markers. */
707 record_buffer_markers (struct buffer
*b
)
709 if (! NILP (BVAR (b
, pt_marker
)))
713 eassert (!NILP (BVAR (b
, begv_marker
)));
714 eassert (!NILP (BVAR (b
, zv_marker
)));
716 XSETBUFFER (buffer
, b
);
717 set_marker_both (BVAR (b
, pt_marker
), buffer
, b
->pt
, b
->pt_byte
);
718 set_marker_both (BVAR (b
, begv_marker
), buffer
, b
->begv
, b
->begv_byte
);
719 set_marker_both (BVAR (b
, zv_marker
), buffer
, b
->zv
, b
->zv_byte
);
724 /* If buffer B has markers to record PT, BEGV and ZV when it is not
725 current, fetch these values into B->begv etc. */
728 fetch_buffer_markers (struct buffer
*b
)
730 if (! NILP (BVAR (b
, pt_marker
)))
734 eassert (!NILP (BVAR (b
, begv_marker
)));
735 eassert (!NILP (BVAR (b
, zv_marker
)));
737 m
= BVAR (b
, pt_marker
);
738 SET_BUF_PT_BOTH (b
, marker_position (m
), marker_byte_position (m
));
740 m
= BVAR (b
, begv_marker
);
741 SET_BUF_BEGV_BOTH (b
, marker_position (m
), marker_byte_position (m
));
743 m
= BVAR (b
, zv_marker
);
744 SET_BUF_ZV_BOTH (b
, marker_position (m
), marker_byte_position (m
));
749 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer
, Smake_indirect_buffer
,
751 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ",
752 doc
: /* Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.
753 BASE-BUFFER should be a live buffer, or the name of an existing buffer.
754 NAME should be a string which is not the name of an existing buffer.
755 Optional argument CLONE non-nil means preserve BASE-BUFFER's state,
756 such as major and minor modes, in the indirect buffer.
757 CLONE nil means the indirect buffer's state is reset to default values. */)
758 (Lisp_Object base_buffer
, Lisp_Object name
, Lisp_Object clone
)
760 Lisp_Object buf
, tem
;
764 buf
= Fget_buffer (name
);
766 error ("Buffer name `%s' is in use", SDATA (name
));
769 base_buffer
= Fget_buffer (base_buffer
);
770 if (NILP (base_buffer
))
771 error ("No such buffer: `%s'", SDATA (tem
));
772 if (!BUFFER_LIVE_P (XBUFFER (base_buffer
)))
773 error ("Base buffer has been killed");
775 if (SCHARS (name
) == 0)
776 error ("Empty string for buffer name is not allowed");
778 b
= allocate_buffer ();
780 /* No double indirection - if base buffer is indirect,
781 new buffer becomes an indirect to base's base. */
782 b
->base_buffer
= (XBUFFER (base_buffer
)->base_buffer
783 ? XBUFFER (base_buffer
)->base_buffer
784 : XBUFFER (base_buffer
));
786 /* Use the base buffer's text object. */
787 b
->text
= b
->base_buffer
->text
;
788 /* We have no own text. */
789 b
->indirections
= -1;
790 /* Notify base buffer that we share the text now. */
791 b
->base_buffer
->indirections
++;
792 /* Always -1 for an indirect buffer. */
793 b
->window_count
= -1;
795 b
->pt
= b
->base_buffer
->pt
;
796 b
->begv
= b
->base_buffer
->begv
;
797 b
->zv
= b
->base_buffer
->zv
;
798 b
->pt_byte
= b
->base_buffer
->pt_byte
;
799 b
->begv_byte
= b
->base_buffer
->begv_byte
;
800 b
->zv_byte
= b
->base_buffer
->zv_byte
;
802 b
->newline_cache
= 0;
803 b
->width_run_cache
= 0;
804 b
->bidi_paragraph_cache
= 0;
805 bset_width_table (b
, Qnil
);
807 name
= Fcopy_sequence (name
);
808 set_string_intervals (name
, NULL
);
812 reset_buffer_local_variables (b
, 1);
814 /* Put this in the alist of all live buffers. */
816 Vbuffer_alist
= nconc2 (Vbuffer_alist
, list1 (Fcons (name
, buf
)));
818 bset_mark (b
, Fmake_marker ());
820 /* The multibyte status belongs to the base buffer. */
821 bset_enable_multibyte_characters
822 (b
, BVAR (b
->base_buffer
, enable_multibyte_characters
));
824 /* Make sure the base buffer has markers for its narrowing. */
825 if (NILP (BVAR (b
->base_buffer
, pt_marker
)))
827 eassert (NILP (BVAR (b
->base_buffer
, begv_marker
)));
828 eassert (NILP (BVAR (b
->base_buffer
, zv_marker
)));
830 bset_pt_marker (b
->base_buffer
,
831 build_marker (b
->base_buffer
, b
->base_buffer
->pt
,
832 b
->base_buffer
->pt_byte
));
834 bset_begv_marker (b
->base_buffer
,
835 build_marker (b
->base_buffer
, b
->base_buffer
->begv
,
836 b
->base_buffer
->begv_byte
));
838 bset_zv_marker (b
->base_buffer
,
839 build_marker (b
->base_buffer
, b
->base_buffer
->zv
,
840 b
->base_buffer
->zv_byte
));
842 XMARKER (BVAR (b
->base_buffer
, zv_marker
))->insertion_type
= 1;
847 /* Give the indirect buffer markers for its narrowing. */
848 bset_pt_marker (b
, build_marker (b
, b
->pt
, b
->pt_byte
));
849 bset_begv_marker (b
, build_marker (b
, b
->begv
, b
->begv_byte
));
850 bset_zv_marker (b
, build_marker (b
, b
->zv
, b
->zv_byte
));
851 XMARKER (BVAR (b
, zv_marker
))->insertion_type
= 1;
855 struct buffer
*old_b
= current_buffer
;
857 clone_per_buffer_values (b
->base_buffer
, b
);
858 bset_filename (b
, Qnil
);
859 bset_file_truename (b
, Qnil
);
860 bset_display_count (b
, make_number (0));
861 bset_backed_up (b
, Qnil
);
862 bset_auto_save_file_name (b
, Qnil
);
863 set_buffer_internal_1 (b
);
864 Fset (intern ("buffer-save-without-query"), Qnil
);
865 Fset (intern ("buffer-file-number"), Qnil
);
866 Fset (intern ("buffer-stale-function"), Qnil
);
867 set_buffer_internal_1 (old_b
);
870 /* Run buffer-list-update-hook. */
871 if (!NILP (Vrun_hooks
))
872 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
877 /* Mark OV as no longer associated with B. */
880 drop_overlay (struct buffer
*b
, struct Lisp_Overlay
*ov
)
882 eassert (b
== XBUFFER (Fmarker_buffer (ov
->start
)));
883 modify_overlay (b
, marker_position (ov
->start
),
884 marker_position (ov
->end
));
885 unchain_marker (XMARKER (ov
->start
));
886 unchain_marker (XMARKER (ov
->end
));
890 /* Delete all overlays of B and reset it's overlay lists. */
893 delete_all_overlays (struct buffer
*b
)
895 struct Lisp_Overlay
*ov
, *next
;
897 /* FIXME: Since each drop_overlay will scan BUF_MARKERS to unlink its
898 markers, we have an unneeded O(N^2) behavior here. */
899 for (ov
= b
->overlays_before
; ov
; ov
= next
)
901 drop_overlay (b
, ov
);
906 for (ov
= b
->overlays_after
; ov
; ov
= next
)
908 drop_overlay (b
, ov
);
913 set_buffer_overlays_before (b
, NULL
);
914 set_buffer_overlays_after (b
, NULL
);
917 /* Reinitialize everything about a buffer except its name and contents
919 If called on an already-initialized buffer, the list of overlays
920 should be deleted before calling this function, otherwise we end up
921 with overlays that claim to belong to the buffer but the buffer
922 claims it doesn't belong to it. */
925 reset_buffer (register struct buffer
*b
)
927 bset_filename (b
, Qnil
);
928 bset_file_truename (b
, Qnil
);
929 bset_directory (b
, current_buffer
? BVAR (current_buffer
, directory
) : Qnil
);
930 b
->modtime
= make_timespec (0, UNKNOWN_MODTIME_NSECS
);
931 b
->modtime_size
= -1;
932 XSETFASTINT (BVAR (b
, save_length
), 0);
933 b
->last_window_start
= 1;
934 /* It is more conservative to start out "changed" than "unchanged". */
936 b
->prevent_redisplay_optimizations_p
= 1;
937 bset_backed_up (b
, Qnil
);
938 BUF_AUTOSAVE_MODIFF (b
) = 0;
939 b
->auto_save_failure_time
= 0;
940 bset_auto_save_file_name (b
, Qnil
);
941 bset_read_only (b
, Qnil
);
942 set_buffer_overlays_before (b
, NULL
);
943 set_buffer_overlays_after (b
, NULL
);
944 b
->overlay_center
= BEG
;
945 bset_mark_active (b
, Qnil
);
946 bset_point_before_scroll (b
, Qnil
);
947 bset_file_format (b
, Qnil
);
948 bset_auto_save_file_format (b
, Qt
);
949 bset_last_selected_window (b
, Qnil
);
950 bset_display_count (b
, make_number (0));
951 bset_display_time (b
, Qnil
);
952 bset_enable_multibyte_characters
953 (b
, BVAR (&buffer_defaults
, enable_multibyte_characters
));
954 bset_cursor_type (b
, BVAR (&buffer_defaults
, cursor_type
));
955 bset_extra_line_spacing (b
, BVAR (&buffer_defaults
, extra_line_spacing
));
957 b
->display_error_modiff
= 0;
960 /* Reset buffer B's local variables info.
961 Don't use this on a buffer that has already been in use;
962 it does not treat permanent locals consistently.
963 Instead, use Fkill_all_local_variables.
965 If PERMANENT_TOO, reset permanent buffer-local variables.
966 If not, preserve those. */
969 reset_buffer_local_variables (struct buffer
*b
, bool permanent_too
)
973 /* Reset the major mode to Fundamental, together with all the
974 things that depend on the major mode.
975 default-major-mode is handled at a higher level.
976 We ignore it here. */
977 bset_major_mode (b
, Qfundamental_mode
);
978 bset_keymap (b
, Qnil
);
979 bset_mode_name (b
, QSFundamental
);
980 bset_minor_modes (b
, Qnil
);
982 /* If the standard case table has been altered and invalidated,
983 fix up its insides first. */
984 if (! (CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[0])
985 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[1])
986 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[2])))
987 Fset_standard_case_table (Vascii_downcase_table
);
989 bset_downcase_table (b
, Vascii_downcase_table
);
990 bset_upcase_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[0]);
991 bset_case_canon_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[1]);
992 bset_case_eqv_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[2]);
993 bset_invisibility_spec (b
, Qt
);
995 /* Reset all (or most) per-buffer variables to their defaults. */
997 bset_local_var_alist (b
, Qnil
);
1000 Lisp_Object tmp
, prop
, last
= Qnil
;
1001 for (tmp
= BVAR (b
, local_var_alist
); CONSP (tmp
); tmp
= XCDR (tmp
))
1002 if (!NILP (prop
= Fget (XCAR (XCAR (tmp
)), Qpermanent_local
)))
1004 /* If permanent-local, keep it. */
1006 if (EQ (prop
, Qpermanent_local_hook
))
1008 /* This is a partially permanent hook variable.
1009 Preserve only the elements that want to be preserved. */
1010 Lisp_Object list
, newlist
;
1011 list
= XCDR (XCAR (tmp
));
1015 for (newlist
= Qnil
; CONSP (list
); list
= XCDR (list
))
1017 Lisp_Object elt
= XCAR (list
);
1018 /* Preserve element ELT if it's t,
1019 if it is a function with a `permanent-local-hook' property,
1020 or if it's not a symbol. */
1023 || !NILP (Fget (elt
, Qpermanent_local_hook
)))
1024 newlist
= Fcons (elt
, newlist
);
1026 XSETCDR (XCAR (tmp
), Fnreverse (newlist
));
1029 /* Delete this local variable. */
1030 else if (NILP (last
))
1031 bset_local_var_alist (b
, XCDR (tmp
));
1033 XSETCDR (last
, XCDR (tmp
));
1036 for (i
= 0; i
< last_per_buffer_idx
; ++i
)
1037 if (permanent_too
|| buffer_permanent_local_flags
[i
] == 0)
1038 SET_PER_BUFFER_VALUE_P (b
, i
, 0);
1040 /* For each slot that has a default value, copy that into the slot. */
1041 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
1043 int idx
= PER_BUFFER_IDX (offset
);
1046 || buffer_permanent_local_flags
[idx
] == 0)))
1047 set_per_buffer_value (b
, offset
, per_buffer_default (offset
));
1051 /* We split this away from generate-new-buffer, because rename-buffer
1052 and set-visited-file-name ought to be able to use this to really
1053 rename the buffer properly. */
1055 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name
,
1056 Sgenerate_new_buffer_name
, 1, 2, 0,
1057 doc
: /* Return a string that is the name of no existing buffer based on NAME.
1058 If there is no live buffer named NAME, then return NAME.
1059 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
1060 \(starting at 2) until an unused name is found, and then return that name.
1061 Optional second argument IGNORE specifies a name that is okay to use (if
1062 it is in the sequence to be tried) even if a buffer with that name exists.
1064 If NAME begins with a space (i.e., a buffer that is not normally
1065 visible to users), then if buffer NAME already exists a random number
1066 is first appended to NAME, to speed up finding a non-existent buffer. */)
1067 (register Lisp_Object name
, Lisp_Object ignore
)
1069 register Lisp_Object gentemp
, tem
, tem2
;
1071 char number
[INT_BUFSIZE_BOUND (ptrdiff_t) + sizeof "<>"];
1073 CHECK_STRING (name
);
1075 tem
= Fstring_equal (name
, ignore
);
1078 tem
= Fget_buffer (name
);
1082 if (!strncmp (SSDATA (name
), " ", 1)) /* see bug#1229 */
1084 /* Note fileio.c:make_temp_name does random differently. */
1085 tem2
= concat2 (name
, make_formatted_string
1087 XFASTINT (Frandom (make_number (999999)))));
1088 tem
= Fget_buffer (tem2
);
1098 gentemp
= concat2 (tem2
, make_formatted_string
1099 (number
, "<%"pD
"d>", ++count
));
1100 tem
= Fstring_equal (gentemp
, ignore
);
1103 tem
= Fget_buffer (gentemp
);
1110 DEFUN ("buffer-name", Fbuffer_name
, Sbuffer_name
, 0, 1, 0,
1111 doc
: /* Return the name of BUFFER, as a string.
1112 BUFFER defaults to the current buffer.
1113 Return nil if BUFFER has been killed. */)
1114 (register Lisp_Object buffer
)
1117 return BVAR (current_buffer
, name
);
1118 CHECK_BUFFER (buffer
);
1119 return BVAR (XBUFFER (buffer
), name
);
1122 DEFUN ("buffer-file-name", Fbuffer_file_name
, Sbuffer_file_name
, 0, 1, 0,
1123 doc
: /* Return name of file BUFFER is visiting, or nil if none.
1124 No argument or nil as argument means use the current buffer. */)
1125 (register Lisp_Object buffer
)
1128 return BVAR (current_buffer
, filename
);
1129 CHECK_BUFFER (buffer
);
1130 return BVAR (XBUFFER (buffer
), filename
);
1133 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer
, Sbuffer_base_buffer
,
1135 doc
: /* Return the base buffer of indirect buffer BUFFER.
1136 If BUFFER is not indirect, return nil.
1137 BUFFER defaults to the current buffer. */)
1138 (register Lisp_Object buffer
)
1140 struct buffer
*base
;
1141 Lisp_Object base_buffer
;
1144 base
= current_buffer
->base_buffer
;
1147 CHECK_BUFFER (buffer
);
1148 base
= XBUFFER (buffer
)->base_buffer
;
1153 XSETBUFFER (base_buffer
, base
);
1157 DEFUN ("buffer-local-value", Fbuffer_local_value
,
1158 Sbuffer_local_value
, 2, 2, 0,
1159 doc
: /* Return the value of VARIABLE in BUFFER.
1160 If VARIABLE does not have a buffer-local binding in BUFFER, the value
1161 is the default binding of the variable. */)
1162 (register Lisp_Object variable
, register Lisp_Object buffer
)
1164 register Lisp_Object result
= buffer_local_value_1 (variable
, buffer
);
1166 if (EQ (result
, Qunbound
))
1167 xsignal1 (Qvoid_variable
, variable
);
1173 /* Like Fbuffer_local_value, but return Qunbound if the variable is
1177 buffer_local_value_1 (Lisp_Object variable
, Lisp_Object buffer
)
1179 register struct buffer
*buf
;
1180 register Lisp_Object result
;
1181 struct Lisp_Symbol
*sym
;
1183 CHECK_SYMBOL (variable
);
1184 CHECK_BUFFER (buffer
);
1185 buf
= XBUFFER (buffer
);
1186 sym
= XSYMBOL (variable
);
1189 switch (sym
->redirect
)
1191 case SYMBOL_VARALIAS
: sym
= indirect_variable (sym
); goto start
;
1192 case SYMBOL_PLAINVAL
: result
= SYMBOL_VAL (sym
); break;
1193 case SYMBOL_LOCALIZED
:
1194 { /* Look in local_var_alist. */
1195 struct Lisp_Buffer_Local_Value
*blv
= SYMBOL_BLV (sym
);
1196 XSETSYMBOL (variable
, sym
); /* Update In case of aliasing. */
1197 result
= Fassoc (variable
, BVAR (buf
, local_var_alist
));
1201 { /* What binding is loaded right now? */
1202 Lisp_Object current_alist_element
= blv
->valcell
;
1204 /* The value of the currently loaded binding is not
1205 stored in it, but rather in the realvalue slot.
1206 Store that value into the binding it belongs to
1207 in case that is the one we are about to use. */
1209 XSETCDR (current_alist_element
,
1210 do_symval_forwarding (blv
->fwd
));
1212 /* Now get the (perhaps updated) value out of the binding. */
1213 result
= XCDR (result
);
1216 result
= Fdefault_value (variable
);
1219 case SYMBOL_FORWARDED
:
1221 union Lisp_Fwd
*fwd
= SYMBOL_FWD (sym
);
1222 if (BUFFER_OBJFWDP (fwd
))
1223 result
= per_buffer_value (buf
, XBUFFER_OBJFWD (fwd
)->offset
);
1225 result
= Fdefault_value (variable
);
1228 default: emacs_abort ();
1234 /* Return an alist of the Lisp-level buffer-local bindings of
1235 buffer BUF. That is, don't include the variables maintained
1236 in special slots in the buffer object.
1237 If not CLONE, replace elements of the form (VAR . unbound)
1241 buffer_lisp_local_variables (struct buffer
*buf
, bool clone
)
1243 Lisp_Object result
= Qnil
;
1245 for (tail
= BVAR (buf
, local_var_alist
); CONSP (tail
); tail
= XCDR (tail
))
1247 Lisp_Object val
, elt
;
1251 /* Reference each variable in the alist in buf.
1252 If inquiring about the current buffer, this gets the current values,
1253 so store them into the alist so the alist is up to date.
1254 If inquiring about some other buffer, this swaps out any values
1255 for that buffer, making the alist up to date automatically. */
1256 val
= find_symbol_value (XCAR (elt
));
1257 /* Use the current buffer value only if buf is the current buffer. */
1258 if (buf
!= current_buffer
)
1261 result
= Fcons (!clone
&& EQ (val
, Qunbound
)
1263 : Fcons (XCAR (elt
), val
),
1270 DEFUN ("buffer-local-variables", Fbuffer_local_variables
,
1271 Sbuffer_local_variables
, 0, 1, 0,
1272 doc
: /* Return an alist of variables that are buffer-local in BUFFER.
1273 Most elements look like (SYMBOL . VALUE), describing one variable.
1274 For a symbol that is locally unbound, just the symbol appears in the value.
1275 Note that storing new VALUEs in these elements doesn't change the variables.
1276 No argument or nil as argument means use current buffer as BUFFER. */)
1277 (register Lisp_Object buffer
)
1279 register struct buffer
*buf
;
1280 register Lisp_Object result
;
1283 buf
= current_buffer
;
1286 CHECK_BUFFER (buffer
);
1287 buf
= XBUFFER (buffer
);
1290 result
= buffer_lisp_local_variables (buf
, 0);
1292 /* Add on all the variables stored in special slots. */
1296 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
1298 idx
= PER_BUFFER_IDX (offset
);
1299 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
1300 && SYMBOLP (PER_BUFFER_SYMBOL (offset
)))
1302 Lisp_Object sym
= PER_BUFFER_SYMBOL (offset
);
1303 Lisp_Object val
= per_buffer_value (buf
, offset
);
1304 result
= Fcons (EQ (val
, Qunbound
) ? sym
: Fcons (sym
, val
),
1313 DEFUN ("buffer-modified-p", Fbuffer_modified_p
, Sbuffer_modified_p
,
1315 doc
: /* Return t if BUFFER was modified since its file was last read or saved.
1316 No argument or nil as argument means use current buffer as BUFFER. */)
1317 (register Lisp_Object buffer
)
1319 register struct buffer
*buf
;
1321 buf
= current_buffer
;
1324 CHECK_BUFFER (buffer
);
1325 buf
= XBUFFER (buffer
);
1328 return BUF_SAVE_MODIFF (buf
) < BUF_MODIFF (buf
) ? Qt
: Qnil
;
1331 DEFUN ("force-mode-line-update", Fforce_mode_line_update
,
1332 Sforce_mode_line_update
, 0, 1, 0,
1333 doc
: /* Force redisplay of the current buffer's mode line and header line.
1334 With optional non-nil ALL, force redisplay of all mode lines and
1335 header lines. This function also forces recomputation of the
1336 menu bar menus and the frame title. */)
1341 update_mode_lines
= 10;
1342 /* FIXME: This can't be right. */
1343 current_buffer
->prevent_redisplay_optimizations_p
= true;
1345 else if (buffer_window_count (current_buffer
))
1347 bset_update_mode_line (current_buffer
);
1348 current_buffer
->prevent_redisplay_optimizations_p
= true;
1353 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p
, Sset_buffer_modified_p
,
1355 doc
: /* Mark current buffer as modified or unmodified according to FLAG.
1356 A non-nil FLAG means mark the buffer modified. */)
1359 Frestore_buffer_modified_p (flag
);
1361 /* Set update_mode_lines only if buffer is displayed in some window.
1362 Packages like jit-lock or lazy-lock preserve a buffer's modified
1363 state by recording/restoring the state around blocks of code.
1364 Setting update_mode_lines makes redisplay consider all windows
1365 (on all frames). Stealth fontification of buffers not displayed
1366 would incur additional redisplay costs if we'd set
1367 update_modes_lines unconditionally.
1369 Ideally, I think there should be another mechanism for fontifying
1370 buffers without "modifying" buffers, or redisplay should be
1371 smarter about updating the `*' in mode lines. --gerd */
1372 return Fforce_mode_line_update (Qnil
);
1375 DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p
,
1376 Srestore_buffer_modified_p
, 1, 1, 0,
1377 doc
: /* Like `set-buffer-modified-p', with a difference concerning redisplay.
1378 It is not ensured that mode lines will be updated to show the modified
1379 state of the current buffer. Use with care. */)
1384 /* If buffer becoming modified, lock the file.
1385 If buffer becoming unmodified, unlock the file. */
1387 struct buffer
*b
= current_buffer
->base_buffer
1388 ? current_buffer
->base_buffer
1391 fn
= BVAR (b
, file_truename
);
1392 /* Test buffer-file-name so that binding it to nil is effective. */
1393 if (!NILP (fn
) && ! NILP (BVAR (b
, filename
)))
1395 bool already
= SAVE_MODIFF
< MODIFF
;
1396 if (!already
&& !NILP (flag
))
1398 else if (already
&& NILP (flag
))
1402 /* Here we have a problem. SAVE_MODIFF is used here to encode
1403 buffer-modified-p (as SAVE_MODIFF<MODIFF) as well as
1404 recent-auto-save-p (as SAVE_MODIFF<auto_save_modified). So if we
1405 modify SAVE_MODIFF to affect one, we may affect the other
1407 E.g. if FLAG is nil we need to set SAVE_MODIFF to MODIFF, but
1408 if SAVE_MODIFF<auto_save_modified that means we risk changing
1409 recent-auto-save-p from t to nil.
1410 Vice versa, if FLAG is non-nil and SAVE_MODIFF>=auto_save_modified
1411 we risk changing recent-auto-save-p from nil to t. */
1412 SAVE_MODIFF
= (NILP (flag
)
1413 /* FIXME: This unavoidably sets recent-auto-save-p to nil. */
1415 /* Let's try to preserve recent-auto-save-p. */
1416 : SAVE_MODIFF
< MODIFF
? SAVE_MODIFF
1417 /* If SAVE_MODIFF == auto_save_modified == MODIFF,
1418 we can either decrease SAVE_MODIFF and auto_save_modified
1419 or increase MODIFF. */
1425 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick
, Sbuffer_modified_tick
,
1427 doc
: /* Return BUFFER's tick counter, incremented for each change in text.
1428 Each buffer has a tick counter which is incremented each time the
1429 text in that buffer is changed. It wraps around occasionally.
1430 No argument or nil as argument means use current buffer as BUFFER. */)
1431 (register Lisp_Object buffer
)
1433 register struct buffer
*buf
;
1435 buf
= current_buffer
;
1438 CHECK_BUFFER (buffer
);
1439 buf
= XBUFFER (buffer
);
1442 return make_number (BUF_MODIFF (buf
));
1445 DEFUN ("buffer-chars-modified-tick", Fbuffer_chars_modified_tick
,
1446 Sbuffer_chars_modified_tick
, 0, 1, 0,
1447 doc
: /* Return BUFFER's character-change tick counter.
1448 Each buffer has a character-change tick counter, which is set to the
1449 value of the buffer's tick counter \(see `buffer-modified-tick'), each
1450 time text in that buffer is inserted or deleted. By comparing the
1451 values returned by two individual calls of `buffer-chars-modified-tick',
1452 you can tell whether a character change occurred in that buffer in
1453 between these calls. No argument or nil as argument means use current
1454 buffer as BUFFER. */)
1455 (register Lisp_Object buffer
)
1457 register struct buffer
*buf
;
1459 buf
= current_buffer
;
1462 CHECK_BUFFER (buffer
);
1463 buf
= XBUFFER (buffer
);
1466 return make_number (BUF_CHARS_MODIFF (buf
));
1469 DEFUN ("rename-buffer", Frename_buffer
, Srename_buffer
, 1, 2,
1470 "(list (read-string \"Rename buffer (to new name): \" \
1471 nil 'buffer-name-history (buffer-name (current-buffer))) \
1472 current-prefix-arg)",
1473 doc
: /* Change current buffer's name to NEWNAME (a string).
1474 If second arg UNIQUE is nil or omitted, it is an error if a
1475 buffer named NEWNAME already exists.
1476 If UNIQUE is non-nil, come up with a new name using
1477 `generate-new-buffer-name'.
1478 Interactively, you can set UNIQUE with a prefix argument.
1479 We return the name we actually gave the buffer.
1480 This does not change the name of the visited file (if any). */)
1481 (register Lisp_Object newname
, Lisp_Object unique
)
1483 register Lisp_Object tem
, buf
;
1485 CHECK_STRING (newname
);
1487 if (SCHARS (newname
) == 0)
1488 error ("Empty string is invalid as a buffer name");
1490 tem
= Fget_buffer (newname
);
1493 /* Don't short-circuit if UNIQUE is t. That is a useful way to
1494 rename the buffer automatically so you can create another
1495 with the original name. It makes UNIQUE equivalent to
1496 (rename-buffer (generate-new-buffer-name NEWNAME)). */
1497 if (NILP (unique
) && XBUFFER (tem
) == current_buffer
)
1498 return BVAR (current_buffer
, name
);
1500 newname
= Fgenerate_new_buffer_name (newname
, BVAR (current_buffer
, name
));
1502 error ("Buffer name `%s' is in use", SDATA (newname
));
1505 bset_name (current_buffer
, newname
);
1507 /* Catch redisplay's attention. Unless we do this, the mode lines for
1508 any windows displaying current_buffer will stay unchanged. */
1509 update_mode_lines
= 11;
1511 XSETBUFFER (buf
, current_buffer
);
1512 Fsetcar (Frassq (buf
, Vbuffer_alist
), newname
);
1513 if (NILP (BVAR (current_buffer
, filename
))
1514 && !NILP (BVAR (current_buffer
, auto_save_file_name
)))
1515 call0 (intern ("rename-auto-save-file"));
1517 /* Run buffer-list-update-hook. */
1518 if (!NILP (Vrun_hooks
))
1519 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1521 /* Refetch since that last call may have done GC. */
1522 return BVAR (current_buffer
, name
);
1525 /* True if B can be used as 'other-than-BUFFER' buffer. */
1528 candidate_buffer (Lisp_Object b
, Lisp_Object buffer
)
1530 return (BUFFERP (b
) && !EQ (b
, buffer
)
1531 && BUFFER_LIVE_P (XBUFFER (b
))
1532 && !BUFFER_HIDDEN_P (XBUFFER (b
)));
1535 DEFUN ("other-buffer", Fother_buffer
, Sother_buffer
, 0, 3, 0,
1536 doc
: /* Return most recently selected buffer other than BUFFER.
1537 Buffers not visible in windows are preferred to visible buffers, unless
1538 optional second argument VISIBLE-OK is non-nil. Ignore the argument
1539 BUFFER unless it denotes a live buffer. If the optional third argument
1540 FRAME is non-nil, use that frame's buffer list instead of the selected
1541 frame's buffer list.
1543 The buffer is found by scanning the selected or specified frame's buffer
1544 list first, followed by the list of all buffers. If no other buffer
1545 exists, return the buffer `*scratch*' (creating it if necessary). */)
1546 (register Lisp_Object buffer
, Lisp_Object visible_ok
, Lisp_Object frame
)
1548 struct frame
*f
= decode_any_frame (frame
);
1549 Lisp_Object tail
= f
->buffer_list
, pred
= f
->buffer_predicate
;
1550 Lisp_Object buf
, notsogood
= Qnil
;
1552 /* Consider buffers that have been seen in the frame first. */
1553 for (; CONSP (tail
); tail
= XCDR (tail
))
1556 if (candidate_buffer (buf
, buffer
)
1557 /* If the frame has a buffer_predicate, disregard buffers that
1558 don't fit the predicate. */
1559 && (NILP (pred
) || !NILP (call1 (pred
, buf
))))
1561 if (!NILP (visible_ok
)
1562 || NILP (Fget_buffer_window (buf
, Qvisible
)))
1564 else if (NILP (notsogood
))
1569 /* Consider alist of all buffers next. */
1570 FOR_EACH_LIVE_BUFFER (tail
, buf
)
1572 if (candidate_buffer (buf
, buffer
)
1573 /* If the frame has a buffer_predicate, disregard buffers that
1574 don't fit the predicate. */
1575 && (NILP (pred
) || !NILP (call1 (pred
, buf
))))
1577 if (!NILP (visible_ok
)
1578 || NILP (Fget_buffer_window (buf
, Qvisible
)))
1580 else if (NILP (notsogood
))
1585 if (!NILP (notsogood
))
1589 buf
= Fget_buffer (build_string ("*scratch*"));
1592 buf
= Fget_buffer_create (build_string ("*scratch*"));
1593 Fset_buffer_major_mode (buf
);
1599 /* The following function is a safe variant of Fother_buffer: It doesn't
1600 pay attention to any frame-local buffer lists, doesn't care about
1601 visibility of buffers, and doesn't evaluate any frame predicates. */
1604 other_buffer_safely (Lisp_Object buffer
)
1606 Lisp_Object tail
, buf
;
1608 FOR_EACH_LIVE_BUFFER (tail
, buf
)
1609 if (candidate_buffer (buf
, buffer
))
1612 buf
= Fget_buffer (build_string ("*scratch*"));
1615 buf
= Fget_buffer_create (build_string ("*scratch*"));
1616 Fset_buffer_major_mode (buf
);
1622 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo
, Sbuffer_enable_undo
,
1624 doc
: /* Start keeping undo information for buffer BUFFER.
1625 No argument or nil as argument means do this for the current buffer. */)
1626 (register Lisp_Object buffer
)
1628 Lisp_Object real_buffer
;
1631 XSETBUFFER (real_buffer
, current_buffer
);
1634 real_buffer
= Fget_buffer (buffer
);
1635 if (NILP (real_buffer
))
1639 if (EQ (BVAR (XBUFFER (real_buffer
), undo_list
), Qt
))
1640 bset_undo_list (XBUFFER (real_buffer
), Qnil
);
1645 /* Truncate undo list and shrink the gap of BUFFER. */
1648 compact_buffer (struct buffer
*buffer
)
1650 BUFFER_CHECK_INDIRECTION (buffer
);
1652 /* Skip dead buffers, indirect buffers and buffers
1653 which aren't changed since last compaction. */
1654 if (BUFFER_LIVE_P (buffer
)
1655 && (buffer
->base_buffer
== NULL
)
1656 && (BUF_COMPACT (buffer
) != BUF_MODIFF (buffer
)))
1658 /* If a buffer's undo list is Qt, that means that undo is
1659 turned off in that buffer. Calling truncate_undo_list on
1660 Qt tends to return NULL, which effectively turns undo back on.
1661 So don't call truncate_undo_list if undo_list is Qt. */
1662 if (!EQ (buffer
->INTERNAL_FIELD (undo_list
), Qt
))
1663 truncate_undo_list (buffer
);
1665 /* Shrink buffer gaps. */
1666 if (!buffer
->text
->inhibit_shrinking
)
1668 /* If a buffer's gap size is more than 10% of the buffer
1669 size, or larger than GAP_BYTES_DFL bytes, then shrink it
1670 accordingly. Keep a minimum size of GAP_BYTES_MIN bytes. */
1671 ptrdiff_t size
= clip_to_bounds (GAP_BYTES_MIN
,
1672 BUF_Z_BYTE (buffer
) / 10,
1674 if (BUF_GAP_SIZE (buffer
) > size
)
1675 make_gap_1 (buffer
, -(BUF_GAP_SIZE (buffer
) - size
));
1677 BUF_COMPACT (buffer
) = BUF_MODIFF (buffer
);
1681 DEFUN ("kill-buffer", Fkill_buffer
, Skill_buffer
, 0, 1, "bKill buffer: ",
1682 doc
: /* Kill the buffer specified by BUFFER-OR-NAME.
1683 The argument may be a buffer or the name of an existing buffer.
1684 Argument nil or omitted means kill the current buffer. Return t if the
1685 buffer is actually killed, nil otherwise.
1687 The functions in `kill-buffer-query-functions' are called with the
1688 buffer to be killed as the current buffer. If any of them returns nil,
1689 the buffer is not killed. The hook `kill-buffer-hook' is run before the
1690 buffer is actually killed. The buffer being killed will be current
1691 while the hook is running. Functions called by any of these hooks are
1692 supposed to not change the current buffer.
1694 Any processes that have this buffer as the `process-buffer' are killed
1695 with SIGHUP. This function calls `replace-buffer-in-windows' for
1696 cleaning up all windows currently displaying the buffer to be killed. */)
1697 (Lisp_Object buffer_or_name
)
1700 register struct buffer
*b
;
1701 register Lisp_Object tem
;
1702 register struct Lisp_Marker
*m
;
1703 struct gcpro gcpro1
;
1705 if (NILP (buffer_or_name
))
1706 buffer
= Fcurrent_buffer ();
1708 buffer
= Fget_buffer (buffer_or_name
);
1710 nsberror (buffer_or_name
);
1712 b
= XBUFFER (buffer
);
1714 /* Avoid trouble for buffer already dead. */
1715 if (!BUFFER_LIVE_P (b
))
1718 /* Run hooks with the buffer to be killed the current buffer. */
1720 ptrdiff_t count
= SPECPDL_INDEX ();
1721 Lisp_Object arglist
[1];
1723 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1724 set_buffer_internal (b
);
1726 /* First run the query functions; if any query is answered no,
1727 don't kill the buffer. */
1728 arglist
[0] = Qkill_buffer_query_functions
;
1729 tem
= Frun_hook_with_args_until_failure (1, arglist
);
1731 return unbind_to (count
, Qnil
);
1733 /* Query if the buffer is still modified. */
1734 if (INTERACTIVE
&& !NILP (BVAR (b
, filename
))
1735 && BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
1738 tem
= do_yes_or_no_p (format2 ("Buffer %s modified; kill anyway? ",
1739 BVAR (b
, name
), make_number (0)));
1742 return unbind_to (count
, Qnil
);
1745 /* If the hooks have killed the buffer, exit now. */
1746 if (!BUFFER_LIVE_P (b
))
1747 return unbind_to (count
, Qt
);
1749 /* Then run the hooks. */
1750 Frun_hooks (1, &Qkill_buffer_hook
);
1751 unbind_to (count
, Qnil
);
1754 /* If the hooks have killed the buffer, exit now. */
1755 if (!BUFFER_LIVE_P (b
))
1758 /* We have no more questions to ask. Verify that it is valid
1759 to kill the buffer. This must be done after the questions
1760 since anything can happen within do_yes_or_no_p. */
1762 /* Don't kill the minibuffer now current. */
1763 if (EQ (buffer
, XWINDOW (minibuf_window
)->contents
))
1766 /* When we kill an ordinary buffer which shares it's buffer text
1767 with indirect buffer(s), we must kill indirect buffer(s) too.
1768 We do it at this stage so nothing terrible happens if they
1769 ask questions or their hooks get errors. */
1770 if (!b
->base_buffer
&& b
->indirections
> 0)
1772 struct buffer
*other
;
1776 FOR_EACH_BUFFER (other
)
1777 if (other
->base_buffer
== b
)
1780 XSETBUFFER (buf
, other
);
1786 /* Exit if we now have killed the base buffer (Bug#11665). */
1787 if (!BUFFER_LIVE_P (b
))
1791 /* Run replace_buffer_in_windows before making another buffer current
1792 since set-window-buffer-start-and-point will refuse to make another
1793 buffer current if the selected window does not show the current
1794 buffer (bug#10114). */
1795 replace_buffer_in_windows (buffer
);
1797 /* Exit if replacing the buffer in windows has killed our buffer. */
1798 if (!BUFFER_LIVE_P (b
))
1801 /* Make this buffer not be current. Exit if it is the sole visible
1803 if (b
== current_buffer
)
1805 tem
= Fother_buffer (buffer
, Qnil
, Qnil
);
1807 if (b
== current_buffer
)
1811 /* If the buffer now current is shown in the minibuffer and our buffer
1812 is the sole other buffer give up. */
1813 XSETBUFFER (tem
, current_buffer
);
1814 if (EQ (tem
, XWINDOW (minibuf_window
)->contents
)
1815 && EQ (buffer
, Fother_buffer (buffer
, Qnil
, Qnil
)))
1818 /* Now there is no question: we can kill the buffer. */
1820 /* Unlock this buffer's file, if it is locked. */
1824 kill_buffer_processes (buffer
);
1827 /* Killing buffer processes may run sentinels which may have killed
1829 if (!BUFFER_LIVE_P (b
))
1832 /* These may run Lisp code and into infinite loops (if someone
1833 insisted on circular lists) so allow quitting here. */
1834 frames_discard_buffer (buffer
);
1836 clear_charpos_cache (b
);
1838 tem
= Vinhibit_quit
;
1840 /* Remove the buffer from the list of all buffers. */
1841 Vbuffer_alist
= Fdelq (Frassq (buffer
, Vbuffer_alist
), Vbuffer_alist
);
1842 /* If replace_buffer_in_windows didn't do its job fix that now. */
1843 replace_buffer_in_windows_safely (buffer
);
1844 Vinhibit_quit
= tem
;
1846 /* Delete any auto-save file, if we saved it in this session.
1847 But not if the buffer is modified. */
1848 if (STRINGP (BVAR (b
, auto_save_file_name
))
1849 && BUF_AUTOSAVE_MODIFF (b
) != 0
1850 && BUF_SAVE_MODIFF (b
) < BUF_AUTOSAVE_MODIFF (b
)
1851 && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
)
1852 && NILP (Fsymbol_value (intern ("auto-save-visited-file-name"))))
1855 delete = Fsymbol_value (intern ("delete-auto-save-files"));
1856 if (! NILP (delete))
1857 internal_delete_file (BVAR (b
, auto_save_file_name
));
1860 /* Deleting an auto-save file could have killed our buffer. */
1861 if (!BUFFER_LIVE_P (b
))
1867 /* Unchain all markers that belong to this indirect buffer.
1868 Don't unchain the markers that belong to the base buffer
1869 or its other indirect buffers. */
1870 struct Lisp_Marker
**mp
= &BUF_MARKERS (b
);
1881 /* Intervals should be owned by the base buffer (Bug#16502). */
1882 i
= buffer_intervals (b
);
1886 XSETBUFFER (owner
, b
->base_buffer
);
1887 set_interval_object (i
, owner
);
1892 /* Unchain all markers of this buffer and its indirect buffers.
1893 and leave them pointing nowhere. */
1894 for (m
= BUF_MARKERS (b
); m
; )
1896 struct Lisp_Marker
*next
= m
->next
;
1901 BUF_MARKERS (b
) = NULL
;
1902 set_buffer_intervals (b
, NULL
);
1904 /* Perhaps we should explicitly free the interval tree here... */
1906 /* Since we've unlinked the markers, the overlays can't be here any more
1908 b
->overlays_before
= NULL
;
1909 b
->overlays_after
= NULL
;
1911 /* Reset the local variables, so that this buffer's local values
1912 won't be protected from GC. They would be protected
1913 if they happened to remain cached in their symbols.
1914 This gets rid of them for certain. */
1915 swap_out_buffer_local_variables (b
);
1916 reset_buffer_local_variables (b
, 1);
1918 bset_name (b
, Qnil
);
1923 /* Notify our base buffer that we don't share the text anymore. */
1924 eassert (b
->indirections
== -1);
1925 b
->base_buffer
->indirections
--;
1926 eassert (b
->base_buffer
->indirections
>= 0);
1927 /* Make sure that we wasn't confused. */
1928 eassert (b
->window_count
== -1);
1932 /* Make sure that no one shows us. */
1933 eassert (b
->window_count
== 0);
1934 /* No one shares our buffer text, can free it. */
1935 free_buffer_text (b
);
1938 if (b
->newline_cache
)
1940 free_region_cache (b
->newline_cache
);
1941 b
->newline_cache
= 0;
1943 if (b
->width_run_cache
)
1945 free_region_cache (b
->width_run_cache
);
1946 b
->width_run_cache
= 0;
1948 if (b
->bidi_paragraph_cache
)
1950 free_region_cache (b
->bidi_paragraph_cache
);
1951 b
->bidi_paragraph_cache
= 0;
1953 bset_width_table (b
, Qnil
);
1955 bset_undo_list (b
, Qnil
);
1957 /* Run buffer-list-update-hook. */
1958 if (!NILP (Vrun_hooks
))
1959 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1964 /* Move association for BUFFER to the front of buffer (a)lists. Since
1965 we do this each time BUFFER is selected visibly, the more recently
1966 selected buffers are always closer to the front of those lists. This
1967 means that other_buffer is more likely to choose a relevant buffer.
1969 Note that this moves BUFFER to the front of the buffer lists of the
1970 selected frame even if BUFFER is not shown there. If BUFFER is not
1971 shown in the selected frame, consider the present behavior a feature.
1972 `select-window' gets this right since it shows BUFFER in the selected
1973 window when calling us. */
1976 record_buffer (Lisp_Object buffer
)
1978 Lisp_Object aelt
, aelt_cons
, tem
;
1979 register struct frame
*f
= XFRAME (selected_frame
);
1981 CHECK_BUFFER (buffer
);
1983 /* Update Vbuffer_alist (we know that it has an entry for BUFFER).
1984 Don't allow quitting since this might leave the buffer list in an
1985 inconsistent state. */
1986 tem
= Vinhibit_quit
;
1988 aelt
= Frassq (buffer
, Vbuffer_alist
);
1989 aelt_cons
= Fmemq (aelt
, Vbuffer_alist
);
1990 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
1991 XSETCDR (aelt_cons
, Vbuffer_alist
);
1992 Vbuffer_alist
= aelt_cons
;
1993 Vinhibit_quit
= tem
;
1995 /* Update buffer list of selected frame. */
1996 fset_buffer_list (f
, Fcons (buffer
, Fdelq (buffer
, f
->buffer_list
)));
1997 fset_buried_buffer_list (f
, Fdelq (buffer
, f
->buried_buffer_list
));
1999 /* Run buffer-list-update-hook. */
2000 if (!NILP (Vrun_hooks
))
2001 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
2005 /* Move BUFFER to the end of the buffer (a)lists. Do nothing if the
2006 buffer is killed. For the selected frame's buffer list this moves
2007 BUFFER to its end even if it was never shown in that frame. If
2008 this happens we have a feature, hence `bury-buffer-internal' should be
2009 called only when BUFFER was shown in the selected frame. */
2011 DEFUN ("bury-buffer-internal", Fbury_buffer_internal
, Sbury_buffer_internal
,
2013 doc
: /* Move BUFFER to the end of the buffer list. */)
2014 (Lisp_Object buffer
)
2016 Lisp_Object aelt
, aelt_cons
, tem
;
2017 register struct frame
*f
= XFRAME (selected_frame
);
2019 CHECK_BUFFER (buffer
);
2021 /* Update Vbuffer_alist (we know that it has an entry for BUFFER).
2022 Don't allow quitting since this might leave the buffer list in an
2023 inconsistent state. */
2024 tem
= Vinhibit_quit
;
2026 aelt
= Frassq (buffer
, Vbuffer_alist
);
2027 aelt_cons
= Fmemq (aelt
, Vbuffer_alist
);
2028 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
2029 XSETCDR (aelt_cons
, Qnil
);
2030 Vbuffer_alist
= nconc2 (Vbuffer_alist
, aelt_cons
);
2031 Vinhibit_quit
= tem
;
2033 /* Update buffer lists of selected frame. */
2034 fset_buffer_list (f
, Fdelq (buffer
, f
->buffer_list
));
2035 fset_buried_buffer_list
2036 (f
, Fcons (buffer
, Fdelq (buffer
, f
->buried_buffer_list
)));
2038 /* Run buffer-list-update-hook. */
2039 if (!NILP (Vrun_hooks
))
2040 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
2045 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode
, Sset_buffer_major_mode
, 1, 1, 0,
2046 doc
: /* Set an appropriate major mode for BUFFER.
2047 For the *scratch* buffer, use `initial-major-mode', otherwise choose a mode
2048 according to the default value of `major-mode'.
2049 Use this function before selecting the buffer, since it may need to inspect
2050 the current buffer's major mode. */)
2051 (Lisp_Object buffer
)
2054 Lisp_Object function
;
2056 CHECK_BUFFER (buffer
);
2058 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
2059 error ("Attempt to set major mode for a dead buffer");
2061 if (strcmp (SSDATA (BVAR (XBUFFER (buffer
), name
)), "*scratch*") == 0)
2062 function
= find_symbol_value (intern ("initial-major-mode"));
2065 function
= BVAR (&buffer_defaults
, major_mode
);
2067 && NILP (Fget (BVAR (current_buffer
, major_mode
), Qmode_class
)))
2068 function
= BVAR (current_buffer
, major_mode
);
2071 if (NILP (function
) || EQ (function
, Qfundamental_mode
))
2074 count
= SPECPDL_INDEX ();
2076 /* To select a nonfundamental mode,
2077 select the buffer temporarily and then call the mode function. */
2079 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2081 Fset_buffer (buffer
);
2084 return unbind_to (count
, Qnil
);
2087 DEFUN ("current-buffer", Fcurrent_buffer
, Scurrent_buffer
, 0, 0, 0,
2088 doc
: /* Return the current buffer as a Lisp object. */)
2091 register Lisp_Object buf
;
2092 XSETBUFFER (buf
, current_buffer
);
2096 /* Set the current buffer to B, and do not set windows_or_buffers_changed.
2097 This is used by redisplay. */
2100 set_buffer_internal_1 (register struct buffer
*b
)
2102 register struct buffer
*old_buf
;
2103 register Lisp_Object tail
;
2105 #ifdef USE_MMAP_FOR_BUFFERS
2106 if (b
->text
->beg
== NULL
)
2107 enlarge_buffer_text (b
, 0);
2108 #endif /* USE_MMAP_FOR_BUFFERS */
2110 if (current_buffer
== b
)
2113 BUFFER_CHECK_INDIRECTION (b
);
2115 old_buf
= current_buffer
;
2117 last_known_column_point
= -1; /* Invalidate indentation cache. */
2121 /* Put the undo list back in the base buffer, so that it appears
2122 that an indirect buffer shares the undo list of its base. */
2123 if (old_buf
->base_buffer
)
2124 bset_undo_list (old_buf
->base_buffer
, BVAR (old_buf
, undo_list
));
2126 /* If the old current buffer has markers to record PT, BEGV and ZV
2127 when it is not current, update them now. */
2128 record_buffer_markers (old_buf
);
2131 /* Get the undo list from the base buffer, so that it appears
2132 that an indirect buffer shares the undo list of its base. */
2134 bset_undo_list (b
, BVAR (b
->base_buffer
, undo_list
));
2136 /* If the new current buffer has markers to record PT, BEGV and ZV
2137 when it is not current, fetch them now. */
2138 fetch_buffer_markers (b
);
2140 /* Look down buffer's list of local Lisp variables
2141 to find and update any that forward into C variables. */
2145 for (tail
= BVAR (b
, local_var_alist
); CONSP (tail
); tail
= XCDR (tail
))
2147 Lisp_Object var
= XCAR (XCAR (tail
));
2148 struct Lisp_Symbol
*sym
= XSYMBOL (var
);
2149 if (sym
->redirect
== SYMBOL_LOCALIZED
/* Just to be sure. */
2150 && SYMBOL_BLV (sym
)->fwd
)
2151 /* Just reference the variable
2152 to cause it to become set for this buffer. */
2153 Fsymbol_value (var
);
2156 /* Do the same with any others that were local to the previous buffer */
2157 while (b
!= old_buf
&& (b
= old_buf
, b
));
2160 /* Switch to buffer B temporarily for redisplay purposes.
2161 This avoids certain things that don't need to be done within redisplay. */
2164 set_buffer_temp (struct buffer
*b
)
2166 register struct buffer
*old_buf
;
2168 if (current_buffer
== b
)
2171 old_buf
= current_buffer
;
2174 /* If the old current buffer has markers to record PT, BEGV and ZV
2175 when it is not current, update them now. */
2176 record_buffer_markers (old_buf
);
2178 /* If the new current buffer has markers to record PT, BEGV and ZV
2179 when it is not current, fetch them now. */
2180 fetch_buffer_markers (b
);
2183 DEFUN ("set-buffer", Fset_buffer
, Sset_buffer
, 1, 1, 0,
2184 doc
: /* Make buffer BUFFER-OR-NAME current for editing operations.
2185 BUFFER-OR-NAME may be a buffer or the name of an existing buffer.
2186 See also `with-current-buffer' when you want to make a buffer current
2187 temporarily. This function does not display the buffer, so its effect
2188 ends when the current command terminates. Use `switch-to-buffer' or
2189 `pop-to-buffer' to switch buffers permanently.
2190 The return value is the buffer made current. */)
2191 (register Lisp_Object buffer_or_name
)
2193 register Lisp_Object buffer
;
2194 buffer
= Fget_buffer (buffer_or_name
);
2196 nsberror (buffer_or_name
);
2197 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
2198 error ("Selecting deleted buffer");
2199 set_buffer_internal (XBUFFER (buffer
));
2204 restore_buffer (Lisp_Object buffer_or_name
)
2206 Fset_buffer (buffer_or_name
);
2209 /* Set the current buffer to BUFFER provided if it is alive. */
2212 set_buffer_if_live (Lisp_Object buffer
)
2214 if (BUFFER_LIVE_P (XBUFFER (buffer
)))
2215 set_buffer_internal (XBUFFER (buffer
));
2218 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only
,
2219 Sbarf_if_buffer_read_only
, 0, 0, 0,
2220 doc
: /* Signal a `buffer-read-only' error if the current buffer is read-only. */)
2223 if (!NILP (BVAR (current_buffer
, read_only
))
2224 && NILP (Vinhibit_read_only
))
2225 xsignal1 (Qbuffer_read_only
, Fcurrent_buffer ());
2229 DEFUN ("erase-buffer", Ferase_buffer
, Serase_buffer
, 0, 0, "*",
2230 doc
: /* Delete the entire contents of the current buffer.
2231 Any narrowing restriction in effect (see `narrow-to-region') is removed,
2232 so the buffer is truly empty after this. */)
2239 current_buffer
->last_window_start
= 1;
2240 /* Prevent warnings, or suspension of auto saving, that would happen
2241 if future size is less than past size. Use of erase-buffer
2242 implies that the future text is not really related to the past text. */
2243 XSETFASTINT (BVAR (current_buffer
, save_length
), 0);
2248 validate_region (register Lisp_Object
*b
, register Lisp_Object
*e
)
2250 CHECK_NUMBER_COERCE_MARKER (*b
);
2251 CHECK_NUMBER_COERCE_MARKER (*e
);
2253 if (XINT (*b
) > XINT (*e
))
2256 tem
= *b
; *b
= *e
; *e
= tem
;
2259 if (! (BEGV
<= XINT (*b
) && XINT (*e
) <= ZV
))
2260 args_out_of_range_3 (Fcurrent_buffer (), *b
, *e
);
2263 /* Advance BYTE_POS up to a character boundary
2264 and return the adjusted position. */
2267 advance_to_char_boundary (ptrdiff_t byte_pos
)
2271 if (byte_pos
== BEG
)
2272 /* Beginning of buffer is always a character boundary. */
2275 c
= FETCH_BYTE (byte_pos
);
2276 if (! CHAR_HEAD_P (c
))
2278 /* We should advance BYTE_POS only when C is a constituent of a
2279 multibyte sequence. */
2280 ptrdiff_t orig_byte_pos
= byte_pos
;
2285 c
= FETCH_BYTE (byte_pos
);
2287 while (! CHAR_HEAD_P (c
) && byte_pos
> BEG
);
2289 if (byte_pos
< orig_byte_pos
)
2290 byte_pos
= orig_byte_pos
;
2291 /* If C is a constituent of a multibyte sequence, BYTE_POS was
2292 surely advance to the correct character boundary. If C is
2293 not, BYTE_POS was unchanged. */
2299 DEFUN ("buffer-swap-text", Fbuffer_swap_text
, Sbuffer_swap_text
,
2301 doc
: /* Swap the text between current buffer and BUFFER. */)
2302 (Lisp_Object buffer
)
2304 struct buffer
*other_buffer
;
2305 CHECK_BUFFER (buffer
);
2306 other_buffer
= XBUFFER (buffer
);
2308 if (!BUFFER_LIVE_P (other_buffer
))
2309 error ("Cannot swap a dead buffer's text");
2311 /* Actually, it probably works just fine.
2312 * if (other_buffer == current_buffer)
2313 * error ("Cannot swap a buffer's text with itself"); */
2315 /* Actually, this may be workable as well, tho probably only if they're
2317 if (other_buffer
->base_buffer
2318 || current_buffer
->base_buffer
)
2319 error ("Cannot swap indirect buffers's text");
2321 { /* This is probably harder to make work. */
2322 struct buffer
*other
;
2323 FOR_EACH_BUFFER (other
)
2324 if (other
->base_buffer
== other_buffer
2325 || other
->base_buffer
== current_buffer
)
2326 error ("One of the buffers to swap has indirect buffers");
2329 #define swapfield(field, type) \
2331 type tmp##field = other_buffer->field; \
2332 other_buffer->field = current_buffer->field; \
2333 current_buffer->field = tmp##field; \
2335 #define swapfield_(field, type) \
2337 type tmp##field = BVAR (other_buffer, field); \
2338 bset_##field (other_buffer, BVAR (current_buffer, field)); \
2339 bset_##field (current_buffer, tmp##field); \
2342 swapfield (own_text
, struct buffer_text
);
2343 eassert (current_buffer
->text
== ¤t_buffer
->own_text
);
2344 eassert (other_buffer
->text
== &other_buffer
->own_text
);
2346 r_alloc_reset_variable ((void **) ¤t_buffer
->own_text
.beg
,
2347 (void **) &other_buffer
->own_text
.beg
);
2348 r_alloc_reset_variable ((void **) &other_buffer
->own_text
.beg
,
2349 (void **) ¤t_buffer
->own_text
.beg
);
2350 #endif /* REL_ALLOC */
2352 swapfield (pt
, ptrdiff_t);
2353 swapfield (pt_byte
, ptrdiff_t);
2354 swapfield (begv
, ptrdiff_t);
2355 swapfield (begv_byte
, ptrdiff_t);
2356 swapfield (zv
, ptrdiff_t);
2357 swapfield (zv_byte
, ptrdiff_t);
2358 eassert (!current_buffer
->base_buffer
);
2359 eassert (!other_buffer
->base_buffer
);
2360 swapfield (indirections
, ptrdiff_t);
2361 current_buffer
->clip_changed
= 1; other_buffer
->clip_changed
= 1;
2362 swapfield (newline_cache
, struct region_cache
*);
2363 swapfield (width_run_cache
, struct region_cache
*);
2364 swapfield (bidi_paragraph_cache
, struct region_cache
*);
2365 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2366 other_buffer
->prevent_redisplay_optimizations_p
= 1;
2367 swapfield (overlays_before
, struct Lisp_Overlay
*);
2368 swapfield (overlays_after
, struct Lisp_Overlay
*);
2369 swapfield (overlay_center
, ptrdiff_t);
2370 swapfield_ (undo_list
, Lisp_Object
);
2371 swapfield_ (mark
, Lisp_Object
);
2372 swapfield_ (enable_multibyte_characters
, Lisp_Object
);
2373 swapfield_ (bidi_display_reordering
, Lisp_Object
);
2374 swapfield_ (bidi_paragraph_direction
, Lisp_Object
);
2375 /* FIXME: Not sure what we should do with these *_marker fields.
2376 Hopefully they're just nil anyway. */
2377 swapfield_ (pt_marker
, Lisp_Object
);
2378 swapfield_ (begv_marker
, Lisp_Object
);
2379 swapfield_ (zv_marker
, Lisp_Object
);
2380 bset_point_before_scroll (current_buffer
, Qnil
);
2381 bset_point_before_scroll (other_buffer
, Qnil
);
2383 current_buffer
->text
->modiff
++; other_buffer
->text
->modiff
++;
2384 current_buffer
->text
->chars_modiff
++; other_buffer
->text
->chars_modiff
++;
2385 current_buffer
->text
->overlay_modiff
++; other_buffer
->text
->overlay_modiff
++;
2386 current_buffer
->text
->beg_unchanged
= current_buffer
->text
->gpt
;
2387 current_buffer
->text
->end_unchanged
= current_buffer
->text
->gpt
;
2388 other_buffer
->text
->beg_unchanged
= other_buffer
->text
->gpt
;
2389 other_buffer
->text
->end_unchanged
= other_buffer
->text
->gpt
;
2391 struct Lisp_Marker
*m
;
2392 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
2393 if (m
->buffer
== other_buffer
)
2394 m
->buffer
= current_buffer
;
2396 /* Since there's no indirect buffer in sight, markers on
2397 BUF_MARKERS(buf) should either be for `buf' or dead. */
2398 eassert (!m
->buffer
);
2399 for (m
= BUF_MARKERS (other_buffer
); m
; m
= m
->next
)
2400 if (m
->buffer
== current_buffer
)
2401 m
->buffer
= other_buffer
;
2403 /* Since there's no indirect buffer in sight, markers on
2404 BUF_MARKERS(buf) should either be for `buf' or dead. */
2405 eassert (!m
->buffer
);
2407 { /* Some of the C code expects that both window markers of a
2408 live window points to that window's buffer. So since we
2409 just swapped the markers between the two buffers, we need
2410 to undo the effect of this swap for window markers. */
2411 Lisp_Object w
= selected_window
, ws
= Qnil
;
2412 Lisp_Object buf1
, buf2
;
2413 XSETBUFFER (buf1
, current_buffer
); XSETBUFFER (buf2
, other_buffer
);
2415 while (NILP (Fmemq (w
, ws
)))
2418 if (MARKERP (XWINDOW (w
)->pointm
)
2419 && (EQ (XWINDOW (w
)->contents
, buf1
)
2420 || EQ (XWINDOW (w
)->contents
, buf2
)))
2421 Fset_marker (XWINDOW (w
)->pointm
,
2423 (BUF_BEGV (XBUFFER (XWINDOW (w
)->contents
))),
2424 XWINDOW (w
)->contents
);
2425 if (MARKERP (XWINDOW (w
)->start
)
2426 && (EQ (XWINDOW (w
)->contents
, buf1
)
2427 || EQ (XWINDOW (w
)->contents
, buf2
)))
2428 Fset_marker (XWINDOW (w
)->start
,
2430 (XBUFFER (XWINDOW (w
)->contents
)->last_window_start
),
2431 XWINDOW (w
)->contents
);
2432 w
= Fnext_window (w
, Qt
, Qt
);
2436 if (current_buffer
->text
->intervals
)
2437 (eassert (EQ (current_buffer
->text
->intervals
->up
.obj
, buffer
)),
2438 XSETBUFFER (current_buffer
->text
->intervals
->up
.obj
, current_buffer
));
2439 if (other_buffer
->text
->intervals
)
2440 (eassert (EQ (other_buffer
->text
->intervals
->up
.obj
, Fcurrent_buffer ())),
2441 XSETBUFFER (other_buffer
->text
->intervals
->up
.obj
, other_buffer
));
2446 DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte
, Sset_buffer_multibyte
,
2448 doc
: /* Set the multibyte flag of the current buffer to FLAG.
2449 If FLAG is t, this makes the buffer a multibyte buffer.
2450 If FLAG is nil, this makes the buffer a single-byte buffer.
2451 In these cases, the buffer contents remain unchanged as a sequence of
2452 bytes but the contents viewed as characters do change.
2453 If FLAG is `to', this makes the buffer a multibyte buffer by changing
2454 all eight-bit bytes to eight-bit characters.
2455 If the multibyte flag was really changed, undo information of the
2456 current buffer is cleared. */)
2459 struct Lisp_Marker
*tail
, *markers
;
2460 struct buffer
*other
;
2462 bool narrowed
= (BEG
!= BEGV
|| Z
!= ZV
);
2463 bool modified_p
= !NILP (Fbuffer_modified_p (Qnil
));
2464 Lisp_Object old_undo
= BVAR (current_buffer
, undo_list
);
2465 struct gcpro gcpro1
;
2467 if (current_buffer
->base_buffer
)
2468 error ("Cannot do `set-buffer-multibyte' on an indirect buffer");
2470 /* Do nothing if nothing actually changes. */
2471 if (NILP (flag
) == NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
2476 /* Don't record these buffer changes. We will put a special undo entry
2478 bset_undo_list (current_buffer
, Qt
);
2480 /* If the cached position is for this buffer, clear it out. */
2481 clear_charpos_cache (current_buffer
);
2484 begv
= BEGV_BYTE
, zv
= ZV_BYTE
;
2486 begv
= BEGV
, zv
= ZV
;
2489 error ("Changing multibyteness in a narrowed buffer");
2491 invalidate_buffer_caches (current_buffer
, BEGV
, ZV
);
2495 ptrdiff_t pos
, stop
;
2498 /* Do this first, so it can use CHAR_TO_BYTE
2499 to calculate the old correspondences. */
2500 set_intervals_multibyte (0);
2502 bset_enable_multibyte_characters (current_buffer
, Qnil
);
2508 TEMP_SET_PT_BOTH (PT_BYTE
, PT_BYTE
);
2511 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
2512 tail
->charpos
= tail
->bytepos
;
2514 /* Convert multibyte form of 8-bit characters to unibyte. */
2529 if (ASCII_BYTE_P (*p
))
2531 else if (CHAR_BYTE8_HEAD_P (*p
))
2533 c
= STRING_CHAR_AND_LENGTH (p
, bytes
);
2534 /* Delete all bytes for this 8-bit character but the
2535 last one, and change the last one to the character
2538 del_range_2 (pos
, pos
, pos
+ bytes
, pos
+ bytes
, 0);
2550 bytes
= BYTES_BY_CHAR_HEAD (*p
);
2551 p
+= bytes
, pos
+= bytes
;
2555 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2560 ptrdiff_t pos
, stop
;
2561 unsigned char *p
, *pend
;
2563 /* Be sure not to have a multibyte sequence striding over the GAP.
2564 Ex: We change this: "...abc\302 _GAP_ \241def..."
2565 to: "...abc _GAP_ \302\241def..." */
2568 && GPT_BYTE
> 1 && GPT_BYTE
< Z_BYTE
2569 && ! CHAR_HEAD_P (*(GAP_END_ADDR
)))
2571 unsigned char *q
= GPT_ADDR
- 1;
2573 while (! CHAR_HEAD_P (*q
) && q
> BEG_ADDR
) q
--;
2574 if (LEADING_CODE_P (*q
))
2576 ptrdiff_t new_gpt
= GPT_BYTE
- (GPT_ADDR
- q
);
2578 move_gap_both (new_gpt
, new_gpt
);
2582 /* Make the buffer contents valid as multibyte by converting
2583 8-bit characters to multibyte form. */
2601 if (ASCII_BYTE_P (*p
))
2603 else if (EQ (flag
, Qt
)
2604 && ! CHAR_BYTE8_HEAD_P (*p
)
2605 && (bytes
= MULTIBYTE_LENGTH (p
, pend
)) > 0)
2606 p
+= bytes
, pos
+= bytes
;
2609 unsigned char tmp
[MAX_MULTIBYTE_LENGTH
];
2612 c
= BYTE8_TO_CHAR (*p
);
2613 bytes
= CHAR_STRING (c
, tmp
);
2615 TEMP_SET_PT_BOTH (pos
+ 1, pos
+ 1);
2617 insert_1_both ((char *) tmp
+ 1, bytes
, bytes
, 1, 0, 0);
2618 /* Now the gap is after the just inserted data. */
2636 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2638 /* Do this first, so that chars_in_text asks the right question.
2639 set_intervals_multibyte needs it too. */
2640 bset_enable_multibyte_characters (current_buffer
, Qt
);
2642 GPT_BYTE
= advance_to_char_boundary (GPT_BYTE
);
2643 GPT
= chars_in_text (BEG_ADDR
, GPT_BYTE
- BEG_BYTE
) + BEG
;
2645 Z
= chars_in_text (GAP_END_ADDR
, Z_BYTE
- GPT_BYTE
) + GPT
;
2647 BEGV_BYTE
= advance_to_char_boundary (BEGV_BYTE
);
2648 if (BEGV_BYTE
> GPT_BYTE
)
2649 BEGV
= chars_in_text (GAP_END_ADDR
, BEGV_BYTE
- GPT_BYTE
) + GPT
;
2651 BEGV
= chars_in_text (BEG_ADDR
, BEGV_BYTE
- BEG_BYTE
) + BEG
;
2653 ZV_BYTE
= advance_to_char_boundary (ZV_BYTE
);
2654 if (ZV_BYTE
> GPT_BYTE
)
2655 ZV
= chars_in_text (GAP_END_ADDR
, ZV_BYTE
- GPT_BYTE
) + GPT
;
2657 ZV
= chars_in_text (BEG_ADDR
, ZV_BYTE
- BEG_BYTE
) + BEG
;
2660 ptrdiff_t byte
= advance_to_char_boundary (PT_BYTE
);
2663 if (byte
> GPT_BYTE
)
2664 position
= chars_in_text (GAP_END_ADDR
, byte
- GPT_BYTE
) + GPT
;
2666 position
= chars_in_text (BEG_ADDR
, byte
- BEG_BYTE
) + BEG
;
2667 TEMP_SET_PT_BOTH (position
, byte
);
2670 tail
= markers
= BUF_MARKERS (current_buffer
);
2672 /* This prevents BYTE_TO_CHAR (that is, buf_bytepos_to_charpos) from
2673 getting confused by the markers that have not yet been updated.
2674 It is also a signal that it should never create a marker. */
2675 BUF_MARKERS (current_buffer
) = NULL
;
2677 for (; tail
; tail
= tail
->next
)
2679 tail
->bytepos
= advance_to_char_boundary (tail
->bytepos
);
2680 tail
->charpos
= BYTE_TO_CHAR (tail
->bytepos
);
2683 /* Make sure no markers were put on the chain
2684 while the chain value was incorrect. */
2685 if (BUF_MARKERS (current_buffer
))
2688 BUF_MARKERS (current_buffer
) = markers
;
2690 /* Do this last, so it can calculate the new correspondences
2691 between chars and bytes. */
2692 set_intervals_multibyte (1);
2695 if (!EQ (old_undo
, Qt
))
2697 /* Represent all the above changes by a special undo entry. */
2698 bset_undo_list (current_buffer
,
2699 Fcons (list3 (Qapply
,
2700 intern ("set-buffer-multibyte"),
2701 NILP (flag
) ? Qt
: Qnil
),
2707 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2709 /* If buffer is shown in a window, let redisplay consider other windows. */
2710 if (buffer_window_count (current_buffer
))
2711 windows_or_buffers_changed
= 10;
2713 /* Copy this buffer's new multibyte status
2714 into all of its indirect buffers. */
2715 FOR_EACH_BUFFER (other
)
2716 if (other
->base_buffer
== current_buffer
&& BUFFER_LIVE_P (other
))
2718 BVAR (other
, enable_multibyte_characters
)
2719 = BVAR (current_buffer
, enable_multibyte_characters
);
2720 other
->prevent_redisplay_optimizations_p
= 1;
2723 /* Restore the modifiedness of the buffer. */
2724 if (!modified_p
&& !NILP (Fbuffer_modified_p (Qnil
)))
2725 Fset_buffer_modified_p (Qnil
);
2727 /* Update coding systems of this buffer's process (if any). */
2729 Lisp_Object process
;
2731 process
= Fget_buffer_process (Fcurrent_buffer ());
2732 if (PROCESSP (process
))
2733 setup_process_coding_systems (process
);
2739 DEFUN ("kill-all-local-variables", Fkill_all_local_variables
,
2740 Skill_all_local_variables
, 0, 0, 0,
2741 doc
: /* Switch to Fundamental mode by killing current buffer's local variables.
2742 Most local variable bindings are eliminated so that the default values
2743 become effective once more. Also, the syntax table is set from
2744 `standard-syntax-table', the local keymap is set to nil,
2745 and the abbrev table from `fundamental-mode-abbrev-table'.
2746 This function also forces redisplay of the mode line.
2748 Every function to select a new major mode starts by
2749 calling this function.
2751 As a special exception, local variables whose names have
2752 a non-nil `permanent-local' property are not eliminated by this function.
2754 The first thing this function does is run
2755 the normal hook `change-major-mode-hook'. */)
2758 Frun_hooks (1, &Qchange_major_mode_hook
);
2760 /* Make sure none of the bindings in local_var_alist
2761 remain swapped in, in their symbols. */
2763 swap_out_buffer_local_variables (current_buffer
);
2765 /* Actually eliminate all local bindings of this buffer. */
2767 reset_buffer_local_variables (current_buffer
, 0);
2769 /* Force mode-line redisplay. Useful here because all major mode
2770 commands call this function. */
2771 update_mode_lines
= 12;
2776 /* Make sure no local variables remain set up with buffer B
2777 for their current values. */
2780 swap_out_buffer_local_variables (struct buffer
*b
)
2782 Lisp_Object oalist
, alist
, buffer
;
2784 XSETBUFFER (buffer
, b
);
2785 oalist
= BVAR (b
, local_var_alist
);
2787 for (alist
= oalist
; CONSP (alist
); alist
= XCDR (alist
))
2789 Lisp_Object sym
= XCAR (XCAR (alist
));
2790 eassert (XSYMBOL (sym
)->redirect
== SYMBOL_LOCALIZED
);
2791 /* Need not do anything if some other buffer's binding is
2793 if (EQ (SYMBOL_BLV (XSYMBOL (sym
))->where
, buffer
))
2795 /* Symbol is set up for this buffer's old local value:
2797 swap_in_global_binding (XSYMBOL (sym
));
2802 /* Find all the overlays in the current buffer that contain position POS.
2803 Return the number found, and store them in a vector in *VEC_PTR.
2804 Store in *LEN_PTR the size allocated for the vector.
2805 Store in *NEXT_PTR the next position after POS where an overlay starts,
2806 or ZV if there are no more overlays between POS and ZV.
2807 Store in *PREV_PTR the previous position before POS where an overlay ends,
2808 or where an overlay starts which ends at or after POS;
2809 or BEGV if there are no such overlays from BEGV to POS.
2810 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2812 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2813 when this function is called.
2815 If EXTEND, make the vector bigger if necessary.
2816 If not, never extend the vector,
2817 and store only as many overlays as will fit.
2818 But still return the total number of overlays.
2820 If CHANGE_REQ, any position written into *PREV_PTR or
2821 *NEXT_PTR is guaranteed to be not equal to POS, unless it is the
2822 default (BEGV or ZV). */
2825 overlays_at (EMACS_INT pos
, bool extend
, Lisp_Object
**vec_ptr
,
2827 ptrdiff_t *next_ptr
, ptrdiff_t *prev_ptr
, bool change_req
)
2829 Lisp_Object overlay
, start
, end
;
2830 struct Lisp_Overlay
*tail
;
2832 ptrdiff_t len
= *len_ptr
;
2833 Lisp_Object
*vec
= *vec_ptr
;
2834 ptrdiff_t next
= ZV
;
2835 ptrdiff_t prev
= BEGV
;
2836 bool inhibit_storing
= 0;
2838 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2840 ptrdiff_t startpos
, endpos
;
2842 XSETMISC (overlay
, tail
);
2844 start
= OVERLAY_START (overlay
);
2845 end
= OVERLAY_END (overlay
);
2846 endpos
= OVERLAY_POSITION (end
);
2853 startpos
= OVERLAY_POSITION (start
);
2854 /* This one ends at or after POS
2855 so its start counts for PREV_PTR if it's before POS. */
2856 if (prev
< startpos
&& startpos
< pos
)
2860 if (startpos
<= pos
)
2864 /* The supplied vector is full.
2865 Either make it bigger, or don't store any more in it. */
2868 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2874 inhibit_storing
= 1;
2877 if (!inhibit_storing
)
2879 /* Keep counting overlays even if we can't return them all. */
2882 else if (startpos
< next
)
2886 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2888 ptrdiff_t startpos
, endpos
;
2890 XSETMISC (overlay
, tail
);
2892 start
= OVERLAY_START (overlay
);
2893 end
= OVERLAY_END (overlay
);
2894 startpos
= OVERLAY_POSITION (start
);
2897 if (startpos
< next
)
2901 endpos
= OVERLAY_POSITION (end
);
2908 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2914 inhibit_storing
= 1;
2917 if (!inhibit_storing
)
2921 if (startpos
< pos
&& startpos
> prev
)
2924 else if (endpos
< pos
&& endpos
> prev
)
2926 else if (endpos
== pos
&& startpos
> prev
2927 && (!change_req
|| startpos
< pos
))
2938 /* Find all the overlays in the current buffer that overlap the range
2939 BEG-END, or are empty at BEG, or are empty at END provided END
2940 denotes the position at the end of the current buffer.
2942 Return the number found, and store them in a vector in *VEC_PTR.
2943 Store in *LEN_PTR the size allocated for the vector.
2944 Store in *NEXT_PTR the next position after POS where an overlay starts,
2945 or ZV if there are no more overlays.
2946 Store in *PREV_PTR the previous position before POS where an overlay ends,
2947 or BEGV if there are no previous overlays.
2948 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2950 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2951 when this function is called.
2953 If EXTEND, make the vector bigger if necessary.
2954 If not, never extend the vector,
2955 and store only as many overlays as will fit.
2956 But still return the total number of overlays. */
2959 overlays_in (EMACS_INT beg
, EMACS_INT end
, bool extend
,
2960 Lisp_Object
**vec_ptr
, ptrdiff_t *len_ptr
,
2961 ptrdiff_t *next_ptr
, ptrdiff_t *prev_ptr
)
2963 Lisp_Object overlay
, ostart
, oend
;
2964 struct Lisp_Overlay
*tail
;
2966 ptrdiff_t len
= *len_ptr
;
2967 Lisp_Object
*vec
= *vec_ptr
;
2968 ptrdiff_t next
= ZV
;
2969 ptrdiff_t prev
= BEGV
;
2970 bool inhibit_storing
= 0;
2971 bool end_is_Z
= end
== Z
;
2973 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2975 ptrdiff_t startpos
, endpos
;
2977 XSETMISC (overlay
, tail
);
2979 ostart
= OVERLAY_START (overlay
);
2980 oend
= OVERLAY_END (overlay
);
2981 endpos
= OVERLAY_POSITION (oend
);
2988 startpos
= OVERLAY_POSITION (ostart
);
2989 /* Count an interval if it overlaps the range, is empty at the
2990 start of the range, or is empty at END provided END denotes the
2991 end of the buffer. */
2992 if ((beg
< endpos
&& startpos
< end
)
2993 || (startpos
== endpos
2994 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
2998 /* The supplied vector is full.
2999 Either make it bigger, or don't store any more in it. */
3002 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
3008 inhibit_storing
= 1;
3011 if (!inhibit_storing
)
3013 /* Keep counting overlays even if we can't return them all. */
3016 else if (startpos
< next
)
3020 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
3022 ptrdiff_t startpos
, endpos
;
3024 XSETMISC (overlay
, tail
);
3026 ostart
= OVERLAY_START (overlay
);
3027 oend
= OVERLAY_END (overlay
);
3028 startpos
= OVERLAY_POSITION (ostart
);
3031 if (startpos
< next
)
3035 endpos
= OVERLAY_POSITION (oend
);
3036 /* Count an interval if it overlaps the range, is empty at the
3037 start of the range, or is empty at END provided END denotes the
3038 end of the buffer. */
3039 if ((beg
< endpos
&& startpos
< end
)
3040 || (startpos
== endpos
3041 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
3047 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
3053 inhibit_storing
= 1;
3056 if (!inhibit_storing
)
3060 else if (endpos
< beg
&& endpos
> prev
)
3072 /* Return true if there exists an overlay with a non-nil
3073 `mouse-face' property overlapping OVERLAY. */
3076 mouse_face_overlay_overlaps (Lisp_Object overlay
)
3078 ptrdiff_t start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3079 ptrdiff_t end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3080 ptrdiff_t n
, i
, size
;
3081 Lisp_Object
*v
, tem
;
3084 v
= alloca (size
* sizeof *v
);
3085 n
= overlays_in (start
, end
, 0, &v
, &size
, NULL
, NULL
);
3088 v
= alloca (n
* sizeof *v
);
3089 overlays_in (start
, end
, 0, &v
, &n
, NULL
, NULL
);
3092 for (i
= 0; i
< n
; ++i
)
3093 if (!EQ (v
[i
], overlay
)
3094 && (tem
= Foverlay_get (overlay
, Qmouse_face
),
3103 /* Fast function to just test if we're at an overlay boundary. */
3105 overlay_touches_p (ptrdiff_t pos
)
3107 Lisp_Object overlay
;
3108 struct Lisp_Overlay
*tail
;
3110 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
3114 XSETMISC (overlay
,tail
);
3115 eassert (OVERLAYP (overlay
));
3117 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3120 if (endpos
== pos
|| OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
)
3124 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
3128 XSETMISC (overlay
, tail
);
3129 eassert (OVERLAYP (overlay
));
3131 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3134 if (startpos
== pos
|| OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
)
3142 Lisp_Object overlay
;
3145 EMACS_INT spriority
; /* Secondary priority. */
3149 compare_overlays (const void *v1
, const void *v2
)
3151 const struct sortvec
*s1
= v1
;
3152 const struct sortvec
*s2
= v2
;
3153 /* Return 1 if s1 should take precedence, -1 if v2 should take precedence,
3154 and 0 if they're equal. */
3155 if (s1
->priority
!= s2
->priority
)
3156 return s1
->priority
< s2
->priority
? -1 : 1;
3157 /* If the priority is equal, give precedence to the one not covered by the
3158 other. If neither covers the other, obey spriority. */
3159 else if (s1
->beg
< s2
->beg
)
3160 return (s1
->end
< s2
->end
&& s1
->spriority
> s2
->spriority
? 1 : -1);
3161 else if (s1
->beg
> s2
->beg
)
3162 return (s1
->end
> s2
->end
&& s1
->spriority
< s2
->spriority
? -1 : 1);
3163 else if (s1
->end
!= s2
->end
)
3164 return s2
->end
< s1
->end
? -1 : 1;
3165 else if (s1
->spriority
!= s2
->spriority
)
3166 return (s1
->spriority
< s2
->spriority
? -1 : 1);
3167 else if (EQ (s1
->overlay
, s2
->overlay
))
3170 /* Avoid the non-determinism of qsort by choosing an arbitrary ordering
3171 between "equal" overlays. The result can still change between
3172 invocations of Emacs, but it won't change in the middle of
3173 `find_field' (bug#6830). */
3174 return XLI (s1
->overlay
) < XLI (s2
->overlay
) ? -1 : 1;
3177 /* Sort an array of overlays by priority. The array is modified in place.
3178 The return value is the new size; this may be smaller than the original
3179 size if some of the overlays were invalid or were window-specific. */
3181 sort_overlays (Lisp_Object
*overlay_vec
, ptrdiff_t noverlays
, struct window
*w
)
3185 struct sortvec
*sortvec
;
3187 SAFE_NALLOCA (sortvec
, 1, noverlays
);
3189 /* Put the valid and relevant overlays into sortvec. */
3191 for (i
= 0, j
= 0; i
< noverlays
; i
++)
3194 Lisp_Object overlay
;
3196 overlay
= overlay_vec
[i
];
3197 if (OVERLAYP (overlay
)
3198 && OVERLAY_POSITION (OVERLAY_START (overlay
)) > 0
3199 && OVERLAY_POSITION (OVERLAY_END (overlay
)) > 0)
3201 /* If we're interested in a specific window, then ignore
3202 overlays that are limited to some other window. */
3207 window
= Foverlay_get (overlay
, Qwindow
);
3208 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3212 /* This overlay is good and counts: put it into sortvec. */
3213 sortvec
[j
].overlay
= overlay
;
3214 sortvec
[j
].beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3215 sortvec
[j
].end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3216 tem
= Foverlay_get (overlay
, Qpriority
);
3219 sortvec
[j
].priority
= 0;
3220 sortvec
[j
].spriority
= 0;
3222 else if (INTEGERP (tem
))
3224 sortvec
[j
].priority
= XINT (tem
);
3225 sortvec
[j
].spriority
= 0;
3227 else if (CONSP (tem
))
3229 Lisp_Object car
= XCAR (tem
);
3230 Lisp_Object cdr
= XCDR (tem
);
3231 sortvec
[j
].priority
= INTEGERP (car
) ? XINT (car
) : 0;
3232 sortvec
[j
].spriority
= INTEGERP (cdr
) ? XINT (cdr
) : 0;
3239 /* Sort the overlays into the proper order: increasing priority. */
3242 qsort (sortvec
, noverlays
, sizeof (struct sortvec
), compare_overlays
);
3244 for (i
= 0; i
< noverlays
; i
++)
3245 overlay_vec
[i
] = sortvec
[i
].overlay
;
3253 Lisp_Object string
, string2
;
3260 struct sortstr
*buf
; /* An array that expands as needed; never freed. */
3261 ptrdiff_t size
; /* Allocated length of that array. */
3262 ptrdiff_t used
; /* How much of the array is currently in use. */
3263 ptrdiff_t bytes
; /* Total length of the strings in buf. */
3266 /* Buffers for storing information about the overlays touching a given
3267 position. These could be automatic variables in overlay_strings, but
3268 it's more efficient to hold onto the memory instead of repeatedly
3269 allocating and freeing it. */
3270 static struct sortstrlist overlay_heads
, overlay_tails
;
3271 static unsigned char *overlay_str_buf
;
3273 /* Allocated length of overlay_str_buf. */
3274 static ptrdiff_t overlay_str_len
;
3276 /* A comparison function suitable for passing to qsort. */
3278 cmp_for_strings (const void *as1
, const void *as2
)
3280 struct sortstr
const *s1
= as1
;
3281 struct sortstr
const *s2
= as2
;
3282 if (s1
->size
!= s2
->size
)
3283 return s2
->size
< s1
->size
? -1 : 1;
3284 if (s1
->priority
!= s2
->priority
)
3285 return s1
->priority
< s2
->priority
? -1 : 1;
3290 record_overlay_string (struct sortstrlist
*ssl
, Lisp_Object str
,
3291 Lisp_Object str2
, Lisp_Object pri
, ptrdiff_t size
)
3295 if (ssl
->used
== ssl
->size
)
3296 ssl
->buf
= xpalloc (ssl
->buf
, &ssl
->size
, 5, -1, sizeof *ssl
->buf
);
3297 ssl
->buf
[ssl
->used
].string
= str
;
3298 ssl
->buf
[ssl
->used
].string2
= str2
;
3299 ssl
->buf
[ssl
->used
].size
= size
;
3300 ssl
->buf
[ssl
->used
].priority
= (INTEGERP (pri
) ? XINT (pri
) : 0);
3303 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3304 nbytes
= SCHARS (str
);
3305 else if (! STRING_MULTIBYTE (str
))
3306 nbytes
= count_size_as_multibyte (SDATA (str
),
3309 nbytes
= SBYTES (str
);
3311 if (INT_ADD_OVERFLOW (ssl
->bytes
, nbytes
))
3312 memory_full (SIZE_MAX
);
3313 ssl
->bytes
+= nbytes
;
3317 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3318 nbytes
= SCHARS (str2
);
3319 else if (! STRING_MULTIBYTE (str2
))
3320 nbytes
= count_size_as_multibyte (SDATA (str2
),
3323 nbytes
= SBYTES (str2
);
3325 if (INT_ADD_OVERFLOW (ssl
->bytes
, nbytes
))
3326 memory_full (SIZE_MAX
);
3327 ssl
->bytes
+= nbytes
;
3331 /* Return the concatenation of the strings associated with overlays that
3332 begin or end at POS, ignoring overlays that are specific to a window
3333 other than W. The strings are concatenated in the appropriate order:
3334 shorter overlays nest inside longer ones, and higher priority inside
3335 lower. Normally all of the after-strings come first, but zero-sized
3336 overlays have their after-strings ride along with the before-strings
3337 because it would look strange to print them inside-out.
3339 Returns the string length, and stores the contents indirectly through
3340 PSTR, if that variable is non-null. The string may be overwritten by
3341 subsequent calls. */
3344 overlay_strings (ptrdiff_t pos
, struct window
*w
, unsigned char **pstr
)
3346 Lisp_Object overlay
, window
, str
;
3347 struct Lisp_Overlay
*ov
;
3348 ptrdiff_t startpos
, endpos
;
3349 bool multibyte
= ! NILP (BVAR (current_buffer
, enable_multibyte_characters
));
3351 overlay_heads
.used
= overlay_heads
.bytes
= 0;
3352 overlay_tails
.used
= overlay_tails
.bytes
= 0;
3353 for (ov
= current_buffer
->overlays_before
; ov
; ov
= ov
->next
)
3355 XSETMISC (overlay
, ov
);
3356 eassert (OVERLAYP (overlay
));
3358 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3359 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3362 if (endpos
!= pos
&& startpos
!= pos
)
3364 window
= Foverlay_get (overlay
, Qwindow
);
3365 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3368 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3369 record_overlay_string (&overlay_heads
, str
,
3371 ? Foverlay_get (overlay
, Qafter_string
)
3373 Foverlay_get (overlay
, Qpriority
),
3375 else if (endpos
== pos
3376 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3377 record_overlay_string (&overlay_tails
, str
, Qnil
,
3378 Foverlay_get (overlay
, Qpriority
),
3381 for (ov
= current_buffer
->overlays_after
; ov
; ov
= ov
->next
)
3383 XSETMISC (overlay
, ov
);
3384 eassert (OVERLAYP (overlay
));
3386 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3387 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3390 if (endpos
!= pos
&& startpos
!= pos
)
3392 window
= Foverlay_get (overlay
, Qwindow
);
3393 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3396 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3397 record_overlay_string (&overlay_heads
, str
,
3399 ? Foverlay_get (overlay
, Qafter_string
)
3401 Foverlay_get (overlay
, Qpriority
),
3403 else if (endpos
== pos
3404 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3405 record_overlay_string (&overlay_tails
, str
, Qnil
,
3406 Foverlay_get (overlay
, Qpriority
),
3409 if (overlay_tails
.used
> 1)
3410 qsort (overlay_tails
.buf
, overlay_tails
.used
, sizeof (struct sortstr
),
3412 if (overlay_heads
.used
> 1)
3413 qsort (overlay_heads
.buf
, overlay_heads
.used
, sizeof (struct sortstr
),
3415 if (overlay_heads
.bytes
|| overlay_tails
.bytes
)
3422 if (INT_ADD_OVERFLOW (overlay_heads
.bytes
, overlay_tails
.bytes
))
3423 memory_full (SIZE_MAX
);
3424 total
= overlay_heads
.bytes
+ overlay_tails
.bytes
;
3425 if (total
> overlay_str_len
)
3426 overlay_str_buf
= xpalloc (overlay_str_buf
, &overlay_str_len
,
3427 total
- overlay_str_len
, -1, 1);
3429 p
= overlay_str_buf
;
3430 for (i
= overlay_tails
.used
; --i
>= 0;)
3433 tem
= overlay_tails
.buf
[i
].string
;
3434 nbytes
= copy_text (SDATA (tem
), p
,
3436 STRING_MULTIBYTE (tem
), multibyte
);
3439 for (i
= 0; i
< overlay_heads
.used
; ++i
)
3442 tem
= overlay_heads
.buf
[i
].string
;
3443 nbytes
= copy_text (SDATA (tem
), p
,
3445 STRING_MULTIBYTE (tem
), multibyte
);
3447 tem
= overlay_heads
.buf
[i
].string2
;
3450 nbytes
= copy_text (SDATA (tem
), p
,
3452 STRING_MULTIBYTE (tem
), multibyte
);
3456 if (p
!= overlay_str_buf
+ total
)
3459 *pstr
= overlay_str_buf
;
3465 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
3468 recenter_overlay_lists (struct buffer
*buf
, ptrdiff_t pos
)
3470 Lisp_Object overlay
, beg
, end
;
3471 struct Lisp_Overlay
*prev
, *tail
, *next
;
3473 /* See if anything in overlays_before should move to overlays_after. */
3475 /* We don't strictly need prev in this loop; it should always be nil.
3476 But we use it for symmetry and in case that should cease to be true
3477 with some future change. */
3479 for (tail
= buf
->overlays_before
; tail
; prev
= tail
, tail
= next
)
3482 XSETMISC (overlay
, tail
);
3483 eassert (OVERLAYP (overlay
));
3485 beg
= OVERLAY_START (overlay
);
3486 end
= OVERLAY_END (overlay
);
3488 if (OVERLAY_POSITION (end
) > pos
)
3490 /* OVERLAY needs to be moved. */
3491 ptrdiff_t where
= OVERLAY_POSITION (beg
);
3492 struct Lisp_Overlay
*other
, *other_prev
;
3494 /* Splice the cons cell TAIL out of overlays_before. */
3498 set_buffer_overlays_before (buf
, next
);
3500 /* Search thru overlays_after for where to put it. */
3502 for (other
= buf
->overlays_after
; other
;
3503 other_prev
= other
, other
= other
->next
)
3505 Lisp_Object otherbeg
, otheroverlay
;
3507 XSETMISC (otheroverlay
, other
);
3508 eassert (OVERLAYP (otheroverlay
));
3510 otherbeg
= OVERLAY_START (otheroverlay
);
3511 if (OVERLAY_POSITION (otherbeg
) >= where
)
3515 /* Add TAIL to overlays_after before OTHER. */
3518 other_prev
->next
= tail
;
3520 set_buffer_overlays_after (buf
, tail
);
3524 /* We've reached the things that should stay in overlays_before.
3525 All the rest of overlays_before must end even earlier,
3530 /* See if anything in overlays_after should be in overlays_before. */
3532 for (tail
= buf
->overlays_after
; tail
; prev
= tail
, tail
= next
)
3535 XSETMISC (overlay
, tail
);
3536 eassert (OVERLAYP (overlay
));
3538 beg
= OVERLAY_START (overlay
);
3539 end
= OVERLAY_END (overlay
);
3541 /* Stop looking, when we know that nothing further
3542 can possibly end before POS. */
3543 if (OVERLAY_POSITION (beg
) > pos
)
3546 if (OVERLAY_POSITION (end
) <= pos
)
3548 /* OVERLAY needs to be moved. */
3549 ptrdiff_t where
= OVERLAY_POSITION (end
);
3550 struct Lisp_Overlay
*other
, *other_prev
;
3552 /* Splice the cons cell TAIL out of overlays_after. */
3556 set_buffer_overlays_after (buf
, next
);
3558 /* Search thru overlays_before for where to put it. */
3560 for (other
= buf
->overlays_before
; other
;
3561 other_prev
= other
, other
= other
->next
)
3563 Lisp_Object otherend
, otheroverlay
;
3565 XSETMISC (otheroverlay
, other
);
3566 eassert (OVERLAYP (otheroverlay
));
3568 otherend
= OVERLAY_END (otheroverlay
);
3569 if (OVERLAY_POSITION (otherend
) <= where
)
3573 /* Add TAIL to overlays_before before OTHER. */
3576 other_prev
->next
= tail
;
3578 set_buffer_overlays_before (buf
, tail
);
3583 buf
->overlay_center
= pos
;
3587 adjust_overlays_for_insert (ptrdiff_t pos
, ptrdiff_t length
)
3589 /* After an insertion, the lists are still sorted properly,
3590 but we may need to update the value of the overlay center. */
3591 if (current_buffer
->overlay_center
>= pos
)
3592 current_buffer
->overlay_center
+= length
;
3596 adjust_overlays_for_delete (ptrdiff_t pos
, ptrdiff_t length
)
3598 if (current_buffer
->overlay_center
< pos
)
3599 /* The deletion was to our right. No change needed; the before- and
3600 after-lists are still consistent. */
3602 else if (current_buffer
->overlay_center
- pos
> length
)
3603 /* The deletion was to our left. We need to adjust the center value
3604 to account for the change in position, but the lists are consistent
3605 given the new value. */
3606 current_buffer
->overlay_center
-= length
;
3608 /* We're right in the middle. There might be things on the after-list
3609 that now belong on the before-list. Recentering will move them,
3610 and also update the center point. */
3611 recenter_overlay_lists (current_buffer
, pos
);
3614 /* Fix up overlays that were garbled as a result of permuting markers
3615 in the range START through END. Any overlay with at least one
3616 endpoint in this range will need to be unlinked from the overlay
3617 list and reinserted in its proper place.
3618 Such an overlay might even have negative size at this point.
3619 If so, we'll make the overlay empty. */
3621 fix_start_end_in_overlays (register ptrdiff_t start
, register ptrdiff_t end
)
3623 Lisp_Object overlay
;
3624 struct Lisp_Overlay
*before_list
IF_LINT (= NULL
);
3625 struct Lisp_Overlay
*after_list
IF_LINT (= NULL
);
3626 /* These are either nil, indicating that before_list or after_list
3627 should be assigned, or the cons cell the cdr of which should be
3629 struct Lisp_Overlay
*beforep
= NULL
, *afterp
= NULL
;
3630 /* 'Parent', likewise, indicates a cons cell or
3631 current_buffer->overlays_before or overlays_after, depending
3632 which loop we're in. */
3633 struct Lisp_Overlay
*tail
, *parent
;
3634 ptrdiff_t startpos
, endpos
;
3636 /* This algorithm shifts links around instead of consing and GCing.
3637 The loop invariant is that before_list (resp. after_list) is a
3638 well-formed list except that its last element, the CDR of beforep
3639 (resp. afterp) if beforep (afterp) isn't nil or before_list
3640 (after_list) if it is, is still uninitialized. So it's not a bug
3641 that before_list isn't initialized, although it may look
3643 for (parent
= NULL
, tail
= current_buffer
->overlays_before
; tail
;)
3645 XSETMISC (overlay
, tail
);
3647 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3648 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3650 /* If the overlay is backwards, make it empty. */
3651 if (endpos
< startpos
)
3654 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3662 || (startpos
>= start
&& startpos
< end
))
3664 /* Add it to the end of the wrong list. Later on,
3665 recenter_overlay_lists will move it to the right place. */
3666 if (endpos
< current_buffer
->overlay_center
)
3671 afterp
->next
= tail
;
3679 beforep
->next
= tail
;
3683 set_buffer_overlays_before (current_buffer
, tail
->next
);
3685 parent
->next
= tail
->next
;
3689 parent
= tail
, tail
= parent
->next
;
3691 for (parent
= NULL
, tail
= current_buffer
->overlays_after
; tail
;)
3693 XSETMISC (overlay
, tail
);
3695 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3696 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3698 /* If the overlay is backwards, make it empty. */
3699 if (endpos
< startpos
)
3702 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3706 if (startpos
>= end
)
3709 if (startpos
>= start
3710 || (endpos
>= start
&& endpos
< end
))
3712 if (endpos
< current_buffer
->overlay_center
)
3717 afterp
->next
= tail
;
3725 beforep
->next
= tail
;
3729 set_buffer_overlays_after (current_buffer
, tail
->next
);
3731 parent
->next
= tail
->next
;
3735 parent
= tail
, tail
= parent
->next
;
3738 /* Splice the constructed (wrong) lists into the buffer's lists,
3739 and let the recenter function make it sane again. */
3742 beforep
->next
= current_buffer
->overlays_before
;
3743 set_buffer_overlays_before (current_buffer
, before_list
);
3748 afterp
->next
= current_buffer
->overlays_after
;
3749 set_buffer_overlays_after (current_buffer
, after_list
);
3751 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3754 /* We have two types of overlay: the one whose ending marker is
3755 after-insertion-marker (this is the usual case) and the one whose
3756 ending marker is before-insertion-marker. When `overlays_before'
3757 contains overlays of the latter type and the former type in this
3758 order and both overlays end at inserting position, inserting a text
3759 increases only the ending marker of the latter type, which results
3760 in incorrect ordering of `overlays_before'.
3762 This function fixes ordering of overlays in the slot
3763 `overlays_before' of the buffer *BP. Before the insertion, `point'
3764 was at PREV, and now is at POS. */
3767 fix_overlays_before (struct buffer
*bp
, ptrdiff_t prev
, ptrdiff_t pos
)
3769 /* If parent is nil, replace overlays_before; otherwise, parent->next. */
3770 struct Lisp_Overlay
*tail
= bp
->overlays_before
, *parent
= NULL
, *right_pair
;
3772 ptrdiff_t end
IF_LINT (= 0);
3774 /* After the insertion, the several overlays may be in incorrect
3775 order. The possibility is that, in the list `overlays_before',
3776 an overlay which ends at POS appears after an overlay which ends
3777 at PREV. Since POS is greater than PREV, we must fix the
3778 ordering of these overlays, by moving overlays ends at POS before
3779 the overlays ends at PREV. */
3781 /* At first, find a place where disordered overlays should be linked
3782 in. It is where an overlay which end before POS exists. (i.e. an
3783 overlay whose ending marker is after-insertion-marker if disorder
3786 && (XSETMISC (tem
, tail
),
3787 (end
= OVERLAY_POSITION (OVERLAY_END (tem
))) >= pos
))
3793 /* If we don't find such an overlay,
3794 or the found one ends before PREV,
3795 or the found one is the last one in the list,
3796 we don't have to fix anything. */
3797 if (!tail
|| end
< prev
|| !tail
->next
)
3800 right_pair
= parent
;
3804 /* Now, end position of overlays in the list TAIL should be before
3805 or equal to PREV. In the loop, an overlay which ends at POS is
3806 moved ahead to the place indicated by the CDR of RIGHT_PAIR. If
3807 we found an overlay which ends before PREV, the remaining
3808 overlays are in correct order. */
3811 XSETMISC (tem
, tail
);
3812 end
= OVERLAY_POSITION (OVERLAY_END (tem
));
3815 { /* This overlay is disordered. */
3816 struct Lisp_Overlay
*found
= tail
;
3818 /* Unlink the found overlay. */
3820 parent
->next
= tail
;
3821 /* Move an overlay at RIGHT_PLACE to the next of the found one,
3822 and link it into the right place. */
3825 found
->next
= bp
->overlays_before
;
3826 set_buffer_overlays_before (bp
, found
);
3830 found
->next
= right_pair
->next
;
3831 right_pair
->next
= found
;
3834 else if (end
== prev
)
3839 else /* No more disordered overlay. */
3844 DEFUN ("overlayp", Foverlayp
, Soverlayp
, 1, 1, 0,
3845 doc
: /* Return t if OBJECT is an overlay. */)
3846 (Lisp_Object object
)
3848 return (OVERLAYP (object
) ? Qt
: Qnil
);
3851 DEFUN ("make-overlay", Fmake_overlay
, Smake_overlay
, 2, 5, 0,
3852 doc
: /* Create a new overlay with range BEG to END in BUFFER and return it.
3853 If omitted, BUFFER defaults to the current buffer.
3854 BEG and END may be integers or markers.
3855 The fourth arg FRONT-ADVANCE, if non-nil, makes the marker
3856 for the front of the overlay advance when text is inserted there
3857 \(which means the text *is not* included in the overlay).
3858 The fifth arg REAR-ADVANCE, if non-nil, makes the marker
3859 for the rear of the overlay advance when text is inserted there
3860 \(which means the text *is* included in the overlay). */)
3861 (Lisp_Object beg
, Lisp_Object end
, Lisp_Object buffer
,
3862 Lisp_Object front_advance
, Lisp_Object rear_advance
)
3864 Lisp_Object overlay
;
3868 XSETBUFFER (buffer
, current_buffer
);
3870 CHECK_BUFFER (buffer
);
3872 if (MARKERP (beg
) && !EQ (Fmarker_buffer (beg
), buffer
))
3873 signal_error ("Marker points into wrong buffer", beg
);
3874 if (MARKERP (end
) && !EQ (Fmarker_buffer (end
), buffer
))
3875 signal_error ("Marker points into wrong buffer", end
);
3877 CHECK_NUMBER_COERCE_MARKER (beg
);
3878 CHECK_NUMBER_COERCE_MARKER (end
);
3880 if (XINT (beg
) > XINT (end
))
3883 temp
= beg
; beg
= end
; end
= temp
;
3886 b
= XBUFFER (buffer
);
3888 beg
= Fset_marker (Fmake_marker (), beg
, buffer
);
3889 end
= Fset_marker (Fmake_marker (), end
, buffer
);
3891 if (!NILP (front_advance
))
3892 XMARKER (beg
)->insertion_type
= 1;
3893 if (!NILP (rear_advance
))
3894 XMARKER (end
)->insertion_type
= 1;
3896 overlay
= build_overlay (beg
, end
, Qnil
);
3898 /* Put the new overlay on the wrong list. */
3899 end
= OVERLAY_END (overlay
);
3900 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
3902 eassert (b
->overlays_after
|| (XOVERLAY (overlay
)->next
== NULL
));
3903 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3904 set_buffer_overlays_after (b
, XOVERLAY (overlay
));
3908 eassert (b
->overlays_before
|| (XOVERLAY (overlay
)->next
== NULL
));
3909 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3910 set_buffer_overlays_before (b
, XOVERLAY (overlay
));
3912 /* This puts it in the right list, and in the right order. */
3913 recenter_overlay_lists (b
, b
->overlay_center
);
3915 /* We don't need to redisplay the region covered by the overlay, because
3916 the overlay has no properties at the moment. */
3921 /* Mark a section of BUF as needing redisplay because of overlays changes. */
3924 modify_overlay (struct buffer
*buf
, ptrdiff_t start
, ptrdiff_t end
)
3928 ptrdiff_t temp
= start
;
3933 BUF_COMPUTE_UNCHANGED (buf
, start
, end
);
3935 bset_redisplay (buf
);
3937 ++BUF_OVERLAY_MODIFF (buf
);
3940 /* Remove OVERLAY from LIST. */
3942 static struct Lisp_Overlay
*
3943 unchain_overlay (struct Lisp_Overlay
*list
, struct Lisp_Overlay
*overlay
)
3945 register struct Lisp_Overlay
*tail
, **prev
= &list
;
3947 for (tail
= list
; tail
; prev
= &tail
->next
, tail
= *prev
)
3948 if (tail
== overlay
)
3950 *prev
= overlay
->next
;
3951 overlay
->next
= NULL
;
3957 /* Remove OVERLAY from both overlay lists of B. */
3960 unchain_both (struct buffer
*b
, Lisp_Object overlay
)
3962 struct Lisp_Overlay
*ov
= XOVERLAY (overlay
);
3964 set_buffer_overlays_before (b
, unchain_overlay (b
->overlays_before
, ov
));
3965 set_buffer_overlays_after (b
, unchain_overlay (b
->overlays_after
, ov
));
3966 eassert (XOVERLAY (overlay
)->next
== NULL
);
3969 DEFUN ("move-overlay", Fmove_overlay
, Smove_overlay
, 3, 4, 0,
3970 doc
: /* Set the endpoints of OVERLAY to BEG and END in BUFFER.
3971 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.
3972 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current
3974 (Lisp_Object overlay
, Lisp_Object beg
, Lisp_Object end
, Lisp_Object buffer
)
3976 struct buffer
*b
, *ob
= 0;
3977 Lisp_Object obuffer
;
3978 ptrdiff_t count
= SPECPDL_INDEX ();
3979 ptrdiff_t n_beg
, n_end
, o_beg
IF_LINT (= 0), o_end
IF_LINT (= 0);
3981 CHECK_OVERLAY (overlay
);
3983 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3985 XSETBUFFER (buffer
, current_buffer
);
3986 CHECK_BUFFER (buffer
);
3988 if (NILP (Fbuffer_live_p (buffer
)))
3989 error ("Attempt to move overlay to a dead buffer");
3991 if (MARKERP (beg
) && !EQ (Fmarker_buffer (beg
), buffer
))
3992 signal_error ("Marker points into wrong buffer", beg
);
3993 if (MARKERP (end
) && !EQ (Fmarker_buffer (end
), buffer
))
3994 signal_error ("Marker points into wrong buffer", end
);
3996 CHECK_NUMBER_COERCE_MARKER (beg
);
3997 CHECK_NUMBER_COERCE_MARKER (end
);
3999 if (XINT (beg
) > XINT (end
))
4002 temp
= beg
; beg
= end
; end
= temp
;
4005 specbind (Qinhibit_quit
, Qt
);
4007 obuffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4008 b
= XBUFFER (buffer
);
4010 if (!NILP (obuffer
))
4012 ob
= XBUFFER (obuffer
);
4014 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4015 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4017 unchain_both (ob
, overlay
);
4020 /* Set the overlay boundaries, which may clip them. */
4021 Fset_marker (OVERLAY_START (overlay
), beg
, buffer
);
4022 Fset_marker (OVERLAY_END (overlay
), end
, buffer
);
4024 n_beg
= marker_position (OVERLAY_START (overlay
));
4025 n_end
= marker_position (OVERLAY_END (overlay
));
4027 /* If the overlay has changed buffers, do a thorough redisplay. */
4028 if (!EQ (buffer
, obuffer
))
4030 /* Redisplay where the overlay was. */
4032 modify_overlay (ob
, o_beg
, o_end
);
4034 /* Redisplay where the overlay is going to be. */
4035 modify_overlay (b
, n_beg
, n_end
);
4038 /* Redisplay the area the overlay has just left, or just enclosed. */
4041 modify_overlay (b
, o_end
, n_end
);
4042 else if (o_end
== n_end
)
4043 modify_overlay (b
, o_beg
, n_beg
);
4045 modify_overlay (b
, min (o_beg
, n_beg
), max (o_end
, n_end
));
4048 /* Delete the overlay if it is empty after clipping and has the
4049 evaporate property. */
4050 if (n_beg
== n_end
&& !NILP (Foverlay_get (overlay
, Qevaporate
)))
4051 return unbind_to (count
, Fdelete_overlay (overlay
));
4053 /* Put the overlay into the new buffer's overlay lists, first on the
4055 if (n_end
< b
->overlay_center
)
4057 XOVERLAY (overlay
)->next
= b
->overlays_after
;
4058 set_buffer_overlays_after (b
, XOVERLAY (overlay
));
4062 XOVERLAY (overlay
)->next
= b
->overlays_before
;
4063 set_buffer_overlays_before (b
, XOVERLAY (overlay
));
4066 /* This puts it in the right list, and in the right order. */
4067 recenter_overlay_lists (b
, b
->overlay_center
);
4069 return unbind_to (count
, overlay
);
4072 DEFUN ("delete-overlay", Fdelete_overlay
, Sdelete_overlay
, 1, 1, 0,
4073 doc
: /* Delete the overlay OVERLAY from its buffer. */)
4074 (Lisp_Object overlay
)
4078 ptrdiff_t count
= SPECPDL_INDEX ();
4080 CHECK_OVERLAY (overlay
);
4082 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4086 b
= XBUFFER (buffer
);
4087 specbind (Qinhibit_quit
, Qt
);
4089 unchain_both (b
, overlay
);
4090 drop_overlay (b
, XOVERLAY (overlay
));
4092 /* When deleting an overlay with before or after strings, turn off
4093 display optimizations for the affected buffer, on the basis that
4094 these strings may contain newlines. This is easier to do than to
4095 check for that situation during redisplay. */
4096 if (!windows_or_buffers_changed
4097 && (!NILP (Foverlay_get (overlay
, Qbefore_string
))
4098 || !NILP (Foverlay_get (overlay
, Qafter_string
))))
4099 b
->prevent_redisplay_optimizations_p
= 1;
4101 return unbind_to (count
, Qnil
);
4104 DEFUN ("delete-all-overlays", Fdelete_all_overlays
, Sdelete_all_overlays
, 0, 1, 0,
4105 doc
: /* Delete all overlays of BUFFER.
4106 BUFFER omitted or nil means delete all overlays of the current
4108 (Lisp_Object buffer
)
4110 register struct buffer
*buf
;
4113 buf
= current_buffer
;
4116 CHECK_BUFFER (buffer
);
4117 buf
= XBUFFER (buffer
);
4120 delete_all_overlays (buf
);
4124 /* Overlay dissection functions. */
4126 DEFUN ("overlay-start", Foverlay_start
, Soverlay_start
, 1, 1, 0,
4127 doc
: /* Return the position at which OVERLAY starts. */)
4128 (Lisp_Object overlay
)
4130 CHECK_OVERLAY (overlay
);
4132 return (Fmarker_position (OVERLAY_START (overlay
)));
4135 DEFUN ("overlay-end", Foverlay_end
, Soverlay_end
, 1, 1, 0,
4136 doc
: /* Return the position at which OVERLAY ends. */)
4137 (Lisp_Object overlay
)
4139 CHECK_OVERLAY (overlay
);
4141 return (Fmarker_position (OVERLAY_END (overlay
)));
4144 DEFUN ("overlay-buffer", Foverlay_buffer
, Soverlay_buffer
, 1, 1, 0,
4145 doc
: /* Return the buffer OVERLAY belongs to.
4146 Return nil if OVERLAY has been deleted. */)
4147 (Lisp_Object overlay
)
4149 CHECK_OVERLAY (overlay
);
4151 return Fmarker_buffer (OVERLAY_START (overlay
));
4154 DEFUN ("overlay-properties", Foverlay_properties
, Soverlay_properties
, 1, 1, 0,
4155 doc
: /* Return a list of the properties on OVERLAY.
4156 This is a copy of OVERLAY's plist; modifying its conses has no effect on
4158 (Lisp_Object overlay
)
4160 CHECK_OVERLAY (overlay
);
4162 return Fcopy_sequence (XOVERLAY (overlay
)->plist
);
4166 DEFUN ("overlays-at", Foverlays_at
, Soverlays_at
, 1, 2, 0,
4167 doc
: /* Return a list of the overlays that contain the character at POS.
4168 If SORTED is non-nil, then sort them by decreasing priority. */)
4169 (Lisp_Object pos
, Lisp_Object sorted
)
4171 ptrdiff_t len
, noverlays
;
4172 Lisp_Object
*overlay_vec
;
4175 CHECK_NUMBER_COERCE_MARKER (pos
);
4177 if (!buffer_has_overlays ())
4181 /* We can't use alloca here because overlays_at can call xrealloc. */
4182 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4184 /* Put all the overlays we want in a vector in overlay_vec.
4185 Store the length in len. */
4186 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4190 noverlays
= sort_overlays (overlay_vec
, noverlays
,
4191 WINDOWP (sorted
) ? XWINDOW (sorted
) : NULL
);
4193 /* Make a list of them all. */
4194 result
= Flist (noverlays
, overlay_vec
);
4196 xfree (overlay_vec
);
4200 DEFUN ("overlays-in", Foverlays_in
, Soverlays_in
, 2, 2, 0,
4201 doc
: /* Return a list of the overlays that overlap the region BEG ... END.
4202 Overlap means that at least one character is contained within the overlay
4203 and also contained within the specified region.
4204 Empty overlays are included in the result if they are located at BEG,
4205 between BEG and END, or at END provided END denotes the position at the
4206 end of the buffer. */)
4207 (Lisp_Object beg
, Lisp_Object end
)
4209 ptrdiff_t len
, noverlays
;
4210 Lisp_Object
*overlay_vec
;
4213 CHECK_NUMBER_COERCE_MARKER (beg
);
4214 CHECK_NUMBER_COERCE_MARKER (end
);
4216 if (!buffer_has_overlays ())
4220 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4222 /* Put all the overlays we want in a vector in overlay_vec.
4223 Store the length in len. */
4224 noverlays
= overlays_in (XINT (beg
), XINT (end
), 1, &overlay_vec
, &len
,
4227 /* Make a list of them all. */
4228 result
= Flist (noverlays
, overlay_vec
);
4230 xfree (overlay_vec
);
4234 DEFUN ("next-overlay-change", Fnext_overlay_change
, Snext_overlay_change
,
4236 doc
: /* Return the next position after POS where an overlay starts or ends.
4237 If there are no overlay boundaries from POS to (point-max),
4238 the value is (point-max). */)
4241 ptrdiff_t i
, len
, noverlays
;
4243 Lisp_Object
*overlay_vec
;
4245 CHECK_NUMBER_COERCE_MARKER (pos
);
4247 if (!buffer_has_overlays ())
4248 return make_number (ZV
);
4251 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4253 /* Put all the overlays we want in a vector in overlay_vec.
4254 Store the length in len.
4255 endpos gets the position where the next overlay starts. */
4256 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4259 /* If any of these overlays ends before endpos,
4260 use its ending point instead. */
4261 for (i
= 0; i
< noverlays
; i
++)
4266 oend
= OVERLAY_END (overlay_vec
[i
]);
4267 oendpos
= OVERLAY_POSITION (oend
);
4268 if (oendpos
< endpos
)
4272 xfree (overlay_vec
);
4273 return make_number (endpos
);
4276 DEFUN ("previous-overlay-change", Fprevious_overlay_change
,
4277 Sprevious_overlay_change
, 1, 1, 0,
4278 doc
: /* Return the previous position before POS where an overlay starts or ends.
4279 If there are no overlay boundaries from (point-min) to POS,
4280 the value is (point-min). */)
4284 Lisp_Object
*overlay_vec
;
4287 CHECK_NUMBER_COERCE_MARKER (pos
);
4289 if (!buffer_has_overlays ())
4290 return make_number (BEGV
);
4292 /* At beginning of buffer, we know the answer;
4293 avoid bug subtracting 1 below. */
4294 if (XINT (pos
) == BEGV
)
4298 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4300 /* Put all the overlays we want in a vector in overlay_vec.
4301 Store the length in len.
4302 prevpos gets the position of the previous change. */
4303 overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4306 xfree (overlay_vec
);
4307 return make_number (prevpos
);
4310 /* These functions are for debugging overlays. */
4312 DEFUN ("overlay-lists", Foverlay_lists
, Soverlay_lists
, 0, 0, 0,
4313 doc
: /* Return a pair of lists giving all the overlays of the current buffer.
4314 The car has all the overlays before the overlay center;
4315 the cdr has all the overlays after the overlay center.
4316 Recentering overlays moves overlays between these lists.
4317 The lists you get are copies, so that changing them has no effect.
4318 However, the overlays you get are the real objects that the buffer uses. */)
4321 struct Lisp_Overlay
*ol
;
4322 Lisp_Object before
= Qnil
, after
= Qnil
, tmp
;
4324 for (ol
= current_buffer
->overlays_before
; ol
; ol
= ol
->next
)
4327 before
= Fcons (tmp
, before
);
4329 for (ol
= current_buffer
->overlays_after
; ol
; ol
= ol
->next
)
4332 after
= Fcons (tmp
, after
);
4335 return Fcons (Fnreverse (before
), Fnreverse (after
));
4338 DEFUN ("overlay-recenter", Foverlay_recenter
, Soverlay_recenter
, 1, 1, 0,
4339 doc
: /* Recenter the overlays of the current buffer around position POS.
4340 That makes overlay lookup faster for positions near POS (but perhaps slower
4341 for positions far away from POS). */)
4345 CHECK_NUMBER_COERCE_MARKER (pos
);
4347 p
= clip_to_bounds (PTRDIFF_MIN
, XINT (pos
), PTRDIFF_MAX
);
4348 recenter_overlay_lists (current_buffer
, p
);
4352 DEFUN ("overlay-get", Foverlay_get
, Soverlay_get
, 2, 2, 0,
4353 doc
: /* Get the property of overlay OVERLAY with property name PROP. */)
4354 (Lisp_Object overlay
, Lisp_Object prop
)
4356 CHECK_OVERLAY (overlay
);
4357 return lookup_char_property (XOVERLAY (overlay
)->plist
, prop
, 0);
4360 DEFUN ("overlay-put", Foverlay_put
, Soverlay_put
, 3, 3, 0,
4361 doc
: /* Set one property of overlay OVERLAY: give property PROP value VALUE.
4362 VALUE will be returned.*/)
4363 (Lisp_Object overlay
, Lisp_Object prop
, Lisp_Object value
)
4365 Lisp_Object tail
, buffer
;
4368 CHECK_OVERLAY (overlay
);
4370 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4372 for (tail
= XOVERLAY (overlay
)->plist
;
4373 CONSP (tail
) && CONSP (XCDR (tail
));
4374 tail
= XCDR (XCDR (tail
)))
4375 if (EQ (XCAR (tail
), prop
))
4377 changed
= !EQ (XCAR (XCDR (tail
)), value
);
4378 XSETCAR (XCDR (tail
), value
);
4381 /* It wasn't in the list, so add it to the front. */
4382 changed
= !NILP (value
);
4384 (overlay
, Fcons (prop
, Fcons (value
, XOVERLAY (overlay
)->plist
)));
4386 if (! NILP (buffer
))
4389 modify_overlay (XBUFFER (buffer
),
4390 marker_position (OVERLAY_START (overlay
)),
4391 marker_position (OVERLAY_END (overlay
)));
4392 if (EQ (prop
, Qevaporate
) && ! NILP (value
)
4393 && (OVERLAY_POSITION (OVERLAY_START (overlay
))
4394 == OVERLAY_POSITION (OVERLAY_END (overlay
))))
4395 Fdelete_overlay (overlay
);
4401 /* Subroutine of report_overlay_modification. */
4403 /* Lisp vector holding overlay hook functions to call.
4404 Vector elements come in pairs.
4405 Each even-index element is a list of hook functions.
4406 The following odd-index element is the overlay they came from.
4408 Before the buffer change, we fill in this vector
4409 as we call overlay hook functions.
4410 After the buffer change, we get the functions to call from this vector.
4411 This way we always call the same functions before and after the change. */
4412 static Lisp_Object last_overlay_modification_hooks
;
4414 /* Number of elements actually used in last_overlay_modification_hooks. */
4415 static ptrdiff_t last_overlay_modification_hooks_used
;
4417 /* Add one functionlist/overlay pair
4418 to the end of last_overlay_modification_hooks. */
4421 add_overlay_mod_hooklist (Lisp_Object functionlist
, Lisp_Object overlay
)
4423 ptrdiff_t oldsize
= ASIZE (last_overlay_modification_hooks
);
4425 if (oldsize
- 1 <= last_overlay_modification_hooks_used
)
4426 last_overlay_modification_hooks
=
4427 larger_vector (last_overlay_modification_hooks
, 2, -1);
4428 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4429 functionlist
); last_overlay_modification_hooks_used
++;
4430 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4431 overlay
); last_overlay_modification_hooks_used
++;
4434 /* Run the modification-hooks of overlays that include
4435 any part of the text in START to END.
4436 If this change is an insertion, also
4437 run the insert-before-hooks of overlay starting at END,
4438 and the insert-after-hooks of overlay ending at START.
4440 This is called both before and after the modification.
4441 AFTER is true when we call after the modification.
4443 ARG1, ARG2, ARG3 are arguments to pass to the hook functions.
4444 When AFTER is nonzero, they are the start position,
4445 the position after the inserted new text,
4446 and the length of deleted or replaced old text. */
4449 report_overlay_modification (Lisp_Object start
, Lisp_Object end
, bool after
,
4450 Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
)
4452 Lisp_Object prop
, overlay
;
4453 struct Lisp_Overlay
*tail
;
4454 /* True if this change is an insertion. */
4455 bool insertion
= (after
? XFASTINT (arg3
) == 0 : EQ (start
, end
));
4456 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4461 /* We used to run the functions as soon as we found them and only register
4462 them in last_overlay_modification_hooks for the purpose of the `after'
4463 case. But running elisp code as we traverse the list of overlays is
4464 painful because the list can be modified by the elisp code so we had to
4465 copy at several places. We now simply do a read-only traversal that
4466 only collects the functions to run and we run them afterwards. It's
4467 simpler, especially since all the code was already there. -stef */
4471 /* We are being called before a change.
4472 Scan the overlays to find the functions to call. */
4473 last_overlay_modification_hooks_used
= 0;
4474 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4476 ptrdiff_t startpos
, endpos
;
4477 Lisp_Object ostart
, oend
;
4479 XSETMISC (overlay
, tail
);
4481 ostart
= OVERLAY_START (overlay
);
4482 oend
= OVERLAY_END (overlay
);
4483 endpos
= OVERLAY_POSITION (oend
);
4484 if (XFASTINT (start
) > endpos
)
4486 startpos
= OVERLAY_POSITION (ostart
);
4487 if (insertion
&& (XFASTINT (start
) == startpos
4488 || XFASTINT (end
) == startpos
))
4490 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4492 add_overlay_mod_hooklist (prop
, overlay
);
4494 if (insertion
&& (XFASTINT (start
) == endpos
4495 || XFASTINT (end
) == endpos
))
4497 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4499 add_overlay_mod_hooklist (prop
, overlay
);
4501 /* Test for intersecting intervals. This does the right thing
4502 for both insertion and deletion. */
4503 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4505 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4507 add_overlay_mod_hooklist (prop
, overlay
);
4511 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4513 ptrdiff_t startpos
, endpos
;
4514 Lisp_Object ostart
, oend
;
4516 XSETMISC (overlay
, tail
);
4518 ostart
= OVERLAY_START (overlay
);
4519 oend
= OVERLAY_END (overlay
);
4520 startpos
= OVERLAY_POSITION (ostart
);
4521 endpos
= OVERLAY_POSITION (oend
);
4522 if (XFASTINT (end
) < startpos
)
4524 if (insertion
&& (XFASTINT (start
) == startpos
4525 || XFASTINT (end
) == startpos
))
4527 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4529 add_overlay_mod_hooklist (prop
, overlay
);
4531 if (insertion
&& (XFASTINT (start
) == endpos
4532 || XFASTINT (end
) == endpos
))
4534 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4536 add_overlay_mod_hooklist (prop
, overlay
);
4538 /* Test for intersecting intervals. This does the right thing
4539 for both insertion and deletion. */
4540 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4542 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4544 add_overlay_mod_hooklist (prop
, overlay
);
4549 GCPRO4 (overlay
, arg1
, arg2
, arg3
);
4551 /* Call the functions recorded in last_overlay_modification_hooks.
4552 First copy the vector contents, in case some of these hooks
4553 do subsequent modification of the buffer. */
4554 ptrdiff_t size
= last_overlay_modification_hooks_used
;
4555 Lisp_Object
*copy
= alloca (size
* sizeof *copy
);
4558 memcpy (copy
, XVECTOR (last_overlay_modification_hooks
)->contents
,
4561 gcpro1
.nvars
= size
;
4563 for (i
= 0; i
< size
;)
4565 Lisp_Object prop_i
, overlay_i
;
4567 overlay_i
= copy
[i
++];
4568 call_overlay_mod_hooks (prop_i
, overlay_i
, after
, arg1
, arg2
, arg3
);
4575 call_overlay_mod_hooks (Lisp_Object list
, Lisp_Object overlay
, bool after
,
4576 Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
)
4578 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4580 GCPRO4 (list
, arg1
, arg2
, arg3
);
4582 while (CONSP (list
))
4585 call4 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
);
4587 call5 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
, arg3
);
4593 /* Delete any zero-sized overlays at position POS, if the `evaporate'
4596 evaporate_overlays (ptrdiff_t pos
)
4598 Lisp_Object overlay
, hit_list
;
4599 struct Lisp_Overlay
*tail
;
4602 if (pos
<= current_buffer
->overlay_center
)
4603 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4606 XSETMISC (overlay
, tail
);
4607 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4610 if (endpos
== pos
&& OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
4611 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4612 hit_list
= Fcons (overlay
, hit_list
);
4615 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4618 XSETMISC (overlay
, tail
);
4619 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4622 if (startpos
== pos
&& OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
4623 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4624 hit_list
= Fcons (overlay
, hit_list
);
4626 for (; CONSP (hit_list
); hit_list
= XCDR (hit_list
))
4627 Fdelete_overlay (XCAR (hit_list
));
4630 /***********************************************************************
4631 Allocation with mmap
4632 ***********************************************************************/
4634 #ifdef USE_MMAP_FOR_BUFFERS
4636 #include <sys/mman.h>
4639 #ifdef MAP_ANONYMOUS
4640 #define MAP_ANON MAP_ANONYMOUS
4647 #define MAP_FAILED ((void *) -1)
4657 /* Memory is allocated in regions which are mapped using mmap(2).
4658 The current implementation lets the system select mapped
4659 addresses; we're not using MAP_FIXED in general, except when
4660 trying to enlarge regions.
4662 Each mapped region starts with a mmap_region structure, the user
4663 area starts after that structure, aligned to MEM_ALIGN.
4665 +-----------------------+
4666 | struct mmap_info + |
4668 +-----------------------+
4672 +-----------------------+ */
4676 /* User-specified size. */
4677 size_t nbytes_specified
;
4679 /* Number of bytes mapped */
4680 size_t nbytes_mapped
;
4682 /* Pointer to the location holding the address of the memory
4683 allocated with the mmap'd block. The variable actually points
4684 after this structure. */
4687 /* Next and previous in list of all mmap'd regions. */
4688 struct mmap_region
*next
, *prev
;
4691 /* Doubly-linked list of mmap'd regions. */
4693 static struct mmap_region
*mmap_regions
;
4695 /* File descriptor for mmap. If we don't have anonymous mapping,
4696 /dev/zero will be opened on it. */
4700 /* Temporary storage for mmap_set_vars, see there. */
4702 static struct mmap_region
*mmap_regions_1
;
4703 static int mmap_fd_1
;
4705 /* Page size on this system. */
4707 static int mmap_page_size
;
4709 /* 1 means mmap has been initialized. */
4711 static bool mmap_initialized_p
;
4713 /* Value is X rounded up to the next multiple of N. */
4715 #define ROUND(X, N) (((X) + (N) - 1) / (N) * (N))
4717 /* Size of mmap_region structure plus padding. */
4719 #define MMAP_REGION_STRUCT_SIZE \
4720 ROUND (sizeof (struct mmap_region), MEM_ALIGN)
4722 /* Given a pointer P to the start of the user-visible part of a mapped
4723 region, return a pointer to the start of the region. */
4725 #define MMAP_REGION(P) \
4726 ((struct mmap_region *) ((char *) (P) - MMAP_REGION_STRUCT_SIZE))
4728 /* Given a pointer P to the start of a mapped region, return a pointer
4729 to the start of the user-visible part of the region. */
4731 #define MMAP_USER_AREA(P) \
4732 ((void *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
4734 #define MEM_ALIGN sizeof (double)
4736 /* Predicate returning true if part of the address range [START .. END]
4737 is currently mapped. Used to prevent overwriting an existing
4740 Default is to conservatively assume the address range is occupied by
4741 something else. This can be overridden by system configuration
4742 files if system-specific means to determine this exists. */
4744 #ifndef MMAP_ALLOCATED_P
4745 #define MMAP_ALLOCATED_P(start, end) 1
4748 /* Perform necessary initializations for the use of mmap. */
4754 /* The value of mmap_fd is initially 0 in temacs, and -1
4755 in a dumped Emacs. */
4758 /* No anonymous mmap -- we need the file descriptor. */
4759 mmap_fd
= emacs_open ("/dev/zero", O_RDONLY
, 0);
4761 fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno
));
4763 #endif /* MAP_ANON == 0 */
4765 if (mmap_initialized_p
)
4767 mmap_initialized_p
= 1;
4773 mmap_page_size
= getpagesize ();
4776 /* Return a region overlapping address range START...END, or null if
4777 none. END is not including, i.e. the last byte in the range
4780 static struct mmap_region
*
4781 mmap_find (void *start
, void *end
)
4783 struct mmap_region
*r
;
4784 char *s
= start
, *e
= end
;
4786 for (r
= mmap_regions
; r
; r
= r
->next
)
4788 char *rstart
= (char *) r
;
4789 char *rend
= rstart
+ r
->nbytes_mapped
;
4791 if (/* First byte of range, i.e. START, in this region? */
4792 (s
>= rstart
&& s
< rend
)
4793 /* Last byte of range, i.e. END - 1, in this region? */
4794 || (e
> rstart
&& e
<= rend
)
4795 /* First byte of this region in the range? */
4796 || (rstart
>= s
&& rstart
< e
)
4797 /* Last byte of this region in the range? */
4798 || (rend
> s
&& rend
<= e
))
4806 /* Unmap a region. P is a pointer to the start of the user-araa of
4810 mmap_free_1 (struct mmap_region
*r
)
4813 r
->next
->prev
= r
->prev
;
4815 r
->prev
->next
= r
->next
;
4817 mmap_regions
= r
->next
;
4819 if (munmap (r
, r
->nbytes_mapped
) == -1)
4820 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4824 /* Enlarge region R by NPAGES pages. NPAGES < 0 means shrink R.
4825 Value is true if successful. */
4828 mmap_enlarge (struct mmap_region
*r
, int npages
)
4830 char *region_end
= (char *) r
+ r
->nbytes_mapped
;
4836 /* Unmap pages at the end of the region. */
4837 nbytes
= - npages
* mmap_page_size
;
4838 if (munmap (region_end
- nbytes
, nbytes
) == -1)
4839 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4842 r
->nbytes_mapped
-= nbytes
;
4846 else if (npages
> 0)
4848 nbytes
= npages
* mmap_page_size
;
4850 /* Try to map additional pages at the end of the region. We
4851 cannot do this if the address range is already occupied by
4852 something else because mmap deletes any previous mapping.
4853 I'm not sure this is worth doing, let's see. */
4854 if (!MMAP_ALLOCATED_P (region_end
, region_end
+ nbytes
))
4858 p
= mmap (region_end
, nbytes
, PROT_READ
| PROT_WRITE
,
4859 MAP_ANON
| MAP_PRIVATE
| MAP_FIXED
, mmap_fd
, 0);
4860 if (p
== MAP_FAILED
)
4861 ; /* fprintf (stderr, "mmap: %s\n", emacs_strerror (errno)); */
4862 else if (p
!= region_end
)
4864 /* Kernels are free to choose a different address. In
4865 that case, unmap what we've mapped above; we have
4867 if (munmap (p
, nbytes
) == -1)
4868 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4872 r
->nbytes_mapped
+= nbytes
;
4882 /* Set or reset variables holding references to mapped regions.
4883 If not RESTORE_P, set all variables to null. If RESTORE_P, set all
4884 variables to the start of the user-areas of mapped regions.
4886 This function is called from Fdump_emacs to ensure that the dumped
4887 Emacs doesn't contain references to memory that won't be mapped
4888 when Emacs starts. */
4891 mmap_set_vars (bool restore_p
)
4893 struct mmap_region
*r
;
4897 mmap_regions
= mmap_regions_1
;
4898 mmap_fd
= mmap_fd_1
;
4899 for (r
= mmap_regions
; r
; r
= r
->next
)
4900 *r
->var
= MMAP_USER_AREA (r
);
4904 for (r
= mmap_regions
; r
; r
= r
->next
)
4906 mmap_regions_1
= mmap_regions
;
4907 mmap_regions
= NULL
;
4908 mmap_fd_1
= mmap_fd
;
4914 /* Allocate a block of storage large enough to hold NBYTES bytes of
4915 data. A pointer to the data is returned in *VAR. VAR is thus the
4916 address of some variable which will use the data area.
4918 The allocation of 0 bytes is valid.
4920 If we can't allocate the necessary memory, set *VAR to null, and
4924 mmap_alloc (void **var
, size_t nbytes
)
4931 map
= ROUND (nbytes
+ MMAP_REGION_STRUCT_SIZE
, mmap_page_size
);
4932 p
= mmap (NULL
, map
, PROT_READ
| PROT_WRITE
, MAP_ANON
| MAP_PRIVATE
,
4935 if (p
== MAP_FAILED
)
4937 if (errno
!= ENOMEM
)
4938 fprintf (stderr
, "mmap: %s\n", emacs_strerror (errno
));
4943 struct mmap_region
*r
= p
;
4945 r
->nbytes_specified
= nbytes
;
4946 r
->nbytes_mapped
= map
;
4949 r
->next
= mmap_regions
;
4954 p
= MMAP_USER_AREA (p
);
4961 /* Free a block of relocatable storage whose data is pointed to by
4962 PTR. Store 0 in *PTR to show there's no block allocated. */
4965 mmap_free (void **var
)
4971 mmap_free_1 (MMAP_REGION (*var
));
4977 /* Given a pointer at address VAR to data allocated with mmap_alloc,
4978 resize it to size NBYTES. Change *VAR to reflect the new block,
4979 and return this value. If more memory cannot be allocated, then
4980 leave *VAR unchanged, and return null. */
4983 mmap_realloc (void **var
, size_t nbytes
)
4990 result
= mmap_alloc (var
, nbytes
);
4991 else if (nbytes
== 0)
4994 result
= mmap_alloc (var
, nbytes
);
4998 struct mmap_region
*r
= MMAP_REGION (*var
);
4999 size_t room
= r
->nbytes_mapped
- MMAP_REGION_STRUCT_SIZE
;
5004 void *old_ptr
= *var
;
5006 /* Try to map additional pages at the end of the region.
5007 If that fails, allocate a new region, copy data
5008 from the old region, then free it. */
5009 if (mmap_enlarge (r
, (ROUND (nbytes
- room
, mmap_page_size
)
5012 r
->nbytes_specified
= nbytes
;
5013 *var
= result
= old_ptr
;
5015 else if (mmap_alloc (var
, nbytes
))
5017 memcpy (*var
, old_ptr
, r
->nbytes_specified
);
5018 mmap_free_1 (MMAP_REGION (old_ptr
));
5020 r
= MMAP_REGION (result
);
5021 r
->nbytes_specified
= nbytes
;
5029 else if (room
- nbytes
>= mmap_page_size
)
5031 /* Shrinking by at least a page. Let's give some
5032 memory back to the system.
5034 The extra parens are to make the division happens first,
5035 on positive values, so we know it will round towards
5037 mmap_enlarge (r
, - ((room
- nbytes
) / mmap_page_size
));
5039 r
->nbytes_specified
= nbytes
;
5043 /* Leave it alone. */
5045 r
->nbytes_specified
= nbytes
;
5053 #endif /* USE_MMAP_FOR_BUFFERS */
5057 /***********************************************************************
5058 Buffer-text Allocation
5059 ***********************************************************************/
5061 /* Allocate NBYTES bytes for buffer B's text buffer. */
5064 alloc_buffer_text (struct buffer
*b
, ptrdiff_t nbytes
)
5069 #if defined USE_MMAP_FOR_BUFFERS
5070 p
= mmap_alloc ((void **) &b
->text
->beg
, nbytes
);
5071 #elif defined REL_ALLOC
5072 p
= r_alloc ((void **) &b
->text
->beg
, nbytes
);
5074 p
= xmalloc (nbytes
);
5080 memory_full (nbytes
);
5087 /* Enlarge buffer B's text buffer by DELTA bytes. DELTA < 0 means
5091 enlarge_buffer_text (struct buffer
*b
, ptrdiff_t delta
)
5094 ptrdiff_t nbytes
= (BUF_Z_BYTE (b
) - BUF_BEG_BYTE (b
) + BUF_GAP_SIZE (b
) + 1
5097 #if defined USE_MMAP_FOR_BUFFERS
5098 p
= mmap_realloc ((void **) &b
->text
->beg
, nbytes
);
5099 #elif defined REL_ALLOC
5100 p
= r_re_alloc ((void **) &b
->text
->beg
, nbytes
);
5102 p
= xrealloc (b
->text
->beg
, nbytes
);
5108 memory_full (nbytes
);
5111 BUF_BEG_ADDR (b
) = p
;
5116 /* Free buffer B's text buffer. */
5119 free_buffer_text (struct buffer
*b
)
5123 #if defined USE_MMAP_FOR_BUFFERS
5124 mmap_free ((void **) &b
->text
->beg
);
5125 #elif defined REL_ALLOC
5126 r_alloc_free ((void **) &b
->text
->beg
);
5128 xfree (b
->text
->beg
);
5131 BUF_BEG_ADDR (b
) = NULL
;
5137 /***********************************************************************
5139 ***********************************************************************/
5142 init_buffer_once (void)
5146 memset (buffer_permanent_local_flags
, 0, sizeof buffer_permanent_local_flags
);
5148 /* Make sure all markable slots in buffer_defaults
5149 are initialized reasonably, so mark_buffer won't choke. */
5150 reset_buffer (&buffer_defaults
);
5151 eassert (EQ (BVAR (&buffer_defaults
, name
), make_number (0)));
5152 reset_buffer_local_variables (&buffer_defaults
, 1);
5153 eassert (EQ (BVAR (&buffer_local_symbols
, name
), make_number (0)));
5154 reset_buffer (&buffer_local_symbols
);
5155 reset_buffer_local_variables (&buffer_local_symbols
, 1);
5156 /* Prevent GC from getting confused. */
5157 buffer_defaults
.text
= &buffer_defaults
.own_text
;
5158 buffer_local_symbols
.text
= &buffer_local_symbols
.own_text
;
5159 /* No one will share the text with these buffers, but let's play it safe. */
5160 buffer_defaults
.indirections
= 0;
5161 buffer_local_symbols
.indirections
= 0;
5162 /* Likewise no one will display them. */
5163 buffer_defaults
.window_count
= 0;
5164 buffer_local_symbols
.window_count
= 0;
5165 set_buffer_intervals (&buffer_defaults
, NULL
);
5166 set_buffer_intervals (&buffer_local_symbols
, NULL
);
5167 /* This is not strictly necessary, but let's make them initialized. */
5168 bset_name (&buffer_defaults
, build_pure_c_string (" *buffer-defaults*"));
5169 bset_name (&buffer_local_symbols
, build_pure_c_string (" *buffer-local-symbols*"));
5170 BUFFER_PVEC_INIT (&buffer_defaults
);
5171 BUFFER_PVEC_INIT (&buffer_local_symbols
);
5173 /* Set up the default values of various buffer slots. */
5174 /* Must do these before making the first buffer! */
5176 /* real setup is done in bindings.el */
5177 bset_mode_line_format (&buffer_defaults
, build_pure_c_string ("%-"));
5178 bset_header_line_format (&buffer_defaults
, Qnil
);
5179 bset_abbrev_mode (&buffer_defaults
, Qnil
);
5180 bset_overwrite_mode (&buffer_defaults
, Qnil
);
5181 bset_case_fold_search (&buffer_defaults
, Qt
);
5182 bset_auto_fill_function (&buffer_defaults
, Qnil
);
5183 bset_selective_display (&buffer_defaults
, Qnil
);
5184 bset_selective_display_ellipses (&buffer_defaults
, Qt
);
5185 bset_abbrev_table (&buffer_defaults
, Qnil
);
5186 bset_display_table (&buffer_defaults
, Qnil
);
5187 bset_undo_list (&buffer_defaults
, Qnil
);
5188 bset_mark_active (&buffer_defaults
, Qnil
);
5189 bset_file_format (&buffer_defaults
, Qnil
);
5190 bset_auto_save_file_format (&buffer_defaults
, Qt
);
5191 set_buffer_overlays_before (&buffer_defaults
, NULL
);
5192 set_buffer_overlays_after (&buffer_defaults
, NULL
);
5193 buffer_defaults
.overlay_center
= BEG
;
5195 XSETFASTINT (BVAR (&buffer_defaults
, tab_width
), 8);
5196 bset_truncate_lines (&buffer_defaults
, Qnil
);
5197 bset_word_wrap (&buffer_defaults
, Qnil
);
5198 bset_ctl_arrow (&buffer_defaults
, Qt
);
5199 bset_bidi_display_reordering (&buffer_defaults
, Qt
);
5200 bset_bidi_paragraph_direction (&buffer_defaults
, Qnil
);
5201 bset_cursor_type (&buffer_defaults
, Qt
);
5202 bset_extra_line_spacing (&buffer_defaults
, Qnil
);
5203 bset_cursor_in_non_selected_windows (&buffer_defaults
, Qt
);
5205 bset_enable_multibyte_characters (&buffer_defaults
, Qt
);
5206 bset_buffer_file_coding_system (&buffer_defaults
, Qnil
);
5207 XSETFASTINT (BVAR (&buffer_defaults
, fill_column
), 70);
5208 XSETFASTINT (BVAR (&buffer_defaults
, left_margin
), 0);
5209 bset_cache_long_scans (&buffer_defaults
, Qt
);
5210 bset_file_truename (&buffer_defaults
, Qnil
);
5211 XSETFASTINT (BVAR (&buffer_defaults
, display_count
), 0);
5212 XSETFASTINT (BVAR (&buffer_defaults
, left_margin_cols
), 0);
5213 XSETFASTINT (BVAR (&buffer_defaults
, right_margin_cols
), 0);
5214 bset_left_fringe_width (&buffer_defaults
, Qnil
);
5215 bset_right_fringe_width (&buffer_defaults
, Qnil
);
5216 bset_fringes_outside_margins (&buffer_defaults
, Qnil
);
5217 bset_scroll_bar_width (&buffer_defaults
, Qnil
);
5218 bset_vertical_scroll_bar_type (&buffer_defaults
, Qt
);
5219 bset_indicate_empty_lines (&buffer_defaults
, Qnil
);
5220 bset_indicate_buffer_boundaries (&buffer_defaults
, Qnil
);
5221 bset_fringe_indicator_alist (&buffer_defaults
, Qnil
);
5222 bset_fringe_cursor_alist (&buffer_defaults
, Qnil
);
5223 bset_scroll_up_aggressively (&buffer_defaults
, Qnil
);
5224 bset_scroll_down_aggressively (&buffer_defaults
, Qnil
);
5225 bset_display_time (&buffer_defaults
, Qnil
);
5227 /* Assign the local-flags to the slots that have default values.
5228 The local flag is a bit that is used in the buffer
5229 to say that it has its own local value for the slot.
5230 The local flag bits are in the local_var_flags slot of the buffer. */
5232 /* Nothing can work if this isn't true */
5233 { verify (sizeof (EMACS_INT
) == word_size
); }
5235 /* 0 means not a lisp var, -1 means always local, else mask */
5236 memset (&buffer_local_flags
, 0, sizeof buffer_local_flags
);
5237 bset_filename (&buffer_local_flags
, make_number (-1));
5238 bset_directory (&buffer_local_flags
, make_number (-1));
5239 bset_backed_up (&buffer_local_flags
, make_number (-1));
5240 bset_save_length (&buffer_local_flags
, make_number (-1));
5241 bset_auto_save_file_name (&buffer_local_flags
, make_number (-1));
5242 bset_read_only (&buffer_local_flags
, make_number (-1));
5243 bset_major_mode (&buffer_local_flags
, make_number (-1));
5244 bset_mode_name (&buffer_local_flags
, make_number (-1));
5245 bset_undo_list (&buffer_local_flags
, make_number (-1));
5246 bset_mark_active (&buffer_local_flags
, make_number (-1));
5247 bset_point_before_scroll (&buffer_local_flags
, make_number (-1));
5248 bset_file_truename (&buffer_local_flags
, make_number (-1));
5249 bset_invisibility_spec (&buffer_local_flags
, make_number (-1));
5250 bset_file_format (&buffer_local_flags
, make_number (-1));
5251 bset_auto_save_file_format (&buffer_local_flags
, make_number (-1));
5252 bset_display_count (&buffer_local_flags
, make_number (-1));
5253 bset_display_time (&buffer_local_flags
, make_number (-1));
5254 bset_enable_multibyte_characters (&buffer_local_flags
, make_number (-1));
5257 XSETFASTINT (BVAR (&buffer_local_flags
, mode_line_format
), idx
); ++idx
;
5258 XSETFASTINT (BVAR (&buffer_local_flags
, abbrev_mode
), idx
); ++idx
;
5259 XSETFASTINT (BVAR (&buffer_local_flags
, overwrite_mode
), idx
); ++idx
;
5260 XSETFASTINT (BVAR (&buffer_local_flags
, case_fold_search
), idx
); ++idx
;
5261 XSETFASTINT (BVAR (&buffer_local_flags
, auto_fill_function
), idx
); ++idx
;
5262 XSETFASTINT (BVAR (&buffer_local_flags
, selective_display
), idx
); ++idx
;
5263 XSETFASTINT (BVAR (&buffer_local_flags
, selective_display_ellipses
), idx
); ++idx
;
5264 XSETFASTINT (BVAR (&buffer_local_flags
, tab_width
), idx
); ++idx
;
5265 XSETFASTINT (BVAR (&buffer_local_flags
, truncate_lines
), idx
); ++idx
;
5266 XSETFASTINT (BVAR (&buffer_local_flags
, word_wrap
), idx
); ++idx
;
5267 XSETFASTINT (BVAR (&buffer_local_flags
, ctl_arrow
), idx
); ++idx
;
5268 XSETFASTINT (BVAR (&buffer_local_flags
, fill_column
), idx
); ++idx
;
5269 XSETFASTINT (BVAR (&buffer_local_flags
, left_margin
), idx
); ++idx
;
5270 XSETFASTINT (BVAR (&buffer_local_flags
, abbrev_table
), idx
); ++idx
;
5271 XSETFASTINT (BVAR (&buffer_local_flags
, display_table
), idx
); ++idx
;
5272 XSETFASTINT (BVAR (&buffer_local_flags
, syntax_table
), idx
); ++idx
;
5273 XSETFASTINT (BVAR (&buffer_local_flags
, cache_long_scans
), idx
); ++idx
;
5274 XSETFASTINT (BVAR (&buffer_local_flags
, category_table
), idx
); ++idx
;
5275 XSETFASTINT (BVAR (&buffer_local_flags
, bidi_display_reordering
), idx
); ++idx
;
5276 XSETFASTINT (BVAR (&buffer_local_flags
, bidi_paragraph_direction
), idx
); ++idx
;
5277 XSETFASTINT (BVAR (&buffer_local_flags
, buffer_file_coding_system
), idx
);
5278 /* Make this one a permanent local. */
5279 buffer_permanent_local_flags
[idx
++] = 1;
5280 XSETFASTINT (BVAR (&buffer_local_flags
, left_margin_cols
), idx
); ++idx
;
5281 XSETFASTINT (BVAR (&buffer_local_flags
, right_margin_cols
), idx
); ++idx
;
5282 XSETFASTINT (BVAR (&buffer_local_flags
, left_fringe_width
), idx
); ++idx
;
5283 XSETFASTINT (BVAR (&buffer_local_flags
, right_fringe_width
), idx
); ++idx
;
5284 XSETFASTINT (BVAR (&buffer_local_flags
, fringes_outside_margins
), idx
); ++idx
;
5285 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_bar_width
), idx
); ++idx
;
5286 XSETFASTINT (BVAR (&buffer_local_flags
, vertical_scroll_bar_type
), idx
); ++idx
;
5287 XSETFASTINT (BVAR (&buffer_local_flags
, indicate_empty_lines
), idx
); ++idx
;
5288 XSETFASTINT (BVAR (&buffer_local_flags
, indicate_buffer_boundaries
), idx
); ++idx
;
5289 XSETFASTINT (BVAR (&buffer_local_flags
, fringe_indicator_alist
), idx
); ++idx
;
5290 XSETFASTINT (BVAR (&buffer_local_flags
, fringe_cursor_alist
), idx
); ++idx
;
5291 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_up_aggressively
), idx
); ++idx
;
5292 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_down_aggressively
), idx
); ++idx
;
5293 XSETFASTINT (BVAR (&buffer_local_flags
, header_line_format
), idx
); ++idx
;
5294 XSETFASTINT (BVAR (&buffer_local_flags
, cursor_type
), idx
); ++idx
;
5295 XSETFASTINT (BVAR (&buffer_local_flags
, extra_line_spacing
), idx
); ++idx
;
5296 XSETFASTINT (BVAR (&buffer_local_flags
, cursor_in_non_selected_windows
), idx
); ++idx
;
5298 /* Need more room? */
5299 if (idx
>= MAX_PER_BUFFER_VARS
)
5301 last_per_buffer_idx
= idx
;
5303 Vbuffer_alist
= Qnil
;
5307 QSFundamental
= build_pure_c_string ("Fundamental");
5309 Qfundamental_mode
= intern_c_string ("fundamental-mode");
5310 bset_major_mode (&buffer_defaults
, Qfundamental_mode
);
5312 Qmode_class
= intern_c_string ("mode-class");
5314 Qprotected_field
= intern_c_string ("protected-field");
5316 Qpermanent_local
= intern_c_string ("permanent-local");
5318 Qkill_buffer_hook
= intern_c_string ("kill-buffer-hook");
5319 Fput (Qkill_buffer_hook
, Qpermanent_local
, Qt
);
5321 /* super-magic invisible buffer */
5322 Vprin1_to_string_buffer
= Fget_buffer_create (build_pure_c_string (" prin1"));
5323 Vbuffer_alist
= Qnil
;
5325 Fset_buffer (Fget_buffer_create (build_pure_c_string ("*scratch*")));
5327 inhibit_modification_hooks
= 0;
5337 #ifdef USE_MMAP_FOR_BUFFERS
5339 /* When using the ralloc implementation based on mmap(2), buffer
5340 text pointers will have been set to null in the dumped Emacs.
5345 if (b
->text
->beg
== NULL
)
5346 enlarge_buffer_text (b
, 0);
5348 #endif /* USE_MMAP_FOR_BUFFERS */
5350 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
5351 if (NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
)))
5352 Fset_buffer_multibyte (Qnil
);
5354 pwd
= get_current_dir_name ();
5357 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5359 /* Maybe this should really use some standard subroutine
5360 whose definition is filename syntax dependent. */
5362 if (!(IS_DIRECTORY_SEP (pwd
[len
- 1])))
5364 /* Grow buffer to add directory separator and '\0'. */
5365 pwd
= realloc (pwd
, len
+ 2);
5367 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5368 pwd
[len
] = DIRECTORY_SEP
;
5369 pwd
[len
+ 1] = '\0';
5373 /* At this moment, we still don't know how to decode the directory
5374 name. So, we keep the bytes in unibyte form so that file I/O
5375 routines correctly get the original bytes. */
5376 bset_directory (current_buffer
, make_unibyte_string (pwd
, len
));
5378 /* Add /: to the front of the name
5379 if it would otherwise be treated as magic. */
5380 temp
= Ffind_file_name_handler (BVAR (current_buffer
, directory
), Qt
);
5382 /* If the default dir is just /, TEMP is non-nil
5383 because of the ange-ftp completion handler.
5384 However, it is not necessary to turn / into /:/.
5385 So avoid doing that. */
5386 && strcmp ("/", SSDATA (BVAR (current_buffer
, directory
))))
5389 concat2 (build_string ("/:"), BVAR (current_buffer
, directory
)));
5391 temp
= get_minibuffer (0);
5392 bset_directory (XBUFFER (temp
), BVAR (current_buffer
, directory
));
5397 /* Similar to defvar_lisp but define a variable whose value is the
5398 Lisp_Object stored in the current buffer. LNAME is the Lisp-level
5399 variable name. VNAME is the name of the buffer slot. PREDICATE
5400 is nil for a general Lisp variable. If PREDICATE is non-nil, then
5401 only Lisp values that satisfies the PREDICATE are allowed (except
5402 that nil is allowed too). DOC is a dummy where you write the doc
5403 string as a comment. */
5405 #define DEFVAR_PER_BUFFER(lname, vname, predicate, doc) \
5407 static struct Lisp_Buffer_Objfwd bo_fwd; \
5408 defvar_per_buffer (&bo_fwd, lname, vname, predicate); \
5412 defvar_per_buffer (struct Lisp_Buffer_Objfwd
*bo_fwd
, const char *namestring
,
5413 Lisp_Object
*address
, Lisp_Object predicate
)
5415 struct Lisp_Symbol
*sym
;
5418 sym
= XSYMBOL (intern (namestring
));
5419 offset
= (char *)address
- (char *)current_buffer
;
5421 bo_fwd
->type
= Lisp_Fwd_Buffer_Obj
;
5422 bo_fwd
->offset
= offset
;
5423 bo_fwd
->predicate
= predicate
;
5424 sym
->declared_special
= 1;
5425 sym
->redirect
= SYMBOL_FORWARDED
;
5426 SET_SYMBOL_FWD (sym
, (union Lisp_Fwd
*) bo_fwd
);
5427 XSETSYMBOL (PER_BUFFER_SYMBOL (offset
), sym
);
5429 if (PER_BUFFER_IDX (offset
) == 0)
5430 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
5431 slot of buffer_local_flags. */
5436 /* Initialize the buffer routines. */
5438 syms_of_buffer (void)
5440 staticpro (&last_overlay_modification_hooks
);
5441 last_overlay_modification_hooks
5442 = Fmake_vector (make_number (10), Qnil
);
5444 staticpro (&Qfundamental_mode
);
5445 staticpro (&Qmode_class
);
5446 staticpro (&QSFundamental
);
5447 staticpro (&Vbuffer_alist
);
5448 staticpro (&Qprotected_field
);
5449 staticpro (&Qpermanent_local
);
5450 staticpro (&Qkill_buffer_hook
);
5452 DEFSYM (Qpermanent_local_hook
, "permanent-local-hook");
5453 DEFSYM (Qoverlayp
, "overlayp");
5454 DEFSYM (Qevaporate
, "evaporate");
5455 DEFSYM (Qmodification_hooks
, "modification-hooks");
5456 DEFSYM (Qinsert_in_front_hooks
, "insert-in-front-hooks");
5457 DEFSYM (Qinsert_behind_hooks
, "insert-behind-hooks");
5458 DEFSYM (Qget_file_buffer
, "get-file-buffer");
5459 DEFSYM (Qpriority
, "priority");
5460 DEFSYM (Qbefore_string
, "before-string");
5461 DEFSYM (Qafter_string
, "after-string");
5462 DEFSYM (Qfirst_change_hook
, "first-change-hook");
5463 DEFSYM (Qbefore_change_functions
, "before-change-functions");
5464 DEFSYM (Qafter_change_functions
, "after-change-functions");
5465 DEFSYM (Qkill_buffer_query_functions
, "kill-buffer-query-functions");
5467 Fput (Qprotected_field
, Qerror_conditions
,
5468 listn (CONSTYPE_PURE
, 2, Qprotected_field
, Qerror
));
5469 Fput (Qprotected_field
, Qerror_message
,
5470 build_pure_c_string ("Attempt to modify a protected field"));
5472 DEFVAR_BUFFER_DEFAULTS ("default-mode-line-format",
5474 doc
: /* Default value of `mode-line-format' for buffers that don't override it.
5475 This is the same as (default-value 'mode-line-format). */);
5477 DEFVAR_BUFFER_DEFAULTS ("default-header-line-format",
5479 doc
: /* Default value of `header-line-format' for buffers that don't override it.
5480 This is the same as (default-value 'header-line-format). */);
5482 DEFVAR_BUFFER_DEFAULTS ("default-cursor-type", cursor_type
,
5483 doc
: /* Default value of `cursor-type' for buffers that don't override it.
5484 This is the same as (default-value 'cursor-type). */);
5486 DEFVAR_BUFFER_DEFAULTS ("default-line-spacing",
5488 doc
: /* Default value of `line-spacing' for buffers that don't override it.
5489 This is the same as (default-value 'line-spacing). */);
5491 DEFVAR_BUFFER_DEFAULTS ("default-cursor-in-non-selected-windows",
5492 cursor_in_non_selected_windows
,
5493 doc
: /* Default value of `cursor-in-non-selected-windows'.
5494 This is the same as (default-value 'cursor-in-non-selected-windows). */);
5496 DEFVAR_BUFFER_DEFAULTS ("default-abbrev-mode",
5498 doc
: /* Default value of `abbrev-mode' for buffers that do not override it.
5499 This is the same as (default-value 'abbrev-mode). */);
5501 DEFVAR_BUFFER_DEFAULTS ("default-ctl-arrow",
5503 doc
: /* Default value of `ctl-arrow' for buffers that do not override it.
5504 This is the same as (default-value 'ctl-arrow). */);
5506 DEFVAR_BUFFER_DEFAULTS ("default-enable-multibyte-characters",
5507 enable_multibyte_characters
,
5508 doc
: /* Default value of `enable-multibyte-characters' for buffers not overriding it.
5509 This is the same as (default-value 'enable-multibyte-characters). */);
5511 DEFVAR_BUFFER_DEFAULTS ("default-buffer-file-coding-system",
5512 buffer_file_coding_system
,
5513 doc
: /* Default value of `buffer-file-coding-system' for buffers not overriding it.
5514 This is the same as (default-value 'buffer-file-coding-system). */);
5516 DEFVAR_BUFFER_DEFAULTS ("default-truncate-lines",
5518 doc
: /* Default value of `truncate-lines' for buffers that do not override it.
5519 This is the same as (default-value 'truncate-lines). */);
5521 DEFVAR_BUFFER_DEFAULTS ("default-fill-column",
5523 doc
: /* Default value of `fill-column' for buffers that do not override it.
5524 This is the same as (default-value 'fill-column). */);
5526 DEFVAR_BUFFER_DEFAULTS ("default-left-margin",
5528 doc
: /* Default value of `left-margin' for buffers that do not override it.
5529 This is the same as (default-value 'left-margin). */);
5531 DEFVAR_BUFFER_DEFAULTS ("default-tab-width",
5533 doc
: /* Default value of `tab-width' for buffers that do not override it.
5534 NOTE: This controls the display width of a TAB character, and not
5535 the size of an indentation step.
5536 This is the same as (default-value 'tab-width). */);
5538 DEFVAR_BUFFER_DEFAULTS ("default-case-fold-search",
5540 doc
: /* Default value of `case-fold-search' for buffers that don't override it.
5541 This is the same as (default-value 'case-fold-search). */);
5543 DEFVAR_BUFFER_DEFAULTS ("default-left-margin-width",
5545 doc
: /* Default value of `left-margin-width' for buffers that don't override it.
5546 This is the same as (default-value 'left-margin-width). */);
5548 DEFVAR_BUFFER_DEFAULTS ("default-right-margin-width",
5550 doc
: /* Default value of `right-margin-width' for buffers that don't override it.
5551 This is the same as (default-value 'right-margin-width). */);
5553 DEFVAR_BUFFER_DEFAULTS ("default-left-fringe-width",
5555 doc
: /* Default value of `left-fringe-width' for buffers that don't override it.
5556 This is the same as (default-value 'left-fringe-width). */);
5558 DEFVAR_BUFFER_DEFAULTS ("default-right-fringe-width",
5560 doc
: /* Default value of `right-fringe-width' for buffers that don't override it.
5561 This is the same as (default-value 'right-fringe-width). */);
5563 DEFVAR_BUFFER_DEFAULTS ("default-fringes-outside-margins",
5564 fringes_outside_margins
,
5565 doc
: /* Default value of `fringes-outside-margins' for buffers that don't override it.
5566 This is the same as (default-value 'fringes-outside-margins). */);
5568 DEFVAR_BUFFER_DEFAULTS ("default-scroll-bar-width",
5570 doc
: /* Default value of `scroll-bar-width' for buffers that don't override it.
5571 This is the same as (default-value 'scroll-bar-width). */);
5573 DEFVAR_BUFFER_DEFAULTS ("default-vertical-scroll-bar",
5574 vertical_scroll_bar_type
,
5575 doc
: /* Default value of `vertical-scroll-bar' for buffers that don't override it.
5576 This is the same as (default-value 'vertical-scroll-bar). */);
5578 DEFVAR_BUFFER_DEFAULTS ("default-indicate-empty-lines",
5579 indicate_empty_lines
,
5580 doc
: /* Default value of `indicate-empty-lines' for buffers that don't override it.
5581 This is the same as (default-value 'indicate-empty-lines). */);
5583 DEFVAR_BUFFER_DEFAULTS ("default-indicate-buffer-boundaries",
5584 indicate_buffer_boundaries
,
5585 doc
: /* Default value of `indicate-buffer-boundaries' for buffers that don't override it.
5586 This is the same as (default-value 'indicate-buffer-boundaries). */);
5588 DEFVAR_BUFFER_DEFAULTS ("default-fringe-indicator-alist",
5589 fringe_indicator_alist
,
5590 doc
: /* Default value of `fringe-indicator-alist' for buffers that don't override it.
5591 This is the same as (default-value 'fringe-indicator-alist'). */);
5593 DEFVAR_BUFFER_DEFAULTS ("default-fringe-cursor-alist",
5594 fringe_cursor_alist
,
5595 doc
: /* Default value of `fringe-cursor-alist' for buffers that don't override it.
5596 This is the same as (default-value 'fringe-cursor-alist'). */);
5598 DEFVAR_BUFFER_DEFAULTS ("default-scroll-up-aggressively",
5599 scroll_up_aggressively
,
5600 doc
: /* Default value of `scroll-up-aggressively'.
5601 This value applies in buffers that don't have their own local values.
5602 This is the same as (default-value 'scroll-up-aggressively). */);
5604 DEFVAR_BUFFER_DEFAULTS ("default-scroll-down-aggressively",
5605 scroll_down_aggressively
,
5606 doc
: /* Default value of `scroll-down-aggressively'.
5607 This value applies in buffers that don't have their own local values.
5608 This is the same as (default-value 'scroll-down-aggressively). */);
5610 DEFVAR_PER_BUFFER ("header-line-format",
5611 &BVAR (current_buffer
, header_line_format
),
5613 doc
: /* Analogous to `mode-line-format', but controls the header line.
5614 The header line appears, optionally, at the top of a window;
5615 the mode line appears at the bottom. */);
5617 DEFVAR_PER_BUFFER ("mode-line-format", &BVAR (current_buffer
, mode_line_format
),
5619 doc
: /* Template for displaying mode line for current buffer.
5621 The value may be nil, a string, a symbol or a list.
5623 A value of nil means don't display a mode line.
5625 For any symbol other than t or nil, the symbol's value is processed as
5626 a mode line construct. As a special exception, if that value is a
5627 string, the string is processed verbatim, without handling any
5628 %-constructs (see below). Also, unless the symbol has a non-nil
5629 `risky-local-variable' property, all properties in any strings, as
5630 well as all :eval and :propertize forms in the value, are ignored.
5632 A list whose car is a string or list is processed by processing each
5633 of the list elements recursively, as separate mode line constructs,
5634 and concatenating the results.
5636 A list of the form `(:eval FORM)' is processed by evaluating FORM and
5637 using the result as a mode line construct. Be careful--FORM should
5638 not load any files, because that can cause an infinite recursion.
5640 A list of the form `(:propertize ELT PROPS...)' is processed by
5641 processing ELT as the mode line construct, and adding the text
5642 properties PROPS to the result.
5644 A list whose car is a symbol is processed by examining the symbol's
5645 value, and, if that value is non-nil, processing the cadr of the list
5646 recursively; and if that value is nil, processing the caddr of the
5649 A list whose car is an integer is processed by processing the cadr of
5650 the list, and padding (if the number is positive) or truncating (if
5651 negative) to the width specified by that number.
5653 A string is printed verbatim in the mode line except for %-constructs:
5654 %b -- print buffer name. %f -- print visited file name.
5655 %F -- print frame name.
5656 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
5657 %& is like %*, but ignore read-only-ness.
5658 % means buffer is read-only and * means it is modified.
5659 For a modified read-only buffer, %* gives % and %+ gives *.
5660 %s -- print process status. %l -- print the current line number.
5661 %c -- print the current column number (this makes editing slower).
5662 To make the column number update correctly in all cases,
5663 `column-number-mode' must be non-nil.
5664 %i -- print the size of the buffer.
5665 %I -- like %i, but use k, M, G, etc., to abbreviate.
5666 %p -- print percent of buffer above top of window, or Top, Bot or All.
5667 %P -- print percent of buffer above bottom of window, perhaps plus Top,
5668 or print Bottom or All.
5669 %n -- print Narrow if appropriate.
5670 %t -- visited file is text or binary (if OS supports this distinction).
5671 %z -- print mnemonics of keyboard, terminal, and buffer coding systems.
5672 %Z -- like %z, but including the end-of-line format.
5673 %e -- print error message about full memory.
5674 %@ -- print @ or hyphen. @ means that default-directory is on a
5676 %[ -- print one [ for each recursive editing level. %] similar.
5677 %% -- print %. %- -- print infinitely many dashes.
5678 Decimal digits after the % specify field width to which to pad. */);
5680 DEFVAR_BUFFER_DEFAULTS ("default-major-mode", major_mode
,
5681 doc
: /* Value of `major-mode' for new buffers. */);
5683 DEFVAR_PER_BUFFER ("major-mode", &BVAR (current_buffer
, major_mode
),
5685 doc
: /* Symbol for current buffer's major mode.
5686 The default value (normally `fundamental-mode') affects new buffers.
5687 A value of nil means to use the current buffer's major mode, provided
5688 it is not marked as "special".
5690 When a mode is used by default, `find-file' switches to it before it
5691 reads the contents into the buffer and before it finishes setting up
5692 the buffer. Thus, the mode and its hooks should not expect certain
5693 variables such as `buffer-read-only' and `buffer-file-coding-system'
5696 DEFVAR_PER_BUFFER ("mode-name", &BVAR (current_buffer
, mode_name
),
5698 doc
: /* Pretty name of current buffer's major mode.
5699 Usually a string, but can use any of the constructs for `mode-line-format',
5701 Format with `format-mode-line' to produce a string value. */);
5703 DEFVAR_PER_BUFFER ("local-abbrev-table", &BVAR (current_buffer
, abbrev_table
), Qnil
,
5704 doc
: /* Local (mode-specific) abbrev table of current buffer. */);
5706 DEFVAR_PER_BUFFER ("abbrev-mode", &BVAR (current_buffer
, abbrev_mode
), Qnil
,
5707 doc
: /* Non-nil if Abbrev mode is enabled.
5708 Use the command `abbrev-mode' to change this variable. */);
5710 DEFVAR_PER_BUFFER ("case-fold-search", &BVAR (current_buffer
, case_fold_search
),
5712 doc
: /* Non-nil if searches and matches should ignore case. */);
5714 DEFVAR_PER_BUFFER ("fill-column", &BVAR (current_buffer
, fill_column
),
5716 doc
: /* Column beyond which automatic line-wrapping should happen.
5717 Interactively, you can set the buffer local value using \\[set-fill-column]. */);
5719 DEFVAR_PER_BUFFER ("left-margin", &BVAR (current_buffer
, left_margin
),
5721 doc
: /* Column for the default `indent-line-function' to indent to.
5722 Linefeed indents to this column in Fundamental mode. */);
5724 DEFVAR_PER_BUFFER ("tab-width", &BVAR (current_buffer
, tab_width
),
5726 doc
: /* Distance between tab stops (for display of tab characters), in columns.
5727 NOTE: This controls the display width of a TAB character, and not
5728 the size of an indentation step.
5729 This should be an integer greater than zero. */);
5731 DEFVAR_PER_BUFFER ("ctl-arrow", &BVAR (current_buffer
, ctl_arrow
), Qnil
,
5732 doc
: /* Non-nil means display control chars with uparrow.
5733 A value of nil means use backslash and octal digits.
5734 This variable does not apply to characters whose display is specified
5735 in the current display table (if there is one). */);
5737 DEFVAR_PER_BUFFER ("enable-multibyte-characters",
5738 &BVAR (current_buffer
, enable_multibyte_characters
),
5740 doc
: /* Non-nil means the buffer contents are regarded as multi-byte characters.
5741 Otherwise they are regarded as unibyte. This affects the display,
5742 file I/O and the behavior of various editing commands.
5744 This variable is buffer-local but you cannot set it directly;
5745 use the function `set-buffer-multibyte' to change a buffer's representation.
5746 See also Info node `(elisp)Text Representations'. */);
5747 XSYMBOL (intern_c_string ("enable-multibyte-characters"))->constant
= 1;
5749 DEFVAR_PER_BUFFER ("buffer-file-coding-system",
5750 &BVAR (current_buffer
, buffer_file_coding_system
), Qnil
,
5751 doc
: /* Coding system to be used for encoding the buffer contents on saving.
5752 This variable applies to saving the buffer, and also to `write-region'
5753 and other functions that use `write-region'.
5754 It does not apply to sending output to subprocesses, however.
5756 If this is nil, the buffer is saved without any code conversion
5757 unless some coding system is specified in `file-coding-system-alist'
5758 for the buffer file.
5760 If the text to be saved cannot be encoded as specified by this variable,
5761 an alternative encoding is selected by `select-safe-coding-system', which see.
5763 The variable `coding-system-for-write', if non-nil, overrides this variable.
5765 This variable is never applied to a way of decoding a file while reading it. */);
5767 DEFVAR_PER_BUFFER ("bidi-display-reordering",
5768 &BVAR (current_buffer
, bidi_display_reordering
), Qnil
,
5769 doc
: /* Non-nil means reorder bidirectional text for display in the visual order. */);
5771 DEFVAR_PER_BUFFER ("bidi-paragraph-direction",
5772 &BVAR (current_buffer
, bidi_paragraph_direction
), Qnil
,
5773 doc
: /* If non-nil, forces directionality of text paragraphs in the buffer.
5775 If this is nil (the default), the direction of each paragraph is
5776 determined by the first strong directional character of its text.
5777 The values of `right-to-left' and `left-to-right' override that.
5778 Any other value is treated as nil.
5780 This variable has no effect unless the buffer's value of
5781 \`bidi-display-reordering' is non-nil. */);
5783 DEFVAR_PER_BUFFER ("truncate-lines", &BVAR (current_buffer
, truncate_lines
), Qnil
,
5784 doc
: /* Non-nil means do not display continuation lines.
5785 Instead, give each line of text just one screen line.
5787 Note that this is overridden by the variable
5788 `truncate-partial-width-windows' if that variable is non-nil
5789 and this buffer is not full-frame width.
5791 Minibuffers set this variable to nil. */);
5793 DEFVAR_PER_BUFFER ("word-wrap", &BVAR (current_buffer
, word_wrap
), Qnil
,
5794 doc
: /* Non-nil means to use word-wrapping for continuation lines.
5795 When word-wrapping is on, continuation lines are wrapped at the space
5796 or tab character nearest to the right window edge.
5797 If nil, continuation lines are wrapped at the right screen edge.
5799 This variable has no effect if long lines are truncated (see
5800 `truncate-lines' and `truncate-partial-width-windows'). If you use
5801 word-wrapping, you might want to reduce the value of
5802 `truncate-partial-width-windows', since wrapping can make text readable
5803 in narrower windows.
5805 Instead of setting this variable directly, most users should use
5806 Visual Line mode . Visual Line mode, when enabled, sets `word-wrap'
5807 to t, and additionally redefines simple editing commands to act on
5808 visual lines rather than logical lines. See the documentation of
5809 `visual-line-mode'. */);
5811 DEFVAR_PER_BUFFER ("default-directory", &BVAR (current_buffer
, directory
),
5813 doc
: /* Name of default directory of current buffer. Should end with slash.
5814 To interactively change the default directory, use command `cd'. */);
5816 DEFVAR_PER_BUFFER ("auto-fill-function", &BVAR (current_buffer
, auto_fill_function
),
5818 doc
: /* Function called (if non-nil) to perform auto-fill.
5819 It is called after self-inserting any character specified in
5820 the `auto-fill-chars' table.
5821 NOTE: This variable is not a hook;
5822 its value may not be a list of functions. */);
5824 DEFVAR_PER_BUFFER ("buffer-file-name", &BVAR (current_buffer
, filename
),
5826 doc
: /* Name of file visited in current buffer, or nil if not visiting a file.
5827 This should be an absolute file name. */);
5829 DEFVAR_PER_BUFFER ("buffer-file-truename", &BVAR (current_buffer
, file_truename
),
5831 doc
: /* Abbreviated truename of file visited in current buffer, or nil if none.
5832 The truename of a file is calculated by `file-truename'
5833 and then abbreviated with `abbreviate-file-name'. */);
5835 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
5836 &BVAR (current_buffer
, auto_save_file_name
),
5838 doc
: /* Name of file for auto-saving current buffer.
5839 If it is nil, that means don't auto-save this buffer. */);
5841 DEFVAR_PER_BUFFER ("buffer-read-only", &BVAR (current_buffer
, read_only
), Qnil
,
5842 doc
: /* Non-nil if this buffer is read-only. */);
5844 DEFVAR_PER_BUFFER ("buffer-backed-up", &BVAR (current_buffer
, backed_up
), Qnil
,
5845 doc
: /* Non-nil if this buffer's file has been backed up.
5846 Backing up is done before the first time the file is saved. */);
5848 DEFVAR_PER_BUFFER ("buffer-saved-size", &BVAR (current_buffer
, save_length
),
5850 doc
: /* Length of current buffer when last read in, saved or auto-saved.
5852 -1 means auto-saving turned off until next real save.
5854 If you set this to -2, that means don't turn off auto-saving in this buffer
5855 if its text size shrinks. If you use `buffer-swap-text' on a buffer,
5856 you probably should set this to -2 in that buffer. */);
5858 DEFVAR_PER_BUFFER ("selective-display", &BVAR (current_buffer
, selective_display
),
5860 doc
: /* Non-nil enables selective display.
5861 An integer N as value means display only lines
5862 that start with less than N columns of space.
5863 A value of t means that the character ^M makes itself and
5864 all the rest of the line invisible; also, when saving the buffer
5865 in a file, save the ^M as a newline. */);
5867 DEFVAR_PER_BUFFER ("selective-display-ellipses",
5868 &BVAR (current_buffer
, selective_display_ellipses
),
5870 doc
: /* Non-nil means display ... on previous line when a line is invisible. */);
5872 DEFVAR_PER_BUFFER ("overwrite-mode", &BVAR (current_buffer
, overwrite_mode
), Qnil
,
5873 doc
: /* Non-nil if self-insertion should replace existing text.
5874 The value should be one of `overwrite-mode-textual',
5875 `overwrite-mode-binary', or nil.
5876 If it is `overwrite-mode-textual', self-insertion still
5877 inserts at the end of a line, and inserts when point is before a tab,
5878 until the tab is filled in.
5879 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too. */);
5881 DEFVAR_PER_BUFFER ("buffer-display-table", &BVAR (current_buffer
, display_table
),
5883 doc
: /* Display table that controls display of the contents of current buffer.
5885 If this variable is nil, the value of `standard-display-table' is used.
5886 Each window can have its own, overriding display table, see
5887 `set-window-display-table' and `window-display-table'.
5889 The display table is a char-table created with `make-display-table'.
5890 A char-table is an array indexed by character codes. Normal array
5891 primitives `aref' and `aset' can be used to access elements of a char-table.
5893 Each of the char-table elements control how to display the corresponding
5894 text character: the element at index C in the table says how to display
5895 the character whose code is C. Each element should be a vector of
5896 characters or nil. The value nil means display the character in the
5897 default fashion; otherwise, the characters from the vector are delivered
5898 to the screen instead of the original character.
5900 For example, (aset buffer-display-table ?X [?Y]) tells Emacs
5901 to display a capital Y instead of each X character.
5903 In addition, a char-table has six extra slots to control the display of:
5905 the end of a truncated screen line (extra-slot 0, a single character);
5906 the end of a continued line (extra-slot 1, a single character);
5907 the escape character used to display character codes in octal
5908 (extra-slot 2, a single character);
5909 the character used as an arrow for control characters (extra-slot 3,
5910 a single character);
5911 the decoration indicating the presence of invisible lines (extra-slot 4,
5912 a vector of characters);
5913 the character used to draw the border between side-by-side windows
5914 (extra-slot 5, a single character).
5916 See also the functions `display-table-slot' and `set-display-table-slot'. */);
5918 DEFVAR_PER_BUFFER ("left-margin-width", &BVAR (current_buffer
, left_margin_cols
),
5920 doc
: /* Width in columns of left marginal area for display of a buffer.
5921 A value of nil means no marginal area.
5923 Setting this variable does not take effect until a new buffer is displayed
5924 in a window. To make the change take effect, call `set-window-buffer'. */);
5926 DEFVAR_PER_BUFFER ("right-margin-width", &BVAR (current_buffer
, right_margin_cols
),
5928 doc
: /* Width in columns of right marginal area for display of a buffer.
5929 A value of nil means no marginal area.
5931 Setting this variable does not take effect until a new buffer is displayed
5932 in a window. To make the change take effect, call `set-window-buffer'. */);
5934 DEFVAR_PER_BUFFER ("left-fringe-width", &BVAR (current_buffer
, left_fringe_width
),
5936 doc
: /* Width of this buffer's left fringe (in pixels).
5937 A value of 0 means no left fringe is shown in this buffer's window.
5938 A value of nil means to use the left fringe width from the window's frame.
5940 Setting this variable does not take effect until a new buffer is displayed
5941 in a window. To make the change take effect, call `set-window-buffer'. */);
5943 DEFVAR_PER_BUFFER ("right-fringe-width", &BVAR (current_buffer
, right_fringe_width
),
5945 doc
: /* Width of this buffer's right fringe (in pixels).
5946 A value of 0 means no right fringe is shown in this buffer's window.
5947 A value of nil means to use the right fringe width from the window's frame.
5949 Setting this variable does not take effect until a new buffer is displayed
5950 in a window. To make the change take effect, call `set-window-buffer'. */);
5952 DEFVAR_PER_BUFFER ("fringes-outside-margins", &BVAR (current_buffer
, fringes_outside_margins
),
5954 doc
: /* Non-nil means to display fringes outside display margins.
5955 A value of nil means to display fringes between margins and buffer text.
5957 Setting this variable does not take effect until a new buffer is displayed
5958 in a window. To make the change take effect, call `set-window-buffer'. */);
5960 DEFVAR_PER_BUFFER ("scroll-bar-width", &BVAR (current_buffer
, scroll_bar_width
),
5962 doc
: /* Width of this buffer's scroll bars in pixels.
5963 A value of nil means to use the scroll bar width from the window's frame. */);
5965 DEFVAR_PER_BUFFER ("vertical-scroll-bar", &BVAR (current_buffer
, vertical_scroll_bar_type
),
5967 doc
: /* Position of this buffer's vertical scroll bar.
5968 The value takes effect whenever you tell a window to display this buffer;
5969 for instance, with `set-window-buffer' or when `display-buffer' displays it.
5971 A value of `left' or `right' means put the vertical scroll bar at that side
5972 of the window; a value of nil means don't show any vertical scroll bars.
5973 A value of t (the default) means do whatever the window's frame specifies. */);
5975 DEFVAR_PER_BUFFER ("indicate-empty-lines",
5976 &BVAR (current_buffer
, indicate_empty_lines
), Qnil
,
5977 doc
: /* Visually indicate empty lines after the buffer end.
5978 If non-nil, a bitmap is displayed in the left fringe of a window on
5979 window-systems. */);
5981 DEFVAR_PER_BUFFER ("indicate-buffer-boundaries",
5982 &BVAR (current_buffer
, indicate_buffer_boundaries
), Qnil
,
5983 doc
: /* Visually indicate buffer boundaries and scrolling.
5984 If non-nil, the first and last line of the buffer are marked in the fringe
5985 of a window on window-systems with angle bitmaps, or if the window can be
5986 scrolled, the top and bottom line of the window are marked with up and down
5989 If value is a symbol `left' or `right', both angle and arrow bitmaps
5990 are displayed in the left or right fringe, resp. Any other value
5991 that doesn't look like an alist means display the angle bitmaps in
5992 the left fringe but no arrows.
5994 You can exercise more precise control by using an alist as the
5995 value. Each alist element (INDICATOR . POSITION) specifies
5996 where to show one of the indicators. INDICATOR is one of `top',
5997 `bottom', `up', `down', or t, which specifies the default position,
5998 and POSITION is one of `left', `right', or nil, meaning do not show
6001 For example, ((top . left) (t . right)) places the top angle bitmap in
6002 left fringe, the bottom angle bitmap in right fringe, and both arrow
6003 bitmaps in right fringe. To show just the angle bitmaps in the left
6004 fringe, but no arrow bitmaps, use ((top . left) (bottom . left)). */);
6006 DEFVAR_PER_BUFFER ("fringe-indicator-alist",
6007 &BVAR (current_buffer
, fringe_indicator_alist
), Qnil
,
6008 doc
: /* Mapping from logical to physical fringe indicator bitmaps.
6009 The value is an alist where each element (INDICATOR . BITMAPS)
6010 specifies the fringe bitmaps used to display a specific logical
6013 INDICATOR specifies the logical indicator type which is one of the
6014 following symbols: `truncation' , `continuation', `overlay-arrow',
6015 `top', `bottom', `top-bottom', `up', `down', empty-line', or `unknown'.
6017 BITMAPS is a list of symbols (LEFT RIGHT [LEFT1 RIGHT1]) which specifies
6018 the actual bitmap shown in the left or right fringe for the logical
6019 indicator. LEFT and RIGHT are the bitmaps shown in the left and/or
6020 right fringe for the specific indicator. The LEFT1 or RIGHT1 bitmaps
6021 are used only for the `bottom' and `top-bottom' indicators when the
6022 last (only) line has no final newline. BITMAPS may also be a single
6023 symbol which is used in both left and right fringes. */);
6025 DEFVAR_PER_BUFFER ("fringe-cursor-alist",
6026 &BVAR (current_buffer
, fringe_cursor_alist
), Qnil
,
6027 doc
: /* Mapping from logical to physical fringe cursor bitmaps.
6028 The value is an alist where each element (CURSOR . BITMAP)
6029 specifies the fringe bitmaps used to display a specific logical
6030 cursor type in the fringe.
6032 CURSOR specifies the logical cursor type which is one of the following
6033 symbols: `box' , `hollow', `bar', `hbar', or `hollow-small'. The last
6034 one is used to show a hollow cursor on narrow lines display lines
6035 where the normal hollow cursor will not fit.
6037 BITMAP is the corresponding fringe bitmap shown for the logical
6040 DEFVAR_PER_BUFFER ("scroll-up-aggressively",
6041 &BVAR (current_buffer
, scroll_up_aggressively
), Qfloatp
,
6042 doc
: /* How far to scroll windows upward.
6043 If you move point off the bottom, the window scrolls automatically.
6044 This variable controls how far it scrolls. The value nil, the default,
6045 means scroll to center point. A fraction means scroll to put point
6046 that fraction of the window's height from the bottom of the window.
6047 When the value is 0.0, point goes at the bottom line, which in the
6048 simple case that you moved off with C-f means scrolling just one line.
6049 1.0 means point goes at the top, so that in that simple case, the
6050 window scrolls by a full window height. Meaningful values are
6051 between 0.0 and 1.0, inclusive. */);
6053 DEFVAR_PER_BUFFER ("scroll-down-aggressively",
6054 &BVAR (current_buffer
, scroll_down_aggressively
), Qfloatp
,
6055 doc
: /* How far to scroll windows downward.
6056 If you move point off the top, the window scrolls automatically.
6057 This variable controls how far it scrolls. The value nil, the default,
6058 means scroll to center point. A fraction means scroll to put point
6059 that fraction of the window's height from the top of the window.
6060 When the value is 0.0, point goes at the top line, which in the
6061 simple case that you moved off with C-b means scrolling just one line.
6062 1.0 means point goes at the bottom, so that in that simple case, the
6063 window scrolls by a full window height. Meaningful values are
6064 between 0.0 and 1.0, inclusive. */);
6066 DEFVAR_LISP ("before-change-functions", Vbefore_change_functions
,
6067 doc
: /* List of functions to call before each text change.
6068 Two arguments are passed to each function: the positions of
6069 the beginning and end of the range of old text to be changed.
6070 \(For an insertion, the beginning and end are at the same place.)
6071 No information is given about the length of the text after the change.
6073 Buffer changes made while executing the `before-change-functions'
6074 don't call any before-change or after-change functions.
6075 That's because `inhibit-modification-hooks' is temporarily set non-nil.
6077 If an unhandled error happens in running these functions,
6078 the variable's value remains nil. That prevents the error
6079 from happening repeatedly and making Emacs nonfunctional. */);
6080 Vbefore_change_functions
= Qnil
;
6082 DEFVAR_LISP ("after-change-functions", Vafter_change_functions
,
6083 doc
: /* List of functions to call after each text change.
6084 Three arguments are passed to each function: the positions of
6085 the beginning and end of the range of changed text,
6086 and the length in bytes of the pre-change text replaced by that range.
6087 \(For an insertion, the pre-change length is zero;
6088 for a deletion, that length is the number of bytes deleted,
6089 and the post-change beginning and end are at the same place.)
6091 Buffer changes made while executing the `after-change-functions'
6092 don't call any before-change or after-change functions.
6093 That's because `inhibit-modification-hooks' is temporarily set non-nil.
6095 If an unhandled error happens in running these functions,
6096 the variable's value remains nil. That prevents the error
6097 from happening repeatedly and making Emacs nonfunctional. */);
6098 Vafter_change_functions
= Qnil
;
6100 DEFVAR_LISP ("first-change-hook", Vfirst_change_hook
,
6101 doc
: /* A list of functions to call before changing a buffer which is unmodified.
6102 The functions are run using the `run-hooks' function. */);
6103 Vfirst_change_hook
= Qnil
;
6105 DEFVAR_PER_BUFFER ("buffer-undo-list", &BVAR (current_buffer
, undo_list
), Qnil
,
6106 doc
: /* List of undo entries in current buffer.
6107 Recent changes come first; older changes follow newer.
6109 An entry (BEG . END) represents an insertion which begins at
6110 position BEG and ends at position END.
6112 An entry (TEXT . POSITION) represents the deletion of the string TEXT
6113 from (abs POSITION). If POSITION is positive, point was at the front
6114 of the text being deleted; if negative, point was at the end.
6116 An entry (t HIGH LOW USEC PSEC) indicates that the buffer was previously
6117 unmodified; (HIGH LOW USEC PSEC) is in the same style as (current-time)
6118 and is the visited file's modification time, as of that time. If the
6119 modification time of the most recent save is different, this entry is
6122 An entry (t . 0) means means the buffer was previously unmodified but
6123 its time stamp was unknown because it was not associated with a file.
6124 An entry (t . -1) is similar, except that it means the buffer's visited
6127 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
6128 was modified between BEG and END. PROPERTY is the property name,
6129 and VALUE is the old value.
6131 An entry (apply FUN-NAME . ARGS) means undo the change with
6132 \(apply FUN-NAME ARGS).
6134 An entry (apply DELTA BEG END FUN-NAME . ARGS) supports selective undo
6135 in the active region. BEG and END is the range affected by this entry
6136 and DELTA is the number of characters added or deleted in that range by
6139 An entry (MARKER . DISTANCE) indicates that the marker MARKER
6140 was adjusted in position by the offset DISTANCE (an integer).
6142 An entry of the form POSITION indicates that point was at the buffer
6143 location given by the integer. Undoing an entry of this form places
6146 Entries with value `nil' mark undo boundaries. The undo command treats
6147 the changes between two undo boundaries as a single step to be undone.
6149 If the value of the variable is t, undo information is not recorded. */);
6151 DEFVAR_PER_BUFFER ("mark-active", &BVAR (current_buffer
, mark_active
), Qnil
,
6152 doc
: /* Non-nil means the mark and region are currently active in this buffer. */);
6154 DEFVAR_PER_BUFFER ("cache-long-scans", &BVAR (current_buffer
, cache_long_scans
), Qnil
,
6155 doc
: /* Non-nil means that Emacs should use caches in attempt to speedup buffer scans.
6157 There is no reason to set this to nil except for debugging purposes.
6159 Normally, the line-motion functions work by scanning the buffer for
6160 newlines. Columnar operations (like `move-to-column' and
6161 `compute-motion') also work by scanning the buffer, summing character
6162 widths as they go. This works well for ordinary text, but if the
6163 buffer's lines are very long (say, more than 500 characters), these
6164 motion functions will take longer to execute. Emacs may also take
6165 longer to update the display.
6167 If `cache-long-scans' is non-nil, these motion functions cache the
6168 results of their scans, and consult the cache to avoid rescanning
6169 regions of the buffer until the text is modified. The caches are most
6170 beneficial when they prevent the most searching---that is, when the
6171 buffer contains long lines and large regions of characters with the
6172 same, fixed screen width.
6174 When `cache-long-scans' is non-nil, processing short lines will
6175 become slightly slower (because of the overhead of consulting the
6176 cache), and the caches will use memory roughly proportional to the
6177 number of newlines and characters whose screen width varies.
6179 Bidirectional editing also requires buffer scans to find paragraph
6180 separators. If you have large paragraphs or no paragraph separators
6181 at all, these scans may be slow. If `cache-long-scans' is non-nil,
6182 results of these scans are cached. This doesn't help too much if
6183 paragraphs are of the reasonable (few thousands of characters) size.
6185 The caches require no explicit maintenance; their accuracy is
6186 maintained internally by the Emacs primitives. Enabling or disabling
6187 the cache should not affect the behavior of any of the motion
6188 functions; it should only affect their performance. */);
6190 DEFVAR_PER_BUFFER ("point-before-scroll", &BVAR (current_buffer
, point_before_scroll
), Qnil
,
6191 doc
: /* Value of point before the last series of scroll operations, or nil. */);
6193 DEFVAR_PER_BUFFER ("buffer-file-format", &BVAR (current_buffer
, file_format
), Qnil
,
6194 doc
: /* List of formats to use when saving this buffer.
6195 Formats are defined by `format-alist'. This variable is
6196 set when a file is visited. */);
6198 DEFVAR_PER_BUFFER ("buffer-auto-save-file-format",
6199 &BVAR (current_buffer
, auto_save_file_format
), Qnil
,
6200 doc
: /* Format in which to write auto-save files.
6201 Should be a list of symbols naming formats that are defined in `format-alist'.
6202 If it is t, which is the default, auto-save files are written in the
6203 same format as a regular save would use. */);
6205 DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
6206 &BVAR (current_buffer
, invisibility_spec
), Qnil
,
6207 doc
: /* Invisibility spec of this buffer.
6208 The default is t, which means that text is invisible if it has a non-nil
6209 `invisible' property.
6210 This variable can also be a list. The list can have two kinds of elements:
6211 `ATOM' and `(ATOM . ELLIPSIS)'. A text character is invisible if its
6212 `invisible' property is `ATOM', or has an `invisible' property that is a list
6213 that contains `ATOM'.
6214 If the `(ATOM . ELLIPSIS)' form is used, and `ELLIPSIS' is non-nil, an
6215 ellipsis will be displayed after the invisible characters.
6216 Setting this variable is very fast, much faster than scanning all the text in
6217 the buffer looking for properties to change. */);
6219 DEFVAR_PER_BUFFER ("buffer-display-count",
6220 &BVAR (current_buffer
, display_count
), Qintegerp
,
6221 doc
: /* A number incremented each time this buffer is displayed in a window.
6222 The function `set-window-buffer' increments it. */);
6224 DEFVAR_PER_BUFFER ("buffer-display-time",
6225 &BVAR (current_buffer
, display_time
), Qnil
,
6226 doc
: /* Time stamp updated each time this buffer is displayed in a window.
6227 The function `set-window-buffer' updates this variable
6228 to the value obtained by calling `current-time'.
6229 If the buffer has never been shown in a window, the value is nil. */);
6231 DEFVAR_LISP ("transient-mark-mode", Vtransient_mark_mode
,
6232 doc
: /* Non-nil if Transient Mark mode is enabled.
6233 See the command `transient-mark-mode' for a description of this minor mode.
6235 Non-nil also enables highlighting of the region whenever the mark is active.
6236 The variable `highlight-nonselected-windows' controls whether to highlight
6237 all windows or just the selected window.
6239 Lisp programs may give this variable certain special values:
6241 - A value of `lambda' enables Transient Mark mode temporarily.
6242 It is disabled again after any subsequent action that would
6243 normally deactivate the mark (e.g. buffer modification).
6245 - A value of (only . OLDVAL) enables Transient Mark mode
6246 temporarily. After any subsequent point motion command that is
6247 not shift-translated, or any other action that would normally
6248 deactivate the mark (e.g. buffer modification), the value of
6249 `transient-mark-mode' is set to OLDVAL. */);
6250 Vtransient_mark_mode
= Qnil
;
6252 DEFVAR_LISP ("inhibit-read-only", Vinhibit_read_only
,
6253 doc
: /* Non-nil means disregard read-only status of buffers or characters.
6254 If the value is t, disregard `buffer-read-only' and all `read-only'
6255 text properties. If the value is a list, disregard `buffer-read-only'
6256 and disregard a `read-only' text property if the property value
6257 is a member of the list. */);
6258 Vinhibit_read_only
= Qnil
;
6260 DEFVAR_PER_BUFFER ("cursor-type", &BVAR (current_buffer
, cursor_type
), Qnil
,
6261 doc
: /* Cursor to use when this buffer is in the selected window.
6262 Values are interpreted as follows:
6264 t use the cursor specified for the frame
6265 nil don't display a cursor
6266 box display a filled box cursor
6267 hollow display a hollow box cursor
6268 bar display a vertical bar cursor with default width
6269 (bar . WIDTH) display a vertical bar cursor with width WIDTH
6270 hbar display a horizontal bar cursor with default height
6271 (hbar . HEIGHT) display a horizontal bar cursor with height HEIGHT
6272 ANYTHING ELSE display a hollow box cursor
6274 When the buffer is displayed in a non-selected window, the
6275 cursor's appearance is instead controlled by the variable
6276 `cursor-in-non-selected-windows'. */);
6278 DEFVAR_PER_BUFFER ("line-spacing",
6279 &BVAR (current_buffer
, extra_line_spacing
), Qnumberp
,
6280 doc
: /* Additional space to put between lines when displaying a buffer.
6281 The space is measured in pixels, and put below lines on graphic displays,
6282 see `display-graphic-p'.
6283 If value is a floating point number, it specifies the spacing relative
6284 to the default frame line height. A value of nil means add no extra space. */);
6286 DEFVAR_PER_BUFFER ("cursor-in-non-selected-windows",
6287 &BVAR (current_buffer
, cursor_in_non_selected_windows
), Qnil
,
6288 doc
: /* Non-nil means show a cursor in non-selected windows.
6289 If nil, only shows a cursor in the selected window.
6290 If t, displays a cursor related to the usual cursor type
6291 \(a solid box becomes hollow, a bar becomes a narrower bar).
6292 You can also specify the cursor type as in the `cursor-type' variable.
6293 Use Custom to set this variable and update the display." */);
6295 DEFVAR_LISP ("kill-buffer-query-functions", Vkill_buffer_query_functions
,
6296 doc
: /* List of functions called with no args to query before killing a buffer.
6297 The buffer being killed will be current while the functions are running.
6299 If any of them returns nil, the buffer is not killed. Functions run by
6300 this hook are supposed to not change the current buffer. */);
6301 Vkill_buffer_query_functions
= Qnil
;
6303 DEFVAR_LISP ("change-major-mode-hook", Vchange_major_mode_hook
,
6304 doc
: /* Normal hook run before changing the major mode of a buffer.
6305 The function `kill-all-local-variables' runs this before doing anything else. */);
6306 Vchange_major_mode_hook
= Qnil
;
6307 DEFSYM (Qchange_major_mode_hook
, "change-major-mode-hook");
6309 DEFVAR_LISP ("buffer-list-update-hook", Vbuffer_list_update_hook
,
6310 doc
: /* Hook run when the buffer list changes.
6311 Functions running this hook are, `get-buffer-create',
6312 `make-indirect-buffer', `rename-buffer', `kill-buffer',
6313 `bury-buffer-internal' and `select-window'. */);
6314 Vbuffer_list_update_hook
= Qnil
;
6315 DEFSYM (Qbuffer_list_update_hook
, "buffer-list-update-hook");
6317 defsubr (&Sbuffer_live_p
);
6318 defsubr (&Sbuffer_list
);
6319 defsubr (&Sget_buffer
);
6320 defsubr (&Sget_file_buffer
);
6321 defsubr (&Sget_buffer_create
);
6322 defsubr (&Smake_indirect_buffer
);
6323 defsubr (&Sgenerate_new_buffer_name
);
6324 defsubr (&Sbuffer_name
);
6325 defsubr (&Sbuffer_file_name
);
6326 defsubr (&Sbuffer_base_buffer
);
6327 defsubr (&Sbuffer_local_value
);
6328 defsubr (&Sbuffer_local_variables
);
6329 defsubr (&Sbuffer_modified_p
);
6330 defsubr (&Sforce_mode_line_update
);
6331 defsubr (&Sset_buffer_modified_p
);
6332 defsubr (&Sbuffer_modified_tick
);
6333 defsubr (&Sbuffer_chars_modified_tick
);
6334 defsubr (&Srename_buffer
);
6335 defsubr (&Sother_buffer
);
6336 defsubr (&Sbuffer_enable_undo
);
6337 defsubr (&Skill_buffer
);
6338 defsubr (&Sbury_buffer_internal
);
6339 defsubr (&Sset_buffer_major_mode
);
6340 defsubr (&Scurrent_buffer
);
6341 defsubr (&Sset_buffer
);
6342 defsubr (&Sbarf_if_buffer_read_only
);
6343 defsubr (&Serase_buffer
);
6344 defsubr (&Sbuffer_swap_text
);
6345 defsubr (&Sset_buffer_multibyte
);
6346 defsubr (&Skill_all_local_variables
);
6348 defsubr (&Soverlayp
);
6349 defsubr (&Smake_overlay
);
6350 defsubr (&Sdelete_overlay
);
6351 defsubr (&Sdelete_all_overlays
);
6352 defsubr (&Smove_overlay
);
6353 defsubr (&Soverlay_start
);
6354 defsubr (&Soverlay_end
);
6355 defsubr (&Soverlay_buffer
);
6356 defsubr (&Soverlay_properties
);
6357 defsubr (&Soverlays_at
);
6358 defsubr (&Soverlays_in
);
6359 defsubr (&Snext_overlay_change
);
6360 defsubr (&Sprevious_overlay_change
);
6361 defsubr (&Soverlay_recenter
);
6362 defsubr (&Soverlay_lists
);
6363 defsubr (&Soverlay_get
);
6364 defsubr (&Soverlay_put
);
6365 defsubr (&Srestore_buffer_modified_p
);
6369 keys_of_buffer (void)
6371 initial_define_key (control_x_map
, 'b', "switch-to-buffer");
6372 initial_define_key (control_x_map
, 'k', "kill-buffer");
6374 /* This must not be in syms_of_buffer, because Qdisabled is not
6375 initialized when that function gets called. */
6376 Fput (intern_c_string ("erase-buffer"), Qdisabled
, Qt
);