1 /* Buffer manipulation primitives for GNU Emacs.
3 Copyright (C) 1985-1989, 1993-1995, 1997-2015 Free Software Foundation,
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
23 #include <sys/types.h>
25 #include <sys/param.h>
33 #include "intervals.h"
36 #include "character.h"
38 #include "region-cache.h"
40 #include "blockinput.h"
46 #include "w32heap.h" /* for mmap_* */
49 struct buffer
*current_buffer
; /* The current buffer. */
51 /* First buffer in chain of all buffers (in reverse order of creation).
52 Threaded through ->header.next.buffer. */
54 struct buffer
*all_buffers
;
56 /* This structure holds the default values of the buffer-local variables
57 defined with DEFVAR_PER_BUFFER, that have special slots in each buffer.
58 The default value occupies the same slot in this structure
59 as an individual buffer's value occupies in that buffer.
60 Setting the default value also goes through the alist of buffers
61 and stores into each buffer that does not say it has a local value. */
63 struct buffer
alignas (GCALIGNMENT
) buffer_defaults
;
65 /* This structure marks which slots in a buffer have corresponding
66 default values in buffer_defaults.
67 Each such slot has a nonzero value in this structure.
68 The value has only one nonzero bit.
70 When a buffer has its own local value for a slot,
71 the entry for that slot (found in the same slot in this structure)
72 is turned on in the buffer's local_flags array.
74 If a slot in this structure is -1, then even though there may
75 be a DEFVAR_PER_BUFFER for the slot, there is no default value for it;
76 and the corresponding slot in buffer_defaults is not used.
78 If a slot in this structure corresponding to a DEFVAR_PER_BUFFER is
79 zero, that is a bug. */
81 struct buffer buffer_local_flags
;
83 /* This structure holds the names of symbols whose values may be
84 buffer-local. It is indexed and accessed in the same way as the above. */
86 struct buffer
alignas (GCALIGNMENT
) buffer_local_symbols
;
88 /* Return the symbol of the per-buffer variable at offset OFFSET in
89 the buffer structure. */
91 #define PER_BUFFER_SYMBOL(OFFSET) \
92 (*(Lisp_Object *)((OFFSET) + (char *) &buffer_local_symbols))
94 /* Maximum length of an overlay vector. */
95 #define OVERLAY_COUNT_MAX \
96 ((ptrdiff_t) min (MOST_POSITIVE_FIXNUM, \
97 min (PTRDIFF_MAX, SIZE_MAX) / word_size))
99 /* Flags indicating which built-in buffer-local variables
100 are permanent locals. */
101 static char buffer_permanent_local_flags
[MAX_PER_BUFFER_VARS
];
103 /* Number of per-buffer variables used. */
105 int last_per_buffer_idx
;
107 static void call_overlay_mod_hooks (Lisp_Object list
, Lisp_Object overlay
,
108 bool after
, Lisp_Object arg1
,
109 Lisp_Object arg2
, Lisp_Object arg3
);
110 static void swap_out_buffer_local_variables (struct buffer
*b
);
111 static void reset_buffer_local_variables (struct buffer
*, bool);
113 /* Alist of all buffer names vs the buffers. This used to be
114 a Lisp-visible variable, but is no longer, to prevent lossage
115 due to user rplac'ing this alist or its elements. */
116 Lisp_Object Vbuffer_alist
;
118 static Lisp_Object QSFundamental
; /* A string "Fundamental". */
120 static void alloc_buffer_text (struct buffer
*, ptrdiff_t);
121 static void free_buffer_text (struct buffer
*b
);
122 static struct Lisp_Overlay
* copy_overlays (struct buffer
*, struct Lisp_Overlay
*);
123 static void modify_overlay (struct buffer
*, ptrdiff_t, ptrdiff_t);
124 static Lisp_Object
buffer_lisp_local_variables (struct buffer
*, bool);
127 CHECK_OVERLAY (Lisp_Object x
)
129 CHECK_TYPE (OVERLAYP (x
), Qoverlayp
, x
);
132 /* These setters are used only in this file, so they can be private.
133 The public setters are inline functions defined in buffer.h. */
135 bset_abbrev_mode (struct buffer
*b
, Lisp_Object val
)
137 b
->INTERNAL_FIELD (abbrev_mode
) = val
;
140 bset_abbrev_table (struct buffer
*b
, Lisp_Object val
)
142 b
->INTERNAL_FIELD (abbrev_table
) = val
;
145 bset_auto_fill_function (struct buffer
*b
, Lisp_Object val
)
147 b
->INTERNAL_FIELD (auto_fill_function
) = val
;
150 bset_auto_save_file_format (struct buffer
*b
, Lisp_Object val
)
152 b
->INTERNAL_FIELD (auto_save_file_format
) = val
;
155 bset_auto_save_file_name (struct buffer
*b
, Lisp_Object val
)
157 b
->INTERNAL_FIELD (auto_save_file_name
) = val
;
160 bset_backed_up (struct buffer
*b
, Lisp_Object val
)
162 b
->INTERNAL_FIELD (backed_up
) = val
;
165 bset_begv_marker (struct buffer
*b
, Lisp_Object val
)
167 b
->INTERNAL_FIELD (begv_marker
) = val
;
170 bset_bidi_display_reordering (struct buffer
*b
, Lisp_Object val
)
172 b
->INTERNAL_FIELD (bidi_display_reordering
) = val
;
175 bset_buffer_file_coding_system (struct buffer
*b
, Lisp_Object val
)
177 b
->INTERNAL_FIELD (buffer_file_coding_system
) = val
;
180 bset_case_fold_search (struct buffer
*b
, Lisp_Object val
)
182 b
->INTERNAL_FIELD (case_fold_search
) = val
;
185 bset_ctl_arrow (struct buffer
*b
, Lisp_Object val
)
187 b
->INTERNAL_FIELD (ctl_arrow
) = val
;
190 bset_cursor_in_non_selected_windows (struct buffer
*b
, Lisp_Object val
)
192 b
->INTERNAL_FIELD (cursor_in_non_selected_windows
) = val
;
195 bset_cursor_type (struct buffer
*b
, Lisp_Object val
)
197 b
->INTERNAL_FIELD (cursor_type
) = val
;
200 bset_display_table (struct buffer
*b
, Lisp_Object val
)
202 b
->INTERNAL_FIELD (display_table
) = val
;
205 bset_extra_line_spacing (struct buffer
*b
, Lisp_Object val
)
207 b
->INTERNAL_FIELD (extra_line_spacing
) = val
;
210 bset_file_format (struct buffer
*b
, Lisp_Object val
)
212 b
->INTERNAL_FIELD (file_format
) = val
;
215 bset_file_truename (struct buffer
*b
, Lisp_Object val
)
217 b
->INTERNAL_FIELD (file_truename
) = val
;
220 bset_fringe_cursor_alist (struct buffer
*b
, Lisp_Object val
)
222 b
->INTERNAL_FIELD (fringe_cursor_alist
) = val
;
225 bset_fringe_indicator_alist (struct buffer
*b
, Lisp_Object val
)
227 b
->INTERNAL_FIELD (fringe_indicator_alist
) = val
;
230 bset_fringes_outside_margins (struct buffer
*b
, Lisp_Object val
)
232 b
->INTERNAL_FIELD (fringes_outside_margins
) = val
;
235 bset_header_line_format (struct buffer
*b
, Lisp_Object val
)
237 b
->INTERNAL_FIELD (header_line_format
) = val
;
240 bset_indicate_buffer_boundaries (struct buffer
*b
, Lisp_Object val
)
242 b
->INTERNAL_FIELD (indicate_buffer_boundaries
) = val
;
245 bset_indicate_empty_lines (struct buffer
*b
, Lisp_Object val
)
247 b
->INTERNAL_FIELD (indicate_empty_lines
) = val
;
250 bset_invisibility_spec (struct buffer
*b
, Lisp_Object val
)
252 b
->INTERNAL_FIELD (invisibility_spec
) = val
;
255 bset_left_fringe_width (struct buffer
*b
, Lisp_Object val
)
257 b
->INTERNAL_FIELD (left_fringe_width
) = val
;
260 bset_major_mode (struct buffer
*b
, Lisp_Object val
)
262 b
->INTERNAL_FIELD (major_mode
) = val
;
265 bset_mark (struct buffer
*b
, Lisp_Object val
)
267 b
->INTERNAL_FIELD (mark
) = val
;
270 bset_minor_modes (struct buffer
*b
, Lisp_Object val
)
272 b
->INTERNAL_FIELD (minor_modes
) = val
;
275 bset_mode_line_format (struct buffer
*b
, Lisp_Object val
)
277 b
->INTERNAL_FIELD (mode_line_format
) = val
;
280 bset_mode_name (struct buffer
*b
, Lisp_Object val
)
282 b
->INTERNAL_FIELD (mode_name
) = val
;
285 bset_name (struct buffer
*b
, Lisp_Object val
)
287 b
->INTERNAL_FIELD (name
) = val
;
290 bset_overwrite_mode (struct buffer
*b
, Lisp_Object val
)
292 b
->INTERNAL_FIELD (overwrite_mode
) = val
;
295 bset_pt_marker (struct buffer
*b
, Lisp_Object val
)
297 b
->INTERNAL_FIELD (pt_marker
) = val
;
300 bset_right_fringe_width (struct buffer
*b
, Lisp_Object val
)
302 b
->INTERNAL_FIELD (right_fringe_width
) = val
;
305 bset_save_length (struct buffer
*b
, Lisp_Object val
)
307 b
->INTERNAL_FIELD (save_length
) = val
;
310 bset_scroll_bar_width (struct buffer
*b
, Lisp_Object val
)
312 b
->INTERNAL_FIELD (scroll_bar_width
) = val
;
315 bset_scroll_bar_height (struct buffer
*b
, Lisp_Object val
)
317 b
->INTERNAL_FIELD (scroll_bar_height
) = val
;
320 bset_scroll_down_aggressively (struct buffer
*b
, Lisp_Object val
)
322 b
->INTERNAL_FIELD (scroll_down_aggressively
) = val
;
325 bset_scroll_up_aggressively (struct buffer
*b
, Lisp_Object val
)
327 b
->INTERNAL_FIELD (scroll_up_aggressively
) = val
;
330 bset_selective_display (struct buffer
*b
, Lisp_Object val
)
332 b
->INTERNAL_FIELD (selective_display
) = val
;
335 bset_selective_display_ellipses (struct buffer
*b
, Lisp_Object val
)
337 b
->INTERNAL_FIELD (selective_display_ellipses
) = val
;
340 bset_vertical_scroll_bar_type (struct buffer
*b
, Lisp_Object val
)
342 b
->INTERNAL_FIELD (vertical_scroll_bar_type
) = val
;
345 bset_horizontal_scroll_bar_type (struct buffer
*b
, Lisp_Object val
)
347 b
->INTERNAL_FIELD (horizontal_scroll_bar_type
) = val
;
350 bset_word_wrap (struct buffer
*b
, Lisp_Object val
)
352 b
->INTERNAL_FIELD (word_wrap
) = val
;
355 bset_zv_marker (struct buffer
*b
, Lisp_Object val
)
357 b
->INTERNAL_FIELD (zv_marker
) = val
;
361 nsberror (Lisp_Object spec
)
364 error ("No buffer named %s", SDATA (spec
));
365 error ("Invalid buffer argument");
368 DEFUN ("buffer-live-p", Fbuffer_live_p
, Sbuffer_live_p
, 1, 1, 0,
369 doc
: /* Return non-nil if OBJECT is a buffer which has not been killed.
370 Value is nil if OBJECT is not a buffer or if it has been killed. */)
373 return ((BUFFERP (object
) && BUFFER_LIVE_P (XBUFFER (object
)))
377 DEFUN ("buffer-list", Fbuffer_list
, Sbuffer_list
, 0, 1, 0,
378 doc
: /* Return a list of all existing live buffers.
379 If the optional arg FRAME is a frame, we return the buffer list in the
380 proper order for that frame: the buffers show in FRAME come first,
381 followed by the rest of the buffers. */)
385 general
= Fmapcar (Qcdr
, Vbuffer_alist
);
389 Lisp_Object framelist
, prevlist
, tail
;
392 framelist
= Fcopy_sequence (XFRAME (frame
)->buffer_list
);
393 prevlist
= Fnreverse (Fcopy_sequence
394 (XFRAME (frame
)->buried_buffer_list
));
396 /* Remove from GENERAL any buffer that duplicates one in
397 FRAMELIST or PREVLIST. */
401 general
= Fdelq (XCAR (tail
), general
);
407 general
= Fdelq (XCAR (tail
), general
);
414 return Fnconc (3, args
);
420 /* Like Fassoc, but use Fstring_equal to compare
421 (which ignores text properties),
422 and don't ever QUIT. */
425 assoc_ignore_text_properties (register Lisp_Object key
, Lisp_Object list
)
427 register Lisp_Object tail
;
428 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
430 register Lisp_Object elt
, tem
;
432 tem
= Fstring_equal (Fcar (elt
), key
);
439 DEFUN ("get-buffer", Fget_buffer
, Sget_buffer
, 1, 1, 0,
440 doc
: /* Return the buffer named BUFFER-OR-NAME.
441 BUFFER-OR-NAME must be either a string or a buffer. If BUFFER-OR-NAME
442 is a string and there is no buffer with that name, return nil. If
443 BUFFER-OR-NAME is a buffer, return it as given. */)
444 (register Lisp_Object buffer_or_name
)
446 if (BUFFERP (buffer_or_name
))
447 return buffer_or_name
;
448 CHECK_STRING (buffer_or_name
);
450 return Fcdr (assoc_ignore_text_properties (buffer_or_name
, Vbuffer_alist
));
453 DEFUN ("get-file-buffer", Fget_file_buffer
, Sget_file_buffer
, 1, 1, 0,
454 doc
: /* Return the buffer visiting file FILENAME (a string).
455 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
456 If there is no such live buffer, return nil.
457 See also `find-buffer-visiting'. */)
458 (register Lisp_Object filename
)
460 register Lisp_Object tail
, buf
, handler
;
462 CHECK_STRING (filename
);
463 filename
= Fexpand_file_name (filename
, Qnil
);
465 /* If the file name has special constructs in it,
466 call the corresponding file handler. */
467 handler
= Ffind_file_name_handler (filename
, Qget_file_buffer
);
470 Lisp_Object handled_buf
= call2 (handler
, Qget_file_buffer
,
472 return BUFFERP (handled_buf
) ? handled_buf
: Qnil
;
475 FOR_EACH_LIVE_BUFFER (tail
, buf
)
477 if (!STRINGP (BVAR (XBUFFER (buf
), filename
))) continue;
478 if (!NILP (Fstring_equal (BVAR (XBUFFER (buf
), filename
), filename
)))
485 get_truename_buffer (register Lisp_Object filename
)
487 register Lisp_Object tail
, buf
;
489 FOR_EACH_LIVE_BUFFER (tail
, buf
)
491 if (!STRINGP (BVAR (XBUFFER (buf
), file_truename
))) continue;
492 if (!NILP (Fstring_equal (BVAR (XBUFFER (buf
), file_truename
), filename
)))
498 DEFUN ("get-buffer-create", Fget_buffer_create
, Sget_buffer_create
, 1, 1, 0,
499 doc
: /* Return the buffer specified by BUFFER-OR-NAME, creating a new one if needed.
500 If BUFFER-OR-NAME is a string and a live buffer with that name exists,
501 return that buffer. If no such buffer exists, create a new buffer with
502 that name and return it. If BUFFER-OR-NAME starts with a space, the new
503 buffer does not keep undo information.
505 If BUFFER-OR-NAME is a buffer instead of a string, return it as given,
506 even if it is dead. The return value is never nil. */)
507 (register Lisp_Object buffer_or_name
)
509 register Lisp_Object buffer
, name
;
510 register struct buffer
*b
;
512 buffer
= Fget_buffer (buffer_or_name
);
516 if (SCHARS (buffer_or_name
) == 0)
517 error ("Empty string for buffer name is not allowed");
519 b
= allocate_buffer ();
521 /* An ordinary buffer uses its own struct buffer_text. */
522 b
->text
= &b
->own_text
;
523 b
->base_buffer
= NULL
;
524 /* No one shares the text with us now. */
526 /* No one shows us now. */
529 BUF_GAP_SIZE (b
) = 20;
531 /* We allocate extra 1-byte at the tail and keep it always '\0' for
532 anchoring a search. */
533 alloc_buffer_text (b
, BUF_GAP_SIZE (b
) + 1);
535 if (! BUF_BEG_ADDR (b
))
536 buffer_memory_full (BUF_GAP_SIZE (b
) + 1);
541 b
->pt_byte
= BEG_BYTE
;
542 b
->begv_byte
= BEG_BYTE
;
543 b
->zv_byte
= BEG_BYTE
;
546 BUF_GPT_BYTE (b
) = BEG_BYTE
;
549 BUF_Z_BYTE (b
) = BEG_BYTE
;
551 BUF_CHARS_MODIFF (b
) = 1;
552 BUF_OVERLAY_MODIFF (b
) = 1;
553 BUF_SAVE_MODIFF (b
) = 1;
555 set_buffer_intervals (b
, NULL
);
556 BUF_UNCHANGED_MODIFIED (b
) = 1;
557 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = 1;
558 BUF_END_UNCHANGED (b
) = 0;
559 BUF_BEG_UNCHANGED (b
) = 0;
560 *(BUF_GPT_ADDR (b
)) = *(BUF_Z_ADDR (b
)) = 0; /* Put an anchor '\0'. */
561 b
->text
->inhibit_shrinking
= false;
562 b
->text
->redisplay
= false;
564 b
->newline_cache
= 0;
565 b
->width_run_cache
= 0;
566 b
->bidi_paragraph_cache
= 0;
567 bset_width_table (b
, Qnil
);
568 b
->prevent_redisplay_optimizations_p
= 1;
570 /* An ordinary buffer normally doesn't need markers
571 to handle BEGV and ZV. */
572 bset_pt_marker (b
, Qnil
);
573 bset_begv_marker (b
, Qnil
);
574 bset_zv_marker (b
, Qnil
);
576 name
= Fcopy_sequence (buffer_or_name
);
577 set_string_intervals (name
, NULL
);
580 bset_undo_list (b
, SREF (name
, 0) != ' ' ? Qnil
: Qt
);
583 reset_buffer_local_variables (b
, 1);
585 bset_mark (b
, Fmake_marker ());
586 BUF_MARKERS (b
) = NULL
;
588 /* Put this in the alist of all live buffers. */
589 XSETBUFFER (buffer
, b
);
590 Vbuffer_alist
= nconc2 (Vbuffer_alist
, list1 (Fcons (name
, buffer
)));
591 /* And run buffer-list-update-hook. */
592 if (!NILP (Vrun_hooks
))
593 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
599 /* Return a list of overlays which is a copy of the overlay list
600 LIST, but for buffer B. */
602 static struct Lisp_Overlay
*
603 copy_overlays (struct buffer
*b
, struct Lisp_Overlay
*list
)
605 struct Lisp_Overlay
*result
= NULL
, *tail
= NULL
;
607 for (; list
; list
= list
->next
)
609 Lisp_Object overlay
, start
, end
;
610 struct Lisp_Marker
*m
;
612 eassert (MARKERP (list
->start
));
613 m
= XMARKER (list
->start
);
614 start
= build_marker (b
, m
->charpos
, m
->bytepos
);
615 XMARKER (start
)->insertion_type
= m
->insertion_type
;
617 eassert (MARKERP (list
->end
));
618 m
= XMARKER (list
->end
);
619 end
= build_marker (b
, m
->charpos
, m
->bytepos
);
620 XMARKER (end
)->insertion_type
= m
->insertion_type
;
622 overlay
= build_overlay (start
, end
, Fcopy_sequence (list
->plist
));
624 tail
= tail
->next
= XOVERLAY (overlay
);
626 result
= tail
= XOVERLAY (overlay
);
632 /* Set an appropriate overlay of B. */
635 set_buffer_overlays_before (struct buffer
*b
, struct Lisp_Overlay
*o
)
637 b
->overlays_before
= o
;
641 set_buffer_overlays_after (struct buffer
*b
, struct Lisp_Overlay
*o
)
643 b
->overlays_after
= o
;
646 /* Clone per-buffer values of buffer FROM.
648 Buffer TO gets the same per-buffer values as FROM, with the
649 following exceptions: (1) TO's name is left untouched, (2) markers
650 are copied and made to refer to TO, and (3) overlay lists are
654 clone_per_buffer_values (struct buffer
*from
, struct buffer
*to
)
658 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
662 /* Don't touch the `name' which should be unique for every buffer. */
663 if (offset
== PER_BUFFER_VAR_OFFSET (name
))
666 obj
= per_buffer_value (from
, offset
);
667 if (MARKERP (obj
) && XMARKER (obj
)->buffer
== from
)
669 struct Lisp_Marker
*m
= XMARKER (obj
);
671 obj
= build_marker (to
, m
->charpos
, m
->bytepos
);
672 XMARKER (obj
)->insertion_type
= m
->insertion_type
;
675 set_per_buffer_value (to
, offset
, obj
);
678 memcpy (to
->local_flags
, from
->local_flags
, sizeof to
->local_flags
);
680 set_buffer_overlays_before (to
, copy_overlays (to
, from
->overlays_before
));
681 set_buffer_overlays_after (to
, copy_overlays (to
, from
->overlays_after
));
683 /* Get (a copy of) the alist of Lisp-level local variables of FROM
684 and install that in TO. */
685 bset_local_var_alist (to
, buffer_lisp_local_variables (from
, 1));
689 /* If buffer B has markers to record PT, BEGV and ZV when it is not
690 current, update these markers. */
693 record_buffer_markers (struct buffer
*b
)
695 if (! NILP (BVAR (b
, pt_marker
)))
699 eassert (!NILP (BVAR (b
, begv_marker
)));
700 eassert (!NILP (BVAR (b
, zv_marker
)));
702 XSETBUFFER (buffer
, b
);
703 set_marker_both (BVAR (b
, pt_marker
), buffer
, b
->pt
, b
->pt_byte
);
704 set_marker_both (BVAR (b
, begv_marker
), buffer
, b
->begv
, b
->begv_byte
);
705 set_marker_both (BVAR (b
, zv_marker
), buffer
, b
->zv
, b
->zv_byte
);
710 /* If buffer B has markers to record PT, BEGV and ZV when it is not
711 current, fetch these values into B->begv etc. */
714 fetch_buffer_markers (struct buffer
*b
)
716 if (! NILP (BVAR (b
, pt_marker
)))
720 eassert (!NILP (BVAR (b
, begv_marker
)));
721 eassert (!NILP (BVAR (b
, zv_marker
)));
723 m
= BVAR (b
, pt_marker
);
724 SET_BUF_PT_BOTH (b
, marker_position (m
), marker_byte_position (m
));
726 m
= BVAR (b
, begv_marker
);
727 SET_BUF_BEGV_BOTH (b
, marker_position (m
), marker_byte_position (m
));
729 m
= BVAR (b
, zv_marker
);
730 SET_BUF_ZV_BOTH (b
, marker_position (m
), marker_byte_position (m
));
735 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer
, Smake_indirect_buffer
,
737 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ",
738 doc
: /* Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.
739 BASE-BUFFER should be a live buffer, or the name of an existing buffer.
740 NAME should be a string which is not the name of an existing buffer.
741 Optional argument CLONE non-nil means preserve BASE-BUFFER's state,
742 such as major and minor modes, in the indirect buffer.
743 CLONE nil means the indirect buffer's state is reset to default values. */)
744 (Lisp_Object base_buffer
, Lisp_Object name
, Lisp_Object clone
)
746 Lisp_Object buf
, tem
;
750 buf
= Fget_buffer (name
);
752 error ("Buffer name `%s' is in use", SDATA (name
));
755 base_buffer
= Fget_buffer (base_buffer
);
756 if (NILP (base_buffer
))
757 error ("No such buffer: `%s'", SDATA (tem
));
758 if (!BUFFER_LIVE_P (XBUFFER (base_buffer
)))
759 error ("Base buffer has been killed");
761 if (SCHARS (name
) == 0)
762 error ("Empty string for buffer name is not allowed");
764 b
= allocate_buffer ();
766 /* No double indirection - if base buffer is indirect,
767 new buffer becomes an indirect to base's base. */
768 b
->base_buffer
= (XBUFFER (base_buffer
)->base_buffer
769 ? XBUFFER (base_buffer
)->base_buffer
770 : XBUFFER (base_buffer
));
772 /* Use the base buffer's text object. */
773 b
->text
= b
->base_buffer
->text
;
774 /* We have no own text. */
775 b
->indirections
= -1;
776 /* Notify base buffer that we share the text now. */
777 b
->base_buffer
->indirections
++;
778 /* Always -1 for an indirect buffer. */
779 b
->window_count
= -1;
781 b
->pt
= b
->base_buffer
->pt
;
782 b
->begv
= b
->base_buffer
->begv
;
783 b
->zv
= b
->base_buffer
->zv
;
784 b
->pt_byte
= b
->base_buffer
->pt_byte
;
785 b
->begv_byte
= b
->base_buffer
->begv_byte
;
786 b
->zv_byte
= b
->base_buffer
->zv_byte
;
788 b
->newline_cache
= 0;
789 b
->width_run_cache
= 0;
790 b
->bidi_paragraph_cache
= 0;
791 bset_width_table (b
, Qnil
);
793 name
= Fcopy_sequence (name
);
794 set_string_intervals (name
, NULL
);
797 /* An indirect buffer shares undo list of its base (Bug#18180). */
798 bset_undo_list (b
, BVAR (b
->base_buffer
, undo_list
));
801 reset_buffer_local_variables (b
, 1);
803 /* Put this in the alist of all live buffers. */
805 Vbuffer_alist
= nconc2 (Vbuffer_alist
, list1 (Fcons (name
, buf
)));
807 bset_mark (b
, Fmake_marker ());
809 /* The multibyte status belongs to the base buffer. */
810 bset_enable_multibyte_characters
811 (b
, BVAR (b
->base_buffer
, enable_multibyte_characters
));
813 /* Make sure the base buffer has markers for its narrowing. */
814 if (NILP (BVAR (b
->base_buffer
, pt_marker
)))
816 eassert (NILP (BVAR (b
->base_buffer
, begv_marker
)));
817 eassert (NILP (BVAR (b
->base_buffer
, zv_marker
)));
819 bset_pt_marker (b
->base_buffer
,
820 build_marker (b
->base_buffer
, b
->base_buffer
->pt
,
821 b
->base_buffer
->pt_byte
));
823 bset_begv_marker (b
->base_buffer
,
824 build_marker (b
->base_buffer
, b
->base_buffer
->begv
,
825 b
->base_buffer
->begv_byte
));
827 bset_zv_marker (b
->base_buffer
,
828 build_marker (b
->base_buffer
, b
->base_buffer
->zv
,
829 b
->base_buffer
->zv_byte
));
831 XMARKER (BVAR (b
->base_buffer
, zv_marker
))->insertion_type
= 1;
836 /* Give the indirect buffer markers for its narrowing. */
837 bset_pt_marker (b
, build_marker (b
, b
->pt
, b
->pt_byte
));
838 bset_begv_marker (b
, build_marker (b
, b
->begv
, b
->begv_byte
));
839 bset_zv_marker (b
, build_marker (b
, b
->zv
, b
->zv_byte
));
840 XMARKER (BVAR (b
, zv_marker
))->insertion_type
= 1;
844 struct buffer
*old_b
= current_buffer
;
846 clone_per_buffer_values (b
->base_buffer
, b
);
847 bset_filename (b
, Qnil
);
848 bset_file_truename (b
, Qnil
);
849 bset_display_count (b
, make_number (0));
850 bset_backed_up (b
, Qnil
);
851 bset_auto_save_file_name (b
, Qnil
);
852 set_buffer_internal_1 (b
);
853 Fset (intern ("buffer-save-without-query"), Qnil
);
854 Fset (intern ("buffer-file-number"), Qnil
);
855 Fset (intern ("buffer-stale-function"), Qnil
);
856 set_buffer_internal_1 (old_b
);
859 /* Run buffer-list-update-hook. */
860 if (!NILP (Vrun_hooks
))
861 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
866 /* Mark OV as no longer associated with B. */
869 drop_overlay (struct buffer
*b
, struct Lisp_Overlay
*ov
)
871 eassert (b
== XBUFFER (Fmarker_buffer (ov
->start
)));
872 modify_overlay (b
, marker_position (ov
->start
),
873 marker_position (ov
->end
));
874 unchain_marker (XMARKER (ov
->start
));
875 unchain_marker (XMARKER (ov
->end
));
879 /* Delete all overlays of B and reset it's overlay lists. */
882 delete_all_overlays (struct buffer
*b
)
884 struct Lisp_Overlay
*ov
, *next
;
886 /* FIXME: Since each drop_overlay will scan BUF_MARKERS to unlink its
887 markers, we have an unneeded O(N^2) behavior here. */
888 for (ov
= b
->overlays_before
; ov
; ov
= next
)
890 drop_overlay (b
, ov
);
895 for (ov
= b
->overlays_after
; ov
; ov
= next
)
897 drop_overlay (b
, ov
);
902 set_buffer_overlays_before (b
, NULL
);
903 set_buffer_overlays_after (b
, NULL
);
906 /* Reinitialize everything about a buffer except its name and contents
908 If called on an already-initialized buffer, the list of overlays
909 should be deleted before calling this function, otherwise we end up
910 with overlays that claim to belong to the buffer but the buffer
911 claims it doesn't belong to it. */
914 reset_buffer (register struct buffer
*b
)
916 bset_filename (b
, Qnil
);
917 bset_file_truename (b
, Qnil
);
918 bset_directory (b
, current_buffer
? BVAR (current_buffer
, directory
) : Qnil
);
919 b
->modtime
= make_timespec (0, UNKNOWN_MODTIME_NSECS
);
920 b
->modtime_size
= -1;
921 XSETFASTINT (BVAR (b
, save_length
), 0);
922 b
->last_window_start
= 1;
923 /* It is more conservative to start out "changed" than "unchanged". */
925 b
->prevent_redisplay_optimizations_p
= 1;
926 bset_backed_up (b
, Qnil
);
927 BUF_AUTOSAVE_MODIFF (b
) = 0;
928 b
->auto_save_failure_time
= 0;
929 bset_auto_save_file_name (b
, Qnil
);
930 bset_read_only (b
, Qnil
);
931 set_buffer_overlays_before (b
, NULL
);
932 set_buffer_overlays_after (b
, NULL
);
933 b
->overlay_center
= BEG
;
934 bset_mark_active (b
, Qnil
);
935 bset_point_before_scroll (b
, Qnil
);
936 bset_file_format (b
, Qnil
);
937 bset_auto_save_file_format (b
, Qt
);
938 bset_last_selected_window (b
, Qnil
);
939 bset_display_count (b
, make_number (0));
940 bset_display_time (b
, Qnil
);
941 bset_enable_multibyte_characters
942 (b
, BVAR (&buffer_defaults
, enable_multibyte_characters
));
943 bset_cursor_type (b
, BVAR (&buffer_defaults
, cursor_type
));
944 bset_extra_line_spacing (b
, BVAR (&buffer_defaults
, extra_line_spacing
));
946 b
->display_error_modiff
= 0;
949 /* Reset buffer B's local variables info.
950 Don't use this on a buffer that has already been in use;
951 it does not treat permanent locals consistently.
952 Instead, use Fkill_all_local_variables.
954 If PERMANENT_TOO, reset permanent buffer-local variables.
955 If not, preserve those. */
958 reset_buffer_local_variables (struct buffer
*b
, bool permanent_too
)
962 /* Reset the major mode to Fundamental, together with all the
963 things that depend on the major mode.
964 default-major-mode is handled at a higher level.
965 We ignore it here. */
966 bset_major_mode (b
, Qfundamental_mode
);
967 bset_keymap (b
, Qnil
);
968 bset_mode_name (b
, QSFundamental
);
969 bset_minor_modes (b
, Qnil
);
971 /* If the standard case table has been altered and invalidated,
972 fix up its insides first. */
973 if (! (CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[0])
974 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[1])
975 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[2])))
976 Fset_standard_case_table (Vascii_downcase_table
);
978 bset_downcase_table (b
, Vascii_downcase_table
);
979 bset_upcase_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[0]);
980 bset_case_canon_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[1]);
981 bset_case_eqv_table (b
, XCHAR_TABLE (Vascii_downcase_table
)->extras
[2]);
982 bset_invisibility_spec (b
, Qt
);
984 /* Reset all (or most) per-buffer variables to their defaults. */
986 bset_local_var_alist (b
, Qnil
);
989 Lisp_Object tmp
, prop
, last
= Qnil
;
990 for (tmp
= BVAR (b
, local_var_alist
); CONSP (tmp
); tmp
= XCDR (tmp
))
991 if (!NILP (prop
= Fget (XCAR (XCAR (tmp
)), Qpermanent_local
)))
993 /* If permanent-local, keep it. */
995 if (EQ (prop
, Qpermanent_local_hook
))
997 /* This is a partially permanent hook variable.
998 Preserve only the elements that want to be preserved. */
999 Lisp_Object list
, newlist
;
1000 list
= XCDR (XCAR (tmp
));
1004 for (newlist
= Qnil
; CONSP (list
); list
= XCDR (list
))
1006 Lisp_Object elt
= XCAR (list
);
1007 /* Preserve element ELT if it's t,
1008 if it is a function with a `permanent-local-hook' property,
1009 or if it's not a symbol. */
1012 || !NILP (Fget (elt
, Qpermanent_local_hook
)))
1013 newlist
= Fcons (elt
, newlist
);
1015 XSETCDR (XCAR (tmp
), Fnreverse (newlist
));
1018 /* Delete this local variable. */
1019 else if (NILP (last
))
1020 bset_local_var_alist (b
, XCDR (tmp
));
1022 XSETCDR (last
, XCDR (tmp
));
1025 for (i
= 0; i
< last_per_buffer_idx
; ++i
)
1026 if (permanent_too
|| buffer_permanent_local_flags
[i
] == 0)
1027 SET_PER_BUFFER_VALUE_P (b
, i
, 0);
1029 /* For each slot that has a default value, copy that into the slot. */
1030 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
1032 int idx
= PER_BUFFER_IDX (offset
);
1035 || buffer_permanent_local_flags
[idx
] == 0)))
1036 set_per_buffer_value (b
, offset
, per_buffer_default (offset
));
1040 /* We split this away from generate-new-buffer, because rename-buffer
1041 and set-visited-file-name ought to be able to use this to really
1042 rename the buffer properly. */
1044 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name
,
1045 Sgenerate_new_buffer_name
, 1, 2, 0,
1046 doc
: /* Return a string that is the name of no existing buffer based on NAME.
1047 If there is no live buffer named NAME, then return NAME.
1048 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
1049 \(starting at 2) until an unused name is found, and then return that name.
1050 Optional second argument IGNORE specifies a name that is okay to use (if
1051 it is in the sequence to be tried) even if a buffer with that name exists.
1053 If NAME begins with a space (i.e., a buffer that is not normally
1054 visible to users), then if buffer NAME already exists a random number
1055 is first appended to NAME, to speed up finding a non-existent buffer. */)
1056 (register Lisp_Object name
, Lisp_Object ignore
)
1058 register Lisp_Object gentemp
, tem
, tem2
;
1060 char number
[INT_BUFSIZE_BOUND (ptrdiff_t) + sizeof "<>"];
1062 CHECK_STRING (name
);
1064 tem
= Fstring_equal (name
, ignore
);
1067 tem
= Fget_buffer (name
);
1071 if (!strncmp (SSDATA (name
), " ", 1)) /* see bug#1229 */
1073 /* Note fileio.c:make_temp_name does random differently. */
1074 tem2
= concat2 (name
, make_formatted_string
1076 XFASTINT (Frandom (make_number (999999)))));
1077 tem
= Fget_buffer (tem2
);
1087 gentemp
= concat2 (tem2
, make_formatted_string
1088 (number
, "<%"pD
"d>", ++count
));
1089 tem
= Fstring_equal (gentemp
, ignore
);
1092 tem
= Fget_buffer (gentemp
);
1099 DEFUN ("buffer-name", Fbuffer_name
, Sbuffer_name
, 0, 1, 0,
1100 doc
: /* Return the name of BUFFER, as a string.
1101 BUFFER defaults to the current buffer.
1102 Return nil if BUFFER has been killed. */)
1103 (register Lisp_Object buffer
)
1105 return BVAR (decode_buffer (buffer
), name
);
1108 DEFUN ("buffer-file-name", Fbuffer_file_name
, Sbuffer_file_name
, 0, 1, 0,
1109 doc
: /* Return name of file BUFFER is visiting, or nil if none.
1110 No argument or nil as argument means use the current buffer. */)
1111 (register Lisp_Object buffer
)
1113 return BVAR (decode_buffer (buffer
), filename
);
1116 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer
, Sbuffer_base_buffer
,
1118 doc
: /* Return the base buffer of indirect buffer BUFFER.
1119 If BUFFER is not indirect, return nil.
1120 BUFFER defaults to the current buffer. */)
1121 (register Lisp_Object buffer
)
1123 struct buffer
*base
= decode_buffer (buffer
)->base_buffer
;
1124 return base
? (XSETBUFFER (buffer
, base
), buffer
) : Qnil
;
1127 DEFUN ("buffer-local-value", Fbuffer_local_value
,
1128 Sbuffer_local_value
, 2, 2, 0,
1129 doc
: /* Return the value of VARIABLE in BUFFER.
1130 If VARIABLE does not have a buffer-local binding in BUFFER, the value
1131 is the default binding of the variable. */)
1132 (register Lisp_Object variable
, register Lisp_Object buffer
)
1134 register Lisp_Object result
= buffer_local_value (variable
, buffer
);
1136 if (EQ (result
, Qunbound
))
1137 xsignal1 (Qvoid_variable
, variable
);
1143 /* Like Fbuffer_local_value, but return Qunbound if the variable is
1147 buffer_local_value (Lisp_Object variable
, Lisp_Object buffer
)
1149 register struct buffer
*buf
;
1150 register Lisp_Object result
;
1151 struct Lisp_Symbol
*sym
;
1153 CHECK_SYMBOL (variable
);
1154 CHECK_BUFFER (buffer
);
1155 buf
= XBUFFER (buffer
);
1156 sym
= XSYMBOL (variable
);
1159 switch (sym
->redirect
)
1161 case SYMBOL_VARALIAS
: sym
= indirect_variable (sym
); goto start
;
1162 case SYMBOL_PLAINVAL
: result
= SYMBOL_VAL (sym
); break;
1163 case SYMBOL_LOCALIZED
:
1164 { /* Look in local_var_alist. */
1165 struct Lisp_Buffer_Local_Value
*blv
= SYMBOL_BLV (sym
);
1166 XSETSYMBOL (variable
, sym
); /* Update In case of aliasing. */
1167 result
= Fassoc (variable
, BVAR (buf
, local_var_alist
));
1171 { /* What binding is loaded right now? */
1172 Lisp_Object current_alist_element
= blv
->valcell
;
1174 /* The value of the currently loaded binding is not
1175 stored in it, but rather in the realvalue slot.
1176 Store that value into the binding it belongs to
1177 in case that is the one we are about to use. */
1179 XSETCDR (current_alist_element
,
1180 do_symval_forwarding (blv
->fwd
));
1182 /* Now get the (perhaps updated) value out of the binding. */
1183 result
= XCDR (result
);
1186 result
= Fdefault_value (variable
);
1189 case SYMBOL_FORWARDED
:
1191 union Lisp_Fwd
*fwd
= SYMBOL_FWD (sym
);
1192 if (BUFFER_OBJFWDP (fwd
))
1193 result
= per_buffer_value (buf
, XBUFFER_OBJFWD (fwd
)->offset
);
1195 result
= Fdefault_value (variable
);
1198 default: emacs_abort ();
1204 /* Return an alist of the Lisp-level buffer-local bindings of
1205 buffer BUF. That is, don't include the variables maintained
1206 in special slots in the buffer object.
1207 If not CLONE, replace elements of the form (VAR . unbound)
1211 buffer_lisp_local_variables (struct buffer
*buf
, bool clone
)
1213 Lisp_Object result
= Qnil
;
1215 for (tail
= BVAR (buf
, local_var_alist
); CONSP (tail
); tail
= XCDR (tail
))
1217 Lisp_Object val
, elt
;
1221 /* Reference each variable in the alist in buf.
1222 If inquiring about the current buffer, this gets the current values,
1223 so store them into the alist so the alist is up to date.
1224 If inquiring about some other buffer, this swaps out any values
1225 for that buffer, making the alist up to date automatically. */
1226 val
= find_symbol_value (XCAR (elt
));
1227 /* Use the current buffer value only if buf is the current buffer. */
1228 if (buf
!= current_buffer
)
1231 result
= Fcons (!clone
&& EQ (val
, Qunbound
)
1233 : Fcons (XCAR (elt
), val
),
1240 DEFUN ("buffer-local-variables", Fbuffer_local_variables
,
1241 Sbuffer_local_variables
, 0, 1, 0,
1242 doc
: /* Return an alist of variables that are buffer-local in BUFFER.
1243 Most elements look like (SYMBOL . VALUE), describing one variable.
1244 For a symbol that is locally unbound, just the symbol appears in the value.
1245 Note that storing new VALUEs in these elements doesn't change the variables.
1246 No argument or nil as argument means use current buffer as BUFFER. */)
1247 (Lisp_Object buffer
)
1249 struct buffer
*buf
= decode_buffer (buffer
);
1250 Lisp_Object result
= buffer_lisp_local_variables (buf
, 0);
1252 /* Add on all the variables stored in special slots. */
1256 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
1258 idx
= PER_BUFFER_IDX (offset
);
1259 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
1260 && SYMBOLP (PER_BUFFER_SYMBOL (offset
)))
1262 Lisp_Object sym
= PER_BUFFER_SYMBOL (offset
);
1263 Lisp_Object val
= per_buffer_value (buf
, offset
);
1264 result
= Fcons (EQ (val
, Qunbound
) ? sym
: Fcons (sym
, val
),
1273 DEFUN ("buffer-modified-p", Fbuffer_modified_p
, Sbuffer_modified_p
,
1275 doc
: /* Return t if BUFFER was modified since its file was last read or saved.
1276 No argument or nil as argument means use current buffer as BUFFER. */)
1277 (Lisp_Object buffer
)
1279 struct buffer
*buf
= decode_buffer (buffer
);
1280 return BUF_SAVE_MODIFF (buf
) < BUF_MODIFF (buf
) ? Qt
: Qnil
;
1283 DEFUN ("force-mode-line-update", Fforce_mode_line_update
,
1284 Sforce_mode_line_update
, 0, 1, 0,
1285 doc
: /* Force redisplay of the current buffer's mode line and header line.
1286 With optional non-nil ALL, force redisplay of all mode lines and
1287 header lines. This function also forces recomputation of the
1288 menu bar menus and the frame title. */)
1293 update_mode_lines
= 10;
1294 /* FIXME: This can't be right. */
1295 current_buffer
->prevent_redisplay_optimizations_p
= true;
1297 else if (buffer_window_count (current_buffer
))
1299 bset_update_mode_line (current_buffer
);
1300 current_buffer
->prevent_redisplay_optimizations_p
= true;
1305 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p
, Sset_buffer_modified_p
,
1307 doc
: /* Mark current buffer as modified or unmodified according to FLAG.
1308 A non-nil FLAG means mark the buffer modified. */)
1311 Frestore_buffer_modified_p (flag
);
1313 /* Set update_mode_lines only if buffer is displayed in some window.
1314 Packages like jit-lock or lazy-lock preserve a buffer's modified
1315 state by recording/restoring the state around blocks of code.
1316 Setting update_mode_lines makes redisplay consider all windows
1317 (on all frames). Stealth fontification of buffers not displayed
1318 would incur additional redisplay costs if we'd set
1319 update_modes_lines unconditionally.
1321 Ideally, I think there should be another mechanism for fontifying
1322 buffers without "modifying" buffers, or redisplay should be
1323 smarter about updating the `*' in mode lines. --gerd */
1324 return Fforce_mode_line_update (Qnil
);
1327 DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p
,
1328 Srestore_buffer_modified_p
, 1, 1, 0,
1329 doc
: /* Like `set-buffer-modified-p', with a difference concerning redisplay.
1330 It is not ensured that mode lines will be updated to show the modified
1331 state of the current buffer. Use with care. */)
1336 /* If buffer becoming modified, lock the file.
1337 If buffer becoming unmodified, unlock the file. */
1339 struct buffer
*b
= current_buffer
->base_buffer
1340 ? current_buffer
->base_buffer
1343 fn
= BVAR (b
, file_truename
);
1344 /* Test buffer-file-name so that binding it to nil is effective. */
1345 if (!NILP (fn
) && ! NILP (BVAR (b
, filename
)))
1347 bool already
= SAVE_MODIFF
< MODIFF
;
1348 if (!already
&& !NILP (flag
))
1350 else if (already
&& NILP (flag
))
1354 /* Here we have a problem. SAVE_MODIFF is used here to encode
1355 buffer-modified-p (as SAVE_MODIFF<MODIFF) as well as
1356 recent-auto-save-p (as SAVE_MODIFF<auto_save_modified). So if we
1357 modify SAVE_MODIFF to affect one, we may affect the other
1359 E.g. if FLAG is nil we need to set SAVE_MODIFF to MODIFF, but
1360 if SAVE_MODIFF<auto_save_modified that means we risk changing
1361 recent-auto-save-p from t to nil.
1362 Vice versa, if FLAG is non-nil and SAVE_MODIFF>=auto_save_modified
1363 we risk changing recent-auto-save-p from nil to t. */
1364 SAVE_MODIFF
= (NILP (flag
)
1365 /* FIXME: This unavoidably sets recent-auto-save-p to nil. */
1367 /* Let's try to preserve recent-auto-save-p. */
1368 : SAVE_MODIFF
< MODIFF
? SAVE_MODIFF
1369 /* If SAVE_MODIFF == auto_save_modified == MODIFF,
1370 we can either decrease SAVE_MODIFF and auto_save_modified
1371 or increase MODIFF. */
1377 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick
, Sbuffer_modified_tick
,
1379 doc
: /* Return BUFFER's tick counter, incremented for each change in text.
1380 Each buffer has a tick counter which is incremented each time the
1381 text in that buffer is changed. It wraps around occasionally.
1382 No argument or nil as argument means use current buffer as BUFFER. */)
1383 (register Lisp_Object buffer
)
1385 return make_number (BUF_MODIFF (decode_buffer (buffer
)));
1388 DEFUN ("buffer-chars-modified-tick", Fbuffer_chars_modified_tick
,
1389 Sbuffer_chars_modified_tick
, 0, 1, 0,
1390 doc
: /* Return BUFFER's character-change tick counter.
1391 Each buffer has a character-change tick counter, which is set to the
1392 value of the buffer's tick counter \(see `buffer-modified-tick'), each
1393 time text in that buffer is inserted or deleted. By comparing the
1394 values returned by two individual calls of `buffer-chars-modified-tick',
1395 you can tell whether a character change occurred in that buffer in
1396 between these calls. No argument or nil as argument means use current
1397 buffer as BUFFER. */)
1398 (register Lisp_Object buffer
)
1400 return make_number (BUF_CHARS_MODIFF (decode_buffer (buffer
)));
1403 DEFUN ("rename-buffer", Frename_buffer
, Srename_buffer
, 1, 2,
1404 "(list (read-string \"Rename buffer (to new name): \" \
1405 nil 'buffer-name-history (buffer-name (current-buffer))) \
1406 current-prefix-arg)",
1407 doc
: /* Change current buffer's name to NEWNAME (a string).
1408 If second arg UNIQUE is nil or omitted, it is an error if a
1409 buffer named NEWNAME already exists.
1410 If UNIQUE is non-nil, come up with a new name using
1411 `generate-new-buffer-name'.
1412 Interactively, you can set UNIQUE with a prefix argument.
1413 We return the name we actually gave the buffer.
1414 This does not change the name of the visited file (if any). */)
1415 (register Lisp_Object newname
, Lisp_Object unique
)
1417 register Lisp_Object tem
, buf
;
1419 CHECK_STRING (newname
);
1421 if (SCHARS (newname
) == 0)
1422 error ("Empty string is invalid as a buffer name");
1424 tem
= Fget_buffer (newname
);
1427 /* Don't short-circuit if UNIQUE is t. That is a useful way to
1428 rename the buffer automatically so you can create another
1429 with the original name. It makes UNIQUE equivalent to
1430 (rename-buffer (generate-new-buffer-name NEWNAME)). */
1431 if (NILP (unique
) && XBUFFER (tem
) == current_buffer
)
1432 return BVAR (current_buffer
, name
);
1434 newname
= Fgenerate_new_buffer_name (newname
, BVAR (current_buffer
, name
));
1436 error ("Buffer name `%s' is in use", SDATA (newname
));
1439 bset_name (current_buffer
, newname
);
1441 /* Catch redisplay's attention. Unless we do this, the mode lines for
1442 any windows displaying current_buffer will stay unchanged. */
1443 update_mode_lines
= 11;
1445 XSETBUFFER (buf
, current_buffer
);
1446 Fsetcar (Frassq (buf
, Vbuffer_alist
), newname
);
1447 if (NILP (BVAR (current_buffer
, filename
))
1448 && !NILP (BVAR (current_buffer
, auto_save_file_name
)))
1449 call0 (intern ("rename-auto-save-file"));
1451 /* Run buffer-list-update-hook. */
1452 if (!NILP (Vrun_hooks
))
1453 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1455 /* Refetch since that last call may have done GC. */
1456 return BVAR (current_buffer
, name
);
1459 /* True if B can be used as 'other-than-BUFFER' buffer. */
1462 candidate_buffer (Lisp_Object b
, Lisp_Object buffer
)
1464 return (BUFFERP (b
) && !EQ (b
, buffer
)
1465 && BUFFER_LIVE_P (XBUFFER (b
))
1466 && !BUFFER_HIDDEN_P (XBUFFER (b
)));
1469 DEFUN ("other-buffer", Fother_buffer
, Sother_buffer
, 0, 3, 0,
1470 doc
: /* Return most recently selected buffer other than BUFFER.
1471 Buffers not visible in windows are preferred to visible buffers, unless
1472 optional second argument VISIBLE-OK is non-nil. Ignore the argument
1473 BUFFER unless it denotes a live buffer. If the optional third argument
1474 FRAME is non-nil, use that frame's buffer list instead of the selected
1475 frame's buffer list.
1477 The buffer is found by scanning the selected or specified frame's buffer
1478 list first, followed by the list of all buffers. If no other buffer
1479 exists, return the buffer `*scratch*' (creating it if necessary). */)
1480 (Lisp_Object buffer
, Lisp_Object visible_ok
, Lisp_Object frame
)
1482 struct frame
*f
= decode_any_frame (frame
);
1483 Lisp_Object tail
= f
->buffer_list
, pred
= f
->buffer_predicate
;
1484 Lisp_Object buf
, notsogood
= Qnil
;
1486 /* Consider buffers that have been seen in the frame first. */
1487 for (; CONSP (tail
); tail
= XCDR (tail
))
1490 if (candidate_buffer (buf
, buffer
)
1491 /* If the frame has a buffer_predicate, disregard buffers that
1492 don't fit the predicate. */
1493 && (NILP (pred
) || !NILP (call1 (pred
, buf
))))
1495 if (!NILP (visible_ok
)
1496 || NILP (Fget_buffer_window (buf
, Qvisible
)))
1498 else if (NILP (notsogood
))
1503 /* Consider alist of all buffers next. */
1504 FOR_EACH_LIVE_BUFFER (tail
, buf
)
1506 if (candidate_buffer (buf
, buffer
)
1507 /* If the frame has a buffer_predicate, disregard buffers that
1508 don't fit the predicate. */
1509 && (NILP (pred
) || !NILP (call1 (pred
, buf
))))
1511 if (!NILP (visible_ok
)
1512 || NILP (Fget_buffer_window (buf
, Qvisible
)))
1514 else if (NILP (notsogood
))
1519 if (!NILP (notsogood
))
1523 AUTO_STRING (scratch
, "*scratch*");
1524 buf
= Fget_buffer (scratch
);
1527 buf
= Fget_buffer_create (scratch
);
1528 Fset_buffer_major_mode (buf
);
1534 /* The following function is a safe variant of Fother_buffer: It doesn't
1535 pay attention to any frame-local buffer lists, doesn't care about
1536 visibility of buffers, and doesn't evaluate any frame predicates. */
1539 other_buffer_safely (Lisp_Object buffer
)
1541 Lisp_Object tail
, buf
;
1543 FOR_EACH_LIVE_BUFFER (tail
, buf
)
1544 if (candidate_buffer (buf
, buffer
))
1547 AUTO_STRING (scratch
, "*scratch*");
1548 buf
= Fget_buffer (scratch
);
1551 buf
= Fget_buffer_create (scratch
);
1552 Fset_buffer_major_mode (buf
);
1558 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo
, Sbuffer_enable_undo
,
1560 doc
: /* Start keeping undo information for buffer BUFFER.
1561 No argument or nil as argument means do this for the current buffer. */)
1562 (register Lisp_Object buffer
)
1564 Lisp_Object real_buffer
;
1567 XSETBUFFER (real_buffer
, current_buffer
);
1570 real_buffer
= Fget_buffer (buffer
);
1571 if (NILP (real_buffer
))
1575 if (EQ (BVAR (XBUFFER (real_buffer
), undo_list
), Qt
))
1576 bset_undo_list (XBUFFER (real_buffer
), Qnil
);
1581 /* Truncate undo list and shrink the gap of BUFFER. */
1584 compact_buffer (struct buffer
*buffer
)
1586 BUFFER_CHECK_INDIRECTION (buffer
);
1588 /* Skip dead buffers, indirect buffers and buffers
1589 which aren't changed since last compaction. */
1590 if (BUFFER_LIVE_P (buffer
)
1591 && (buffer
->base_buffer
== NULL
)
1592 && (BUF_COMPACT (buffer
) != BUF_MODIFF (buffer
)))
1594 /* If a buffer's undo list is Qt, that means that undo is
1595 turned off in that buffer. Calling truncate_undo_list on
1596 Qt tends to return NULL, which effectively turns undo back on.
1597 So don't call truncate_undo_list if undo_list is Qt. */
1598 if (!EQ (buffer
->INTERNAL_FIELD (undo_list
), Qt
))
1599 truncate_undo_list (buffer
);
1601 /* Shrink buffer gaps. */
1602 if (!buffer
->text
->inhibit_shrinking
)
1604 /* If a buffer's gap size is more than 10% of the buffer
1605 size, or larger than GAP_BYTES_DFL bytes, then shrink it
1606 accordingly. Keep a minimum size of GAP_BYTES_MIN bytes. */
1607 ptrdiff_t size
= clip_to_bounds (GAP_BYTES_MIN
,
1608 BUF_Z_BYTE (buffer
) / 10,
1610 if (BUF_GAP_SIZE (buffer
) > size
)
1611 make_gap_1 (buffer
, -(BUF_GAP_SIZE (buffer
) - size
));
1613 BUF_COMPACT (buffer
) = BUF_MODIFF (buffer
);
1617 DEFUN ("kill-buffer", Fkill_buffer
, Skill_buffer
, 0, 1, "bKill buffer: ",
1618 doc
: /* Kill the buffer specified by BUFFER-OR-NAME.
1619 The argument may be a buffer or the name of an existing buffer.
1620 Argument nil or omitted means kill the current buffer. Return t if the
1621 buffer is actually killed, nil otherwise.
1623 The functions in `kill-buffer-query-functions' are called with the
1624 buffer to be killed as the current buffer. If any of them returns nil,
1625 the buffer is not killed. The hook `kill-buffer-hook' is run before the
1626 buffer is actually killed. The buffer being killed will be current
1627 while the hook is running. Functions called by any of these hooks are
1628 supposed to not change the current buffer.
1630 Any processes that have this buffer as the `process-buffer' are killed
1631 with SIGHUP. This function calls `replace-buffer-in-windows' for
1632 cleaning up all windows currently displaying the buffer to be killed. */)
1633 (Lisp_Object buffer_or_name
)
1636 register struct buffer
*b
;
1637 register Lisp_Object tem
;
1638 register struct Lisp_Marker
*m
;
1639 struct gcpro gcpro1
;
1641 if (NILP (buffer_or_name
))
1642 buffer
= Fcurrent_buffer ();
1644 buffer
= Fget_buffer (buffer_or_name
);
1646 nsberror (buffer_or_name
);
1648 b
= XBUFFER (buffer
);
1650 /* Avoid trouble for buffer already dead. */
1651 if (!BUFFER_LIVE_P (b
))
1654 /* Run hooks with the buffer to be killed the current buffer. */
1656 ptrdiff_t count
= SPECPDL_INDEX ();
1657 Lisp_Object arglist
[1];
1659 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1660 set_buffer_internal (b
);
1662 /* First run the query functions; if any query is answered no,
1663 don't kill the buffer. */
1664 arglist
[0] = Qkill_buffer_query_functions
;
1665 tem
= Frun_hook_with_args_until_failure (1, arglist
);
1667 return unbind_to (count
, Qnil
);
1669 /* Query if the buffer is still modified. */
1670 if (INTERACTIVE
&& !NILP (BVAR (b
, filename
))
1671 && BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
1674 tem
= do_yes_or_no_p (format2 ("Buffer %s modified; kill anyway? ",
1675 BVAR (b
, name
), make_number (0)));
1678 return unbind_to (count
, Qnil
);
1681 /* If the hooks have killed the buffer, exit now. */
1682 if (!BUFFER_LIVE_P (b
))
1683 return unbind_to (count
, Qt
);
1685 /* Then run the hooks. */
1686 run_hook (Qkill_buffer_hook
);
1687 unbind_to (count
, Qnil
);
1690 /* If the hooks have killed the buffer, exit now. */
1691 if (!BUFFER_LIVE_P (b
))
1694 /* We have no more questions to ask. Verify that it is valid
1695 to kill the buffer. This must be done after the questions
1696 since anything can happen within do_yes_or_no_p. */
1698 /* Don't kill the minibuffer now current. */
1699 if (EQ (buffer
, XWINDOW (minibuf_window
)->contents
))
1702 /* When we kill an ordinary buffer which shares it's buffer text
1703 with indirect buffer(s), we must kill indirect buffer(s) too.
1704 We do it at this stage so nothing terrible happens if they
1705 ask questions or their hooks get errors. */
1706 if (!b
->base_buffer
&& b
->indirections
> 0)
1708 struct buffer
*other
;
1712 FOR_EACH_BUFFER (other
)
1713 if (other
->base_buffer
== b
)
1716 XSETBUFFER (buf
, other
);
1722 /* Exit if we now have killed the base buffer (Bug#11665). */
1723 if (!BUFFER_LIVE_P (b
))
1727 /* Run replace_buffer_in_windows before making another buffer current
1728 since set-window-buffer-start-and-point will refuse to make another
1729 buffer current if the selected window does not show the current
1730 buffer (bug#10114). */
1731 replace_buffer_in_windows (buffer
);
1733 /* Exit if replacing the buffer in windows has killed our buffer. */
1734 if (!BUFFER_LIVE_P (b
))
1737 /* Make this buffer not be current. Exit if it is the sole visible
1739 if (b
== current_buffer
)
1741 tem
= Fother_buffer (buffer
, Qnil
, Qnil
);
1743 if (b
== current_buffer
)
1747 /* If the buffer now current is shown in the minibuffer and our buffer
1748 is the sole other buffer give up. */
1749 XSETBUFFER (tem
, current_buffer
);
1750 if (EQ (tem
, XWINDOW (minibuf_window
)->contents
)
1751 && EQ (buffer
, Fother_buffer (buffer
, Qnil
, Qnil
)))
1754 /* Now there is no question: we can kill the buffer. */
1756 /* Unlock this buffer's file, if it is locked. */
1760 kill_buffer_processes (buffer
);
1763 /* Killing buffer processes may run sentinels which may have killed
1765 if (!BUFFER_LIVE_P (b
))
1768 /* These may run Lisp code and into infinite loops (if someone
1769 insisted on circular lists) so allow quitting here. */
1770 frames_discard_buffer (buffer
);
1772 clear_charpos_cache (b
);
1774 tem
= Vinhibit_quit
;
1776 /* Remove the buffer from the list of all buffers. */
1777 Vbuffer_alist
= Fdelq (Frassq (buffer
, Vbuffer_alist
), Vbuffer_alist
);
1778 /* If replace_buffer_in_windows didn't do its job fix that now. */
1779 replace_buffer_in_windows_safely (buffer
);
1780 Vinhibit_quit
= tem
;
1782 /* Delete any auto-save file, if we saved it in this session.
1783 But not if the buffer is modified. */
1784 if (STRINGP (BVAR (b
, auto_save_file_name
))
1785 && BUF_AUTOSAVE_MODIFF (b
) != 0
1786 && BUF_SAVE_MODIFF (b
) < BUF_AUTOSAVE_MODIFF (b
)
1787 && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
)
1788 && NILP (Fsymbol_value (intern ("auto-save-visited-file-name"))))
1791 delete = Fsymbol_value (intern ("delete-auto-save-files"));
1792 if (! NILP (delete))
1793 internal_delete_file (BVAR (b
, auto_save_file_name
));
1796 /* Deleting an auto-save file could have killed our buffer. */
1797 if (!BUFFER_LIVE_P (b
))
1803 /* Unchain all markers that belong to this indirect buffer.
1804 Don't unchain the markers that belong to the base buffer
1805 or its other indirect buffers. */
1806 struct Lisp_Marker
**mp
= &BUF_MARKERS (b
);
1817 /* Intervals should be owned by the base buffer (Bug#16502). */
1818 i
= buffer_intervals (b
);
1822 XSETBUFFER (owner
, b
->base_buffer
);
1823 set_interval_object (i
, owner
);
1828 /* Unchain all markers of this buffer and its indirect buffers.
1829 and leave them pointing nowhere. */
1830 for (m
= BUF_MARKERS (b
); m
; )
1832 struct Lisp_Marker
*next
= m
->next
;
1837 BUF_MARKERS (b
) = NULL
;
1838 set_buffer_intervals (b
, NULL
);
1840 /* Perhaps we should explicitly free the interval tree here... */
1842 /* Since we've unlinked the markers, the overlays can't be here any more
1844 b
->overlays_before
= NULL
;
1845 b
->overlays_after
= NULL
;
1847 /* Reset the local variables, so that this buffer's local values
1848 won't be protected from GC. They would be protected
1849 if they happened to remain cached in their symbols.
1850 This gets rid of them for certain. */
1851 swap_out_buffer_local_variables (b
);
1852 reset_buffer_local_variables (b
, 1);
1854 bset_name (b
, Qnil
);
1859 /* Notify our base buffer that we don't share the text anymore. */
1860 eassert (b
->indirections
== -1);
1861 b
->base_buffer
->indirections
--;
1862 eassert (b
->base_buffer
->indirections
>= 0);
1863 /* Make sure that we wasn't confused. */
1864 eassert (b
->window_count
== -1);
1868 /* Make sure that no one shows us. */
1869 eassert (b
->window_count
== 0);
1870 /* No one shares our buffer text, can free it. */
1871 free_buffer_text (b
);
1874 if (b
->newline_cache
)
1876 free_region_cache (b
->newline_cache
);
1877 b
->newline_cache
= 0;
1879 if (b
->width_run_cache
)
1881 free_region_cache (b
->width_run_cache
);
1882 b
->width_run_cache
= 0;
1884 if (b
->bidi_paragraph_cache
)
1886 free_region_cache (b
->bidi_paragraph_cache
);
1887 b
->bidi_paragraph_cache
= 0;
1889 bset_width_table (b
, Qnil
);
1891 bset_undo_list (b
, Qnil
);
1893 /* Run buffer-list-update-hook. */
1894 if (!NILP (Vrun_hooks
))
1895 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1900 /* Move association for BUFFER to the front of buffer (a)lists. Since
1901 we do this each time BUFFER is selected visibly, the more recently
1902 selected buffers are always closer to the front of those lists. This
1903 means that other_buffer is more likely to choose a relevant buffer.
1905 Note that this moves BUFFER to the front of the buffer lists of the
1906 selected frame even if BUFFER is not shown there. If BUFFER is not
1907 shown in the selected frame, consider the present behavior a feature.
1908 `select-window' gets this right since it shows BUFFER in the selected
1909 window when calling us. */
1912 record_buffer (Lisp_Object buffer
)
1914 Lisp_Object aelt
, aelt_cons
, tem
;
1915 register struct frame
*f
= XFRAME (selected_frame
);
1917 CHECK_BUFFER (buffer
);
1919 /* Update Vbuffer_alist (we know that it has an entry for BUFFER).
1920 Don't allow quitting since this might leave the buffer list in an
1921 inconsistent state. */
1922 tem
= Vinhibit_quit
;
1924 aelt
= Frassq (buffer
, Vbuffer_alist
);
1925 aelt_cons
= Fmemq (aelt
, Vbuffer_alist
);
1926 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
1927 XSETCDR (aelt_cons
, Vbuffer_alist
);
1928 Vbuffer_alist
= aelt_cons
;
1929 Vinhibit_quit
= tem
;
1931 /* Update buffer list of selected frame. */
1932 fset_buffer_list (f
, Fcons (buffer
, Fdelq (buffer
, f
->buffer_list
)));
1933 fset_buried_buffer_list (f
, Fdelq (buffer
, f
->buried_buffer_list
));
1935 /* Run buffer-list-update-hook. */
1936 if (!NILP (Vrun_hooks
))
1937 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1941 /* Move BUFFER to the end of the buffer (a)lists. Do nothing if the
1942 buffer is killed. For the selected frame's buffer list this moves
1943 BUFFER to its end even if it was never shown in that frame. If
1944 this happens we have a feature, hence `bury-buffer-internal' should be
1945 called only when BUFFER was shown in the selected frame. */
1947 DEFUN ("bury-buffer-internal", Fbury_buffer_internal
, Sbury_buffer_internal
,
1949 doc
: /* Move BUFFER to the end of the buffer list. */)
1950 (Lisp_Object buffer
)
1952 Lisp_Object aelt
, aelt_cons
, tem
;
1953 register struct frame
*f
= XFRAME (selected_frame
);
1955 CHECK_BUFFER (buffer
);
1957 /* Update Vbuffer_alist (we know that it has an entry for BUFFER).
1958 Don't allow quitting since this might leave the buffer list in an
1959 inconsistent state. */
1960 tem
= Vinhibit_quit
;
1962 aelt
= Frassq (buffer
, Vbuffer_alist
);
1963 aelt_cons
= Fmemq (aelt
, Vbuffer_alist
);
1964 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
1965 XSETCDR (aelt_cons
, Qnil
);
1966 Vbuffer_alist
= nconc2 (Vbuffer_alist
, aelt_cons
);
1967 Vinhibit_quit
= tem
;
1969 /* Update buffer lists of selected frame. */
1970 fset_buffer_list (f
, Fdelq (buffer
, f
->buffer_list
));
1971 fset_buried_buffer_list
1972 (f
, Fcons (buffer
, Fdelq (buffer
, f
->buried_buffer_list
)));
1974 /* Run buffer-list-update-hook. */
1975 if (!NILP (Vrun_hooks
))
1976 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1981 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode
, Sset_buffer_major_mode
, 1, 1, 0,
1982 doc
: /* Set an appropriate major mode for BUFFER.
1983 For the *scratch* buffer, use `initial-major-mode', otherwise choose a mode
1984 according to the default value of `major-mode'.
1985 Use this function before selecting the buffer, since it may need to inspect
1986 the current buffer's major mode. */)
1987 (Lisp_Object buffer
)
1990 Lisp_Object function
;
1992 CHECK_BUFFER (buffer
);
1994 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
1995 error ("Attempt to set major mode for a dead buffer");
1997 if (strcmp (SSDATA (BVAR (XBUFFER (buffer
), name
)), "*scratch*") == 0)
1998 function
= find_symbol_value (intern ("initial-major-mode"));
2001 function
= BVAR (&buffer_defaults
, major_mode
);
2003 && NILP (Fget (BVAR (current_buffer
, major_mode
), Qmode_class
)))
2004 function
= BVAR (current_buffer
, major_mode
);
2007 if (NILP (function
) || EQ (function
, Qfundamental_mode
))
2010 count
= SPECPDL_INDEX ();
2012 /* To select a nonfundamental mode,
2013 select the buffer temporarily and then call the mode function. */
2015 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
2017 Fset_buffer (buffer
);
2020 return unbind_to (count
, Qnil
);
2023 DEFUN ("current-buffer", Fcurrent_buffer
, Scurrent_buffer
, 0, 0, 0,
2024 doc
: /* Return the current buffer as a Lisp object. */)
2027 register Lisp_Object buf
;
2028 XSETBUFFER (buf
, current_buffer
);
2032 /* Set the current buffer to B, and do not set windows_or_buffers_changed.
2033 This is used by redisplay. */
2036 set_buffer_internal_1 (register struct buffer
*b
)
2038 register struct buffer
*old_buf
;
2039 register Lisp_Object tail
;
2041 #ifdef USE_MMAP_FOR_BUFFERS
2042 if (b
->text
->beg
== NULL
)
2043 enlarge_buffer_text (b
, 0);
2044 #endif /* USE_MMAP_FOR_BUFFERS */
2046 if (current_buffer
== b
)
2049 BUFFER_CHECK_INDIRECTION (b
);
2051 old_buf
= current_buffer
;
2053 last_known_column_point
= -1; /* Invalidate indentation cache. */
2057 /* Put the undo list back in the base buffer, so that it appears
2058 that an indirect buffer shares the undo list of its base. */
2059 if (old_buf
->base_buffer
)
2060 bset_undo_list (old_buf
->base_buffer
, BVAR (old_buf
, undo_list
));
2062 /* If the old current buffer has markers to record PT, BEGV and ZV
2063 when it is not current, update them now. */
2064 record_buffer_markers (old_buf
);
2067 /* Get the undo list from the base buffer, so that it appears
2068 that an indirect buffer shares the undo list of its base. */
2070 bset_undo_list (b
, BVAR (b
->base_buffer
, undo_list
));
2072 /* If the new current buffer has markers to record PT, BEGV and ZV
2073 when it is not current, fetch them now. */
2074 fetch_buffer_markers (b
);
2076 /* Look down buffer's list of local Lisp variables
2077 to find and update any that forward into C variables. */
2081 for (tail
= BVAR (b
, local_var_alist
); CONSP (tail
); tail
= XCDR (tail
))
2083 Lisp_Object var
= XCAR (XCAR (tail
));
2084 struct Lisp_Symbol
*sym
= XSYMBOL (var
);
2085 if (sym
->redirect
== SYMBOL_LOCALIZED
/* Just to be sure. */
2086 && SYMBOL_BLV (sym
)->fwd
)
2087 /* Just reference the variable
2088 to cause it to become set for this buffer. */
2089 Fsymbol_value (var
);
2092 /* Do the same with any others that were local to the previous buffer */
2093 while (b
!= old_buf
&& (b
= old_buf
, b
));
2096 /* Switch to buffer B temporarily for redisplay purposes.
2097 This avoids certain things that don't need to be done within redisplay. */
2100 set_buffer_temp (struct buffer
*b
)
2102 register struct buffer
*old_buf
;
2104 if (current_buffer
== b
)
2107 old_buf
= current_buffer
;
2110 /* If the old current buffer has markers to record PT, BEGV and ZV
2111 when it is not current, update them now. */
2112 record_buffer_markers (old_buf
);
2114 /* If the new current buffer has markers to record PT, BEGV and ZV
2115 when it is not current, fetch them now. */
2116 fetch_buffer_markers (b
);
2119 DEFUN ("set-buffer", Fset_buffer
, Sset_buffer
, 1, 1, 0,
2120 doc
: /* Make buffer BUFFER-OR-NAME current for editing operations.
2121 BUFFER-OR-NAME may be a buffer or the name of an existing buffer.
2122 See also `with-current-buffer' when you want to make a buffer current
2123 temporarily. This function does not display the buffer, so its effect
2124 ends when the current command terminates. Use `switch-to-buffer' or
2125 `pop-to-buffer' to switch buffers permanently.
2126 The return value is the buffer made current. */)
2127 (register Lisp_Object buffer_or_name
)
2129 register Lisp_Object buffer
;
2130 buffer
= Fget_buffer (buffer_or_name
);
2132 nsberror (buffer_or_name
);
2133 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
2134 error ("Selecting deleted buffer");
2135 set_buffer_internal (XBUFFER (buffer
));
2140 restore_buffer (Lisp_Object buffer_or_name
)
2142 Fset_buffer (buffer_or_name
);
2145 /* Set the current buffer to BUFFER provided if it is alive. */
2148 set_buffer_if_live (Lisp_Object buffer
)
2150 if (BUFFER_LIVE_P (XBUFFER (buffer
)))
2151 set_buffer_internal (XBUFFER (buffer
));
2154 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only
,
2155 Sbarf_if_buffer_read_only
, 0, 1, 0,
2156 doc
: /* Signal a `buffer-read-only' error if the current buffer is read-only.
2157 If the text under POSITION (which defaults to point) has the
2158 `inhibit-read-only' text property set, the error will not be raised. */)
2162 XSETFASTINT (pos
, PT
);
2166 if (!NILP (BVAR (current_buffer
, read_only
))
2167 && NILP (Vinhibit_read_only
)
2168 && NILP (Fget_text_property (pos
, Qinhibit_read_only
, Qnil
)))
2169 xsignal1 (Qbuffer_read_only
, Fcurrent_buffer ());
2173 DEFUN ("erase-buffer", Ferase_buffer
, Serase_buffer
, 0, 0, "*",
2174 doc
: /* Delete the entire contents of the current buffer.
2175 Any narrowing restriction in effect (see `narrow-to-region') is removed,
2176 so the buffer is truly empty after this. */)
2183 current_buffer
->last_window_start
= 1;
2184 /* Prevent warnings, or suspension of auto saving, that would happen
2185 if future size is less than past size. Use of erase-buffer
2186 implies that the future text is not really related to the past text. */
2187 XSETFASTINT (BVAR (current_buffer
, save_length
), 0);
2192 validate_region (register Lisp_Object
*b
, register Lisp_Object
*e
)
2194 CHECK_NUMBER_COERCE_MARKER (*b
);
2195 CHECK_NUMBER_COERCE_MARKER (*e
);
2197 if (XINT (*b
) > XINT (*e
))
2200 tem
= *b
; *b
= *e
; *e
= tem
;
2203 if (! (BEGV
<= XINT (*b
) && XINT (*e
) <= ZV
))
2204 args_out_of_range_3 (Fcurrent_buffer (), *b
, *e
);
2207 /* Advance BYTE_POS up to a character boundary
2208 and return the adjusted position. */
2211 advance_to_char_boundary (ptrdiff_t byte_pos
)
2215 if (byte_pos
== BEG
)
2216 /* Beginning of buffer is always a character boundary. */
2219 c
= FETCH_BYTE (byte_pos
);
2220 if (! CHAR_HEAD_P (c
))
2222 /* We should advance BYTE_POS only when C is a constituent of a
2223 multibyte sequence. */
2224 ptrdiff_t orig_byte_pos
= byte_pos
;
2229 c
= FETCH_BYTE (byte_pos
);
2231 while (! CHAR_HEAD_P (c
) && byte_pos
> BEG
);
2233 if (byte_pos
< orig_byte_pos
)
2234 byte_pos
= orig_byte_pos
;
2235 /* If C is a constituent of a multibyte sequence, BYTE_POS was
2236 surely advance to the correct character boundary. If C is
2237 not, BYTE_POS was unchanged. */
2243 DEFUN ("buffer-swap-text", Fbuffer_swap_text
, Sbuffer_swap_text
,
2245 doc
: /* Swap the text between current buffer and BUFFER. */)
2246 (Lisp_Object buffer
)
2248 struct buffer
*other_buffer
;
2249 CHECK_BUFFER (buffer
);
2250 other_buffer
= XBUFFER (buffer
);
2252 if (!BUFFER_LIVE_P (other_buffer
))
2253 error ("Cannot swap a dead buffer's text");
2255 /* Actually, it probably works just fine.
2256 * if (other_buffer == current_buffer)
2257 * error ("Cannot swap a buffer's text with itself"); */
2259 /* Actually, this may be workable as well, tho probably only if they're
2261 if (other_buffer
->base_buffer
2262 || current_buffer
->base_buffer
)
2263 error ("Cannot swap indirect buffers's text");
2265 { /* This is probably harder to make work. */
2266 struct buffer
*other
;
2267 FOR_EACH_BUFFER (other
)
2268 if (other
->base_buffer
== other_buffer
2269 || other
->base_buffer
== current_buffer
)
2270 error ("One of the buffers to swap has indirect buffers");
2273 #define swapfield(field, type) \
2275 type tmp##field = other_buffer->field; \
2276 other_buffer->field = current_buffer->field; \
2277 current_buffer->field = tmp##field; \
2279 #define swapfield_(field, type) \
2281 type tmp##field = BVAR (other_buffer, field); \
2282 bset_##field (other_buffer, BVAR (current_buffer, field)); \
2283 bset_##field (current_buffer, tmp##field); \
2286 swapfield (own_text
, struct buffer_text
);
2287 eassert (current_buffer
->text
== ¤t_buffer
->own_text
);
2288 eassert (other_buffer
->text
== &other_buffer
->own_text
);
2290 r_alloc_reset_variable ((void **) ¤t_buffer
->own_text
.beg
,
2291 (void **) &other_buffer
->own_text
.beg
);
2292 r_alloc_reset_variable ((void **) &other_buffer
->own_text
.beg
,
2293 (void **) ¤t_buffer
->own_text
.beg
);
2294 #endif /* REL_ALLOC */
2296 swapfield (pt
, ptrdiff_t);
2297 swapfield (pt_byte
, ptrdiff_t);
2298 swapfield (begv
, ptrdiff_t);
2299 swapfield (begv_byte
, ptrdiff_t);
2300 swapfield (zv
, ptrdiff_t);
2301 swapfield (zv_byte
, ptrdiff_t);
2302 eassert (!current_buffer
->base_buffer
);
2303 eassert (!other_buffer
->base_buffer
);
2304 swapfield (indirections
, ptrdiff_t);
2305 current_buffer
->clip_changed
= 1; other_buffer
->clip_changed
= 1;
2306 swapfield (newline_cache
, struct region_cache
*);
2307 swapfield (width_run_cache
, struct region_cache
*);
2308 swapfield (bidi_paragraph_cache
, struct region_cache
*);
2309 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2310 other_buffer
->prevent_redisplay_optimizations_p
= 1;
2311 swapfield (overlays_before
, struct Lisp_Overlay
*);
2312 swapfield (overlays_after
, struct Lisp_Overlay
*);
2313 swapfield (overlay_center
, ptrdiff_t);
2314 swapfield_ (undo_list
, Lisp_Object
);
2315 swapfield_ (mark
, Lisp_Object
);
2316 swapfield_ (enable_multibyte_characters
, Lisp_Object
);
2317 swapfield_ (bidi_display_reordering
, Lisp_Object
);
2318 swapfield_ (bidi_paragraph_direction
, Lisp_Object
);
2319 /* FIXME: Not sure what we should do with these *_marker fields.
2320 Hopefully they're just nil anyway. */
2321 swapfield_ (pt_marker
, Lisp_Object
);
2322 swapfield_ (begv_marker
, Lisp_Object
);
2323 swapfield_ (zv_marker
, Lisp_Object
);
2324 bset_point_before_scroll (current_buffer
, Qnil
);
2325 bset_point_before_scroll (other_buffer
, Qnil
);
2327 current_buffer
->text
->modiff
++; other_buffer
->text
->modiff
++;
2328 current_buffer
->text
->chars_modiff
++; other_buffer
->text
->chars_modiff
++;
2329 current_buffer
->text
->overlay_modiff
++; other_buffer
->text
->overlay_modiff
++;
2330 current_buffer
->text
->beg_unchanged
= current_buffer
->text
->gpt
;
2331 current_buffer
->text
->end_unchanged
= current_buffer
->text
->gpt
;
2332 other_buffer
->text
->beg_unchanged
= other_buffer
->text
->gpt
;
2333 other_buffer
->text
->end_unchanged
= other_buffer
->text
->gpt
;
2335 struct Lisp_Marker
*m
;
2336 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
2337 if (m
->buffer
== other_buffer
)
2338 m
->buffer
= current_buffer
;
2340 /* Since there's no indirect buffer in sight, markers on
2341 BUF_MARKERS(buf) should either be for `buf' or dead. */
2342 eassert (!m
->buffer
);
2343 for (m
= BUF_MARKERS (other_buffer
); m
; m
= m
->next
)
2344 if (m
->buffer
== current_buffer
)
2345 m
->buffer
= other_buffer
;
2347 /* Since there's no indirect buffer in sight, markers on
2348 BUF_MARKERS(buf) should either be for `buf' or dead. */
2349 eassert (!m
->buffer
);
2351 { /* Some of the C code expects that both window markers of a
2352 live window points to that window's buffer. So since we
2353 just swapped the markers between the two buffers, we need
2354 to undo the effect of this swap for window markers. */
2355 Lisp_Object w
= selected_window
, ws
= Qnil
;
2356 Lisp_Object buf1
, buf2
;
2357 XSETBUFFER (buf1
, current_buffer
); XSETBUFFER (buf2
, other_buffer
);
2359 while (NILP (Fmemq (w
, ws
)))
2362 if (MARKERP (XWINDOW (w
)->pointm
)
2363 && (EQ (XWINDOW (w
)->contents
, buf1
)
2364 || EQ (XWINDOW (w
)->contents
, buf2
)))
2365 Fset_marker (XWINDOW (w
)->pointm
,
2367 (BUF_BEGV (XBUFFER (XWINDOW (w
)->contents
))),
2368 XWINDOW (w
)->contents
);
2369 /* Blindly copied from pointm part. */
2370 if (MARKERP (XWINDOW (w
)->old_pointm
)
2371 && (EQ (XWINDOW (w
)->contents
, buf1
)
2372 || EQ (XWINDOW (w
)->contents
, buf2
)))
2373 Fset_marker (XWINDOW (w
)->old_pointm
,
2375 (BUF_BEGV (XBUFFER (XWINDOW (w
)->contents
))),
2376 XWINDOW (w
)->contents
);
2377 if (MARKERP (XWINDOW (w
)->start
)
2378 && (EQ (XWINDOW (w
)->contents
, buf1
)
2379 || EQ (XWINDOW (w
)->contents
, buf2
)))
2380 Fset_marker (XWINDOW (w
)->start
,
2382 (XBUFFER (XWINDOW (w
)->contents
)->last_window_start
),
2383 XWINDOW (w
)->contents
);
2384 w
= Fnext_window (w
, Qt
, Qt
);
2388 if (current_buffer
->text
->intervals
)
2389 (eassert (EQ (current_buffer
->text
->intervals
->up
.obj
, buffer
)),
2390 XSETBUFFER (current_buffer
->text
->intervals
->up
.obj
, current_buffer
));
2391 if (other_buffer
->text
->intervals
)
2392 (eassert (EQ (other_buffer
->text
->intervals
->up
.obj
, Fcurrent_buffer ())),
2393 XSETBUFFER (other_buffer
->text
->intervals
->up
.obj
, other_buffer
));
2398 DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte
, Sset_buffer_multibyte
,
2400 doc
: /* Set the multibyte flag of the current buffer to FLAG.
2401 If FLAG is t, this makes the buffer a multibyte buffer.
2402 If FLAG is nil, this makes the buffer a single-byte buffer.
2403 In these cases, the buffer contents remain unchanged as a sequence of
2404 bytes but the contents viewed as characters do change.
2405 If FLAG is `to', this makes the buffer a multibyte buffer by changing
2406 all eight-bit bytes to eight-bit characters.
2407 If the multibyte flag was really changed, undo information of the
2408 current buffer is cleared. */)
2411 struct Lisp_Marker
*tail
, *markers
;
2412 struct buffer
*other
;
2414 bool narrowed
= (BEG
!= BEGV
|| Z
!= ZV
);
2415 bool modified_p
= !NILP (Fbuffer_modified_p (Qnil
));
2416 Lisp_Object old_undo
= BVAR (current_buffer
, undo_list
);
2417 struct gcpro gcpro1
;
2419 if (current_buffer
->base_buffer
)
2420 error ("Cannot do `set-buffer-multibyte' on an indirect buffer");
2422 /* Do nothing if nothing actually changes. */
2423 if (NILP (flag
) == NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
2428 /* Don't record these buffer changes. We will put a special undo entry
2430 bset_undo_list (current_buffer
, Qt
);
2432 /* If the cached position is for this buffer, clear it out. */
2433 clear_charpos_cache (current_buffer
);
2436 begv
= BEGV_BYTE
, zv
= ZV_BYTE
;
2438 begv
= BEGV
, zv
= ZV
;
2441 error ("Changing multibyteness in a narrowed buffer");
2443 invalidate_buffer_caches (current_buffer
, BEGV
, ZV
);
2447 ptrdiff_t pos
, stop
;
2450 /* Do this first, so it can use CHAR_TO_BYTE
2451 to calculate the old correspondences. */
2452 set_intervals_multibyte (0);
2454 bset_enable_multibyte_characters (current_buffer
, Qnil
);
2460 TEMP_SET_PT_BOTH (PT_BYTE
, PT_BYTE
);
2463 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
2464 tail
->charpos
= tail
->bytepos
;
2466 /* Convert multibyte form of 8-bit characters to unibyte. */
2481 if (ASCII_CHAR_P (*p
))
2483 else if (CHAR_BYTE8_HEAD_P (*p
))
2485 c
= STRING_CHAR_AND_LENGTH (p
, bytes
);
2486 /* Delete all bytes for this 8-bit character but the
2487 last one, and change the last one to the character
2490 del_range_2 (pos
, pos
, pos
+ bytes
, pos
+ bytes
, 0);
2502 bytes
= BYTES_BY_CHAR_HEAD (*p
);
2503 p
+= bytes
, pos
+= bytes
;
2507 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2512 ptrdiff_t pos
, stop
;
2513 unsigned char *p
, *pend
;
2515 /* Be sure not to have a multibyte sequence striding over the GAP.
2516 Ex: We change this: "...abc\302 _GAP_ \241def..."
2517 to: "...abc _GAP_ \302\241def..." */
2520 && GPT_BYTE
> 1 && GPT_BYTE
< Z_BYTE
2521 && ! CHAR_HEAD_P (*(GAP_END_ADDR
)))
2523 unsigned char *q
= GPT_ADDR
- 1;
2525 while (! CHAR_HEAD_P (*q
) && q
> BEG_ADDR
) q
--;
2526 if (LEADING_CODE_P (*q
))
2528 ptrdiff_t new_gpt
= GPT_BYTE
- (GPT_ADDR
- q
);
2530 move_gap_both (new_gpt
, new_gpt
);
2534 /* Make the buffer contents valid as multibyte by converting
2535 8-bit characters to multibyte form. */
2553 if (ASCII_CHAR_P (*p
))
2555 else if (EQ (flag
, Qt
)
2556 && ! CHAR_BYTE8_HEAD_P (*p
)
2557 && (bytes
= MULTIBYTE_LENGTH (p
, pend
)) > 0)
2558 p
+= bytes
, pos
+= bytes
;
2561 unsigned char tmp
[MAX_MULTIBYTE_LENGTH
];
2564 c
= BYTE8_TO_CHAR (*p
);
2565 bytes
= CHAR_STRING (c
, tmp
);
2567 TEMP_SET_PT_BOTH (pos
+ 1, pos
+ 1);
2569 insert_1_both ((char *) tmp
+ 1, bytes
, bytes
, 1, 0, 0);
2570 /* Now the gap is after the just inserted data. */
2588 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2590 /* Do this first, so that chars_in_text asks the right question.
2591 set_intervals_multibyte needs it too. */
2592 bset_enable_multibyte_characters (current_buffer
, Qt
);
2594 GPT_BYTE
= advance_to_char_boundary (GPT_BYTE
);
2595 GPT
= chars_in_text (BEG_ADDR
, GPT_BYTE
- BEG_BYTE
) + BEG
;
2597 Z
= chars_in_text (GAP_END_ADDR
, Z_BYTE
- GPT_BYTE
) + GPT
;
2599 BEGV_BYTE
= advance_to_char_boundary (BEGV_BYTE
);
2600 if (BEGV_BYTE
> GPT_BYTE
)
2601 BEGV
= chars_in_text (GAP_END_ADDR
, BEGV_BYTE
- GPT_BYTE
) + GPT
;
2603 BEGV
= chars_in_text (BEG_ADDR
, BEGV_BYTE
- BEG_BYTE
) + BEG
;
2605 ZV_BYTE
= advance_to_char_boundary (ZV_BYTE
);
2606 if (ZV_BYTE
> GPT_BYTE
)
2607 ZV
= chars_in_text (GAP_END_ADDR
, ZV_BYTE
- GPT_BYTE
) + GPT
;
2609 ZV
= chars_in_text (BEG_ADDR
, ZV_BYTE
- BEG_BYTE
) + BEG
;
2612 ptrdiff_t byte
= advance_to_char_boundary (PT_BYTE
);
2615 if (byte
> GPT_BYTE
)
2616 position
= chars_in_text (GAP_END_ADDR
, byte
- GPT_BYTE
) + GPT
;
2618 position
= chars_in_text (BEG_ADDR
, byte
- BEG_BYTE
) + BEG
;
2619 TEMP_SET_PT_BOTH (position
, byte
);
2622 tail
= markers
= BUF_MARKERS (current_buffer
);
2624 /* This prevents BYTE_TO_CHAR (that is, buf_bytepos_to_charpos) from
2625 getting confused by the markers that have not yet been updated.
2626 It is also a signal that it should never create a marker. */
2627 BUF_MARKERS (current_buffer
) = NULL
;
2629 for (; tail
; tail
= tail
->next
)
2631 tail
->bytepos
= advance_to_char_boundary (tail
->bytepos
);
2632 tail
->charpos
= BYTE_TO_CHAR (tail
->bytepos
);
2635 /* Make sure no markers were put on the chain
2636 while the chain value was incorrect. */
2637 if (BUF_MARKERS (current_buffer
))
2640 BUF_MARKERS (current_buffer
) = markers
;
2642 /* Do this last, so it can calculate the new correspondences
2643 between chars and bytes. */
2644 set_intervals_multibyte (1);
2647 if (!EQ (old_undo
, Qt
))
2649 /* Represent all the above changes by a special undo entry. */
2650 bset_undo_list (current_buffer
,
2651 Fcons (list3 (Qapply
,
2652 intern ("set-buffer-multibyte"),
2653 NILP (flag
) ? Qt
: Qnil
),
2659 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2661 /* If buffer is shown in a window, let redisplay consider other windows. */
2662 if (buffer_window_count (current_buffer
))
2663 windows_or_buffers_changed
= 10;
2665 /* Copy this buffer's new multibyte status
2666 into all of its indirect buffers. */
2667 FOR_EACH_BUFFER (other
)
2668 if (other
->base_buffer
== current_buffer
&& BUFFER_LIVE_P (other
))
2670 BVAR (other
, enable_multibyte_characters
)
2671 = BVAR (current_buffer
, enable_multibyte_characters
);
2672 other
->prevent_redisplay_optimizations_p
= 1;
2675 /* Restore the modifiedness of the buffer. */
2676 if (!modified_p
&& !NILP (Fbuffer_modified_p (Qnil
)))
2677 Fset_buffer_modified_p (Qnil
);
2679 /* Update coding systems of this buffer's process (if any). */
2681 Lisp_Object process
;
2683 process
= Fget_buffer_process (Fcurrent_buffer ());
2684 if (PROCESSP (process
))
2685 setup_process_coding_systems (process
);
2691 DEFUN ("kill-all-local-variables", Fkill_all_local_variables
,
2692 Skill_all_local_variables
, 0, 0, 0,
2693 doc
: /* Switch to Fundamental mode by killing current buffer's local variables.
2694 Most local variable bindings are eliminated so that the default values
2695 become effective once more. Also, the syntax table is set from
2696 `standard-syntax-table', the local keymap is set to nil,
2697 and the abbrev table from `fundamental-mode-abbrev-table'.
2698 This function also forces redisplay of the mode line.
2700 Every function to select a new major mode starts by
2701 calling this function.
2703 As a special exception, local variables whose names have
2704 a non-nil `permanent-local' property are not eliminated by this function.
2706 The first thing this function does is run
2707 the normal hook `change-major-mode-hook'. */)
2710 run_hook (Qchange_major_mode_hook
);
2712 /* Make sure none of the bindings in local_var_alist
2713 remain swapped in, in their symbols. */
2715 swap_out_buffer_local_variables (current_buffer
);
2717 /* Actually eliminate all local bindings of this buffer. */
2719 reset_buffer_local_variables (current_buffer
, 0);
2721 /* Force mode-line redisplay. Useful here because all major mode
2722 commands call this function. */
2723 update_mode_lines
= 12;
2728 /* Make sure no local variables remain set up with buffer B
2729 for their current values. */
2732 swap_out_buffer_local_variables (struct buffer
*b
)
2734 Lisp_Object oalist
, alist
, buffer
;
2736 XSETBUFFER (buffer
, b
);
2737 oalist
= BVAR (b
, local_var_alist
);
2739 for (alist
= oalist
; CONSP (alist
); alist
= XCDR (alist
))
2741 Lisp_Object sym
= XCAR (XCAR (alist
));
2742 eassert (XSYMBOL (sym
)->redirect
== SYMBOL_LOCALIZED
);
2743 /* Need not do anything if some other buffer's binding is
2745 if (EQ (SYMBOL_BLV (XSYMBOL (sym
))->where
, buffer
))
2747 /* Symbol is set up for this buffer's old local value:
2749 swap_in_global_binding (XSYMBOL (sym
));
2754 /* Find all the overlays in the current buffer that contain position POS.
2755 Return the number found, and store them in a vector in *VEC_PTR.
2756 Store in *LEN_PTR the size allocated for the vector.
2757 Store in *NEXT_PTR the next position after POS where an overlay starts,
2758 or ZV if there are no more overlays between POS and ZV.
2759 Store in *PREV_PTR the previous position before POS where an overlay ends,
2760 or where an overlay starts which ends at or after POS;
2761 or BEGV if there are no such overlays from BEGV to POS.
2762 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2764 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2765 when this function is called.
2767 If EXTEND, make the vector bigger if necessary.
2768 If not, never extend the vector,
2769 and store only as many overlays as will fit.
2770 But still return the total number of overlays.
2772 If CHANGE_REQ, any position written into *PREV_PTR or
2773 *NEXT_PTR is guaranteed to be not equal to POS, unless it is the
2774 default (BEGV or ZV). */
2777 overlays_at (EMACS_INT pos
, bool extend
, Lisp_Object
**vec_ptr
,
2779 ptrdiff_t *next_ptr
, ptrdiff_t *prev_ptr
, bool change_req
)
2781 Lisp_Object overlay
, start
, end
;
2782 struct Lisp_Overlay
*tail
;
2784 ptrdiff_t len
= *len_ptr
;
2785 Lisp_Object
*vec
= *vec_ptr
;
2786 ptrdiff_t next
= ZV
;
2787 ptrdiff_t prev
= BEGV
;
2788 bool inhibit_storing
= 0;
2790 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2792 ptrdiff_t startpos
, endpos
;
2794 XSETMISC (overlay
, tail
);
2796 start
= OVERLAY_START (overlay
);
2797 end
= OVERLAY_END (overlay
);
2798 endpos
= OVERLAY_POSITION (end
);
2805 startpos
= OVERLAY_POSITION (start
);
2806 /* This one ends at or after POS
2807 so its start counts for PREV_PTR if it's before POS. */
2808 if (prev
< startpos
&& startpos
< pos
)
2812 if (startpos
<= pos
)
2816 /* The supplied vector is full.
2817 Either make it bigger, or don't store any more in it. */
2820 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2826 inhibit_storing
= 1;
2829 if (!inhibit_storing
)
2831 /* Keep counting overlays even if we can't return them all. */
2834 else if (startpos
< next
)
2838 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2840 ptrdiff_t startpos
, endpos
;
2842 XSETMISC (overlay
, tail
);
2844 start
= OVERLAY_START (overlay
);
2845 end
= OVERLAY_END (overlay
);
2846 startpos
= OVERLAY_POSITION (start
);
2849 if (startpos
< next
)
2853 endpos
= OVERLAY_POSITION (end
);
2860 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2866 inhibit_storing
= 1;
2869 if (!inhibit_storing
)
2873 if (startpos
< pos
&& startpos
> prev
)
2876 else if (endpos
< pos
&& endpos
> prev
)
2878 else if (endpos
== pos
&& startpos
> prev
2879 && (!change_req
|| startpos
< pos
))
2890 /* Find all the overlays in the current buffer that overlap the range
2891 BEG-END, or are empty at BEG, or are empty at END provided END
2892 denotes the position at the end of the current buffer.
2894 Return the number found, and store them in a vector in *VEC_PTR.
2895 Store in *LEN_PTR the size allocated for the vector.
2896 Store in *NEXT_PTR the next position after POS where an overlay starts,
2897 or ZV if there are no more overlays.
2898 Store in *PREV_PTR the previous position before POS where an overlay ends,
2899 or BEGV if there are no previous overlays.
2900 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2902 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2903 when this function is called.
2905 If EXTEND, make the vector bigger if necessary.
2906 If not, never extend the vector,
2907 and store only as many overlays as will fit.
2908 But still return the total number of overlays. */
2911 overlays_in (EMACS_INT beg
, EMACS_INT end
, bool extend
,
2912 Lisp_Object
**vec_ptr
, ptrdiff_t *len_ptr
,
2913 ptrdiff_t *next_ptr
, ptrdiff_t *prev_ptr
)
2915 Lisp_Object overlay
, ostart
, oend
;
2916 struct Lisp_Overlay
*tail
;
2918 ptrdiff_t len
= *len_ptr
;
2919 Lisp_Object
*vec
= *vec_ptr
;
2920 ptrdiff_t next
= ZV
;
2921 ptrdiff_t prev
= BEGV
;
2922 bool inhibit_storing
= 0;
2923 bool end_is_Z
= end
== Z
;
2925 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2927 ptrdiff_t startpos
, endpos
;
2929 XSETMISC (overlay
, tail
);
2931 ostart
= OVERLAY_START (overlay
);
2932 oend
= OVERLAY_END (overlay
);
2933 endpos
= OVERLAY_POSITION (oend
);
2940 startpos
= OVERLAY_POSITION (ostart
);
2941 /* Count an interval if it overlaps the range, is empty at the
2942 start of the range, or is empty at END provided END denotes the
2943 end of the buffer. */
2944 if ((beg
< endpos
&& startpos
< end
)
2945 || (startpos
== endpos
2946 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
2950 /* The supplied vector is full.
2951 Either make it bigger, or don't store any more in it. */
2954 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2960 inhibit_storing
= 1;
2963 if (!inhibit_storing
)
2965 /* Keep counting overlays even if we can't return them all. */
2968 else if (startpos
< next
)
2972 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2974 ptrdiff_t startpos
, endpos
;
2976 XSETMISC (overlay
, tail
);
2978 ostart
= OVERLAY_START (overlay
);
2979 oend
= OVERLAY_END (overlay
);
2980 startpos
= OVERLAY_POSITION (ostart
);
2983 if (startpos
< next
)
2987 endpos
= OVERLAY_POSITION (oend
);
2988 /* Count an interval if it overlaps the range, is empty at the
2989 start of the range, or is empty at END provided END denotes the
2990 end of the buffer. */
2991 if ((beg
< endpos
&& startpos
< end
)
2992 || (startpos
== endpos
2993 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
2999 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
3005 inhibit_storing
= 1;
3008 if (!inhibit_storing
)
3012 else if (endpos
< beg
&& endpos
> prev
)
3024 /* Return true if there exists an overlay with a non-nil
3025 `mouse-face' property overlapping OVERLAY. */
3028 mouse_face_overlay_overlaps (Lisp_Object overlay
)
3030 ptrdiff_t start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3031 ptrdiff_t end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3032 ptrdiff_t n
, i
, size
;
3033 Lisp_Object
*v
, tem
;
3034 Lisp_Object vbuf
[10];
3037 size
= ARRAYELTS (vbuf
);
3039 n
= overlays_in (start
, end
, 0, &v
, &size
, NULL
, NULL
);
3042 SAFE_NALLOCA (v
, 1, n
);
3043 overlays_in (start
, end
, 0, &v
, &n
, NULL
, NULL
);
3046 for (i
= 0; i
< n
; ++i
)
3047 if (!EQ (v
[i
], overlay
)
3048 && (tem
= Foverlay_get (overlay
, Qmouse_face
),
3058 /* Fast function to just test if we're at an overlay boundary. */
3060 overlay_touches_p (ptrdiff_t pos
)
3062 Lisp_Object overlay
;
3063 struct Lisp_Overlay
*tail
;
3065 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
3069 XSETMISC (overlay
,tail
);
3070 eassert (OVERLAYP (overlay
));
3072 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3075 if (endpos
== pos
|| OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
)
3079 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
3083 XSETMISC (overlay
, tail
);
3084 eassert (OVERLAYP (overlay
));
3086 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3089 if (startpos
== pos
|| OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
)
3097 Lisp_Object overlay
;
3100 EMACS_INT spriority
; /* Secondary priority. */
3104 compare_overlays (const void *v1
, const void *v2
)
3106 const struct sortvec
*s1
= v1
;
3107 const struct sortvec
*s2
= v2
;
3108 /* Return 1 if s1 should take precedence, -1 if v2 should take precedence,
3109 and 0 if they're equal. */
3110 if (s1
->priority
!= s2
->priority
)
3111 return s1
->priority
< s2
->priority
? -1 : 1;
3112 /* If the priority is equal, give precedence to the one not covered by the
3113 other. If neither covers the other, obey spriority. */
3114 else if (s1
->beg
< s2
->beg
)
3115 return (s1
->end
< s2
->end
&& s1
->spriority
> s2
->spriority
? 1 : -1);
3116 else if (s1
->beg
> s2
->beg
)
3117 return (s1
->end
> s2
->end
&& s1
->spriority
< s2
->spriority
? -1 : 1);
3118 else if (s1
->end
!= s2
->end
)
3119 return s2
->end
< s1
->end
? -1 : 1;
3120 else if (s1
->spriority
!= s2
->spriority
)
3121 return (s1
->spriority
< s2
->spriority
? -1 : 1);
3122 else if (EQ (s1
->overlay
, s2
->overlay
))
3125 /* Avoid the non-determinism of qsort by choosing an arbitrary ordering
3126 between "equal" overlays. The result can still change between
3127 invocations of Emacs, but it won't change in the middle of
3128 `find_field' (bug#6830). */
3129 return XLI (s1
->overlay
) < XLI (s2
->overlay
) ? -1 : 1;
3132 /* Sort an array of overlays by priority. The array is modified in place.
3133 The return value is the new size; this may be smaller than the original
3134 size if some of the overlays were invalid or were window-specific. */
3136 sort_overlays (Lisp_Object
*overlay_vec
, ptrdiff_t noverlays
, struct window
*w
)
3140 struct sortvec
*sortvec
;
3142 SAFE_NALLOCA (sortvec
, 1, noverlays
);
3144 /* Put the valid and relevant overlays into sortvec. */
3146 for (i
= 0, j
= 0; i
< noverlays
; i
++)
3149 Lisp_Object overlay
;
3151 overlay
= overlay_vec
[i
];
3152 if (OVERLAYP (overlay
)
3153 && OVERLAY_POSITION (OVERLAY_START (overlay
)) > 0
3154 && OVERLAY_POSITION (OVERLAY_END (overlay
)) > 0)
3156 /* If we're interested in a specific window, then ignore
3157 overlays that are limited to some other window. */
3162 window
= Foverlay_get (overlay
, Qwindow
);
3163 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3167 /* This overlay is good and counts: put it into sortvec. */
3168 sortvec
[j
].overlay
= overlay
;
3169 sortvec
[j
].beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3170 sortvec
[j
].end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3171 tem
= Foverlay_get (overlay
, Qpriority
);
3174 sortvec
[j
].priority
= 0;
3175 sortvec
[j
].spriority
= 0;
3177 else if (INTEGERP (tem
))
3179 sortvec
[j
].priority
= XINT (tem
);
3180 sortvec
[j
].spriority
= 0;
3182 else if (CONSP (tem
))
3184 Lisp_Object car
= XCAR (tem
);
3185 Lisp_Object cdr
= XCDR (tem
);
3186 sortvec
[j
].priority
= INTEGERP (car
) ? XINT (car
) : 0;
3187 sortvec
[j
].spriority
= INTEGERP (cdr
) ? XINT (cdr
) : 0;
3194 /* Sort the overlays into the proper order: increasing priority. */
3197 qsort (sortvec
, noverlays
, sizeof (struct sortvec
), compare_overlays
);
3199 for (i
= 0; i
< noverlays
; i
++)
3200 overlay_vec
[i
] = sortvec
[i
].overlay
;
3208 Lisp_Object string
, string2
;
3215 struct sortstr
*buf
; /* An array that expands as needed; never freed. */
3216 ptrdiff_t size
; /* Allocated length of that array. */
3217 ptrdiff_t used
; /* How much of the array is currently in use. */
3218 ptrdiff_t bytes
; /* Total length of the strings in buf. */
3221 /* Buffers for storing information about the overlays touching a given
3222 position. These could be automatic variables in overlay_strings, but
3223 it's more efficient to hold onto the memory instead of repeatedly
3224 allocating and freeing it. */
3225 static struct sortstrlist overlay_heads
, overlay_tails
;
3226 static unsigned char *overlay_str_buf
;
3228 /* Allocated length of overlay_str_buf. */
3229 static ptrdiff_t overlay_str_len
;
3231 /* A comparison function suitable for passing to qsort. */
3233 cmp_for_strings (const void *as1
, const void *as2
)
3235 struct sortstr
const *s1
= as1
;
3236 struct sortstr
const *s2
= as2
;
3237 if (s1
->size
!= s2
->size
)
3238 return s2
->size
< s1
->size
? -1 : 1;
3239 if (s1
->priority
!= s2
->priority
)
3240 return s1
->priority
< s2
->priority
? -1 : 1;
3245 record_overlay_string (struct sortstrlist
*ssl
, Lisp_Object str
,
3246 Lisp_Object str2
, Lisp_Object pri
, ptrdiff_t size
)
3250 if (ssl
->used
== ssl
->size
)
3251 ssl
->buf
= xpalloc (ssl
->buf
, &ssl
->size
, 5, -1, sizeof *ssl
->buf
);
3252 ssl
->buf
[ssl
->used
].string
= str
;
3253 ssl
->buf
[ssl
->used
].string2
= str2
;
3254 ssl
->buf
[ssl
->used
].size
= size
;
3255 ssl
->buf
[ssl
->used
].priority
= (INTEGERP (pri
) ? XINT (pri
) : 0);
3258 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3259 nbytes
= SCHARS (str
);
3260 else if (! STRING_MULTIBYTE (str
))
3261 nbytes
= count_size_as_multibyte (SDATA (str
),
3264 nbytes
= SBYTES (str
);
3266 if (INT_ADD_OVERFLOW (ssl
->bytes
, nbytes
))
3267 memory_full (SIZE_MAX
);
3268 ssl
->bytes
+= nbytes
;
3272 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3273 nbytes
= SCHARS (str2
);
3274 else if (! STRING_MULTIBYTE (str2
))
3275 nbytes
= count_size_as_multibyte (SDATA (str2
),
3278 nbytes
= SBYTES (str2
);
3280 if (INT_ADD_OVERFLOW (ssl
->bytes
, nbytes
))
3281 memory_full (SIZE_MAX
);
3282 ssl
->bytes
+= nbytes
;
3286 /* Concatenate the strings associated with overlays that begin or end
3287 at POS, ignoring overlays that are specific to windows other than W.
3288 The strings are concatenated in the appropriate order: shorter
3289 overlays nest inside longer ones, and higher priority inside lower.
3290 Normally all of the after-strings come first, but zero-sized
3291 overlays have their after-strings ride along with the
3292 before-strings because it would look strange to print them
3295 Returns the concatenated string's length, and return the pointer to
3296 that string via PSTR, if that variable is non-NULL. The storage of
3297 the concatenated strings may be overwritten by subsequent calls. */
3300 overlay_strings (ptrdiff_t pos
, struct window
*w
, unsigned char **pstr
)
3302 Lisp_Object overlay
, window
, str
;
3303 struct Lisp_Overlay
*ov
;
3304 ptrdiff_t startpos
, endpos
;
3305 bool multibyte
= ! NILP (BVAR (current_buffer
, enable_multibyte_characters
));
3307 overlay_heads
.used
= overlay_heads
.bytes
= 0;
3308 overlay_tails
.used
= overlay_tails
.bytes
= 0;
3309 for (ov
= current_buffer
->overlays_before
; ov
; ov
= ov
->next
)
3311 XSETMISC (overlay
, ov
);
3312 eassert (OVERLAYP (overlay
));
3314 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3315 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3318 if (endpos
!= pos
&& startpos
!= pos
)
3320 window
= Foverlay_get (overlay
, Qwindow
);
3321 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3324 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3325 record_overlay_string (&overlay_heads
, str
,
3327 ? Foverlay_get (overlay
, Qafter_string
)
3329 Foverlay_get (overlay
, Qpriority
),
3331 else if (endpos
== pos
3332 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3333 record_overlay_string (&overlay_tails
, str
, Qnil
,
3334 Foverlay_get (overlay
, Qpriority
),
3337 for (ov
= current_buffer
->overlays_after
; ov
; ov
= ov
->next
)
3339 XSETMISC (overlay
, ov
);
3340 eassert (OVERLAYP (overlay
));
3342 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3343 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3346 if (endpos
!= pos
&& startpos
!= pos
)
3348 window
= Foverlay_get (overlay
, Qwindow
);
3349 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3352 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3353 record_overlay_string (&overlay_heads
, str
,
3355 ? Foverlay_get (overlay
, Qafter_string
)
3357 Foverlay_get (overlay
, Qpriority
),
3359 else if (endpos
== pos
3360 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3361 record_overlay_string (&overlay_tails
, str
, Qnil
,
3362 Foverlay_get (overlay
, Qpriority
),
3365 if (overlay_tails
.used
> 1)
3366 qsort (overlay_tails
.buf
, overlay_tails
.used
, sizeof (struct sortstr
),
3368 if (overlay_heads
.used
> 1)
3369 qsort (overlay_heads
.buf
, overlay_heads
.used
, sizeof (struct sortstr
),
3371 if (overlay_heads
.bytes
|| overlay_tails
.bytes
)
3378 if (INT_ADD_OVERFLOW (overlay_heads
.bytes
, overlay_tails
.bytes
))
3379 memory_full (SIZE_MAX
);
3380 total
= overlay_heads
.bytes
+ overlay_tails
.bytes
;
3381 if (total
> overlay_str_len
)
3382 overlay_str_buf
= xpalloc (overlay_str_buf
, &overlay_str_len
,
3383 total
- overlay_str_len
, -1, 1);
3385 p
= overlay_str_buf
;
3386 for (i
= overlay_tails
.used
; --i
>= 0;)
3389 tem
= overlay_tails
.buf
[i
].string
;
3390 nbytes
= copy_text (SDATA (tem
), p
,
3392 STRING_MULTIBYTE (tem
), multibyte
);
3395 for (i
= 0; i
< overlay_heads
.used
; ++i
)
3398 tem
= overlay_heads
.buf
[i
].string
;
3399 nbytes
= copy_text (SDATA (tem
), p
,
3401 STRING_MULTIBYTE (tem
), multibyte
);
3403 tem
= overlay_heads
.buf
[i
].string2
;
3406 nbytes
= copy_text (SDATA (tem
), p
,
3408 STRING_MULTIBYTE (tem
), multibyte
);
3412 if (p
!= overlay_str_buf
+ total
)
3415 *pstr
= overlay_str_buf
;
3421 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
3424 recenter_overlay_lists (struct buffer
*buf
, ptrdiff_t pos
)
3426 Lisp_Object overlay
, beg
, end
;
3427 struct Lisp_Overlay
*prev
, *tail
, *next
;
3429 /* See if anything in overlays_before should move to overlays_after. */
3431 /* We don't strictly need prev in this loop; it should always be nil.
3432 But we use it for symmetry and in case that should cease to be true
3433 with some future change. */
3435 for (tail
= buf
->overlays_before
; tail
; prev
= tail
, tail
= next
)
3438 XSETMISC (overlay
, tail
);
3439 eassert (OVERLAYP (overlay
));
3441 beg
= OVERLAY_START (overlay
);
3442 end
= OVERLAY_END (overlay
);
3444 if (OVERLAY_POSITION (end
) > pos
)
3446 /* OVERLAY needs to be moved. */
3447 ptrdiff_t where
= OVERLAY_POSITION (beg
);
3448 struct Lisp_Overlay
*other
, *other_prev
;
3450 /* Splice the cons cell TAIL out of overlays_before. */
3454 set_buffer_overlays_before (buf
, next
);
3456 /* Search thru overlays_after for where to put it. */
3458 for (other
= buf
->overlays_after
; other
;
3459 other_prev
= other
, other
= other
->next
)
3461 Lisp_Object otherbeg
, otheroverlay
;
3463 XSETMISC (otheroverlay
, other
);
3464 eassert (OVERLAYP (otheroverlay
));
3466 otherbeg
= OVERLAY_START (otheroverlay
);
3467 if (OVERLAY_POSITION (otherbeg
) >= where
)
3471 /* Add TAIL to overlays_after before OTHER. */
3474 other_prev
->next
= tail
;
3476 set_buffer_overlays_after (buf
, tail
);
3480 /* We've reached the things that should stay in overlays_before.
3481 All the rest of overlays_before must end even earlier,
3486 /* See if anything in overlays_after should be in overlays_before. */
3488 for (tail
= buf
->overlays_after
; tail
; prev
= tail
, tail
= next
)
3491 XSETMISC (overlay
, tail
);
3492 eassert (OVERLAYP (overlay
));
3494 beg
= OVERLAY_START (overlay
);
3495 end
= OVERLAY_END (overlay
);
3497 /* Stop looking, when we know that nothing further
3498 can possibly end before POS. */
3499 if (OVERLAY_POSITION (beg
) > pos
)
3502 if (OVERLAY_POSITION (end
) <= pos
)
3504 /* OVERLAY needs to be moved. */
3505 ptrdiff_t where
= OVERLAY_POSITION (end
);
3506 struct Lisp_Overlay
*other
, *other_prev
;
3508 /* Splice the cons cell TAIL out of overlays_after. */
3512 set_buffer_overlays_after (buf
, next
);
3514 /* Search thru overlays_before for where to put it. */
3516 for (other
= buf
->overlays_before
; other
;
3517 other_prev
= other
, other
= other
->next
)
3519 Lisp_Object otherend
, otheroverlay
;
3521 XSETMISC (otheroverlay
, other
);
3522 eassert (OVERLAYP (otheroverlay
));
3524 otherend
= OVERLAY_END (otheroverlay
);
3525 if (OVERLAY_POSITION (otherend
) <= where
)
3529 /* Add TAIL to overlays_before before OTHER. */
3532 other_prev
->next
= tail
;
3534 set_buffer_overlays_before (buf
, tail
);
3539 buf
->overlay_center
= pos
;
3543 adjust_overlays_for_insert (ptrdiff_t pos
, ptrdiff_t length
)
3545 /* After an insertion, the lists are still sorted properly,
3546 but we may need to update the value of the overlay center. */
3547 if (current_buffer
->overlay_center
>= pos
)
3548 current_buffer
->overlay_center
+= length
;
3552 adjust_overlays_for_delete (ptrdiff_t pos
, ptrdiff_t length
)
3554 if (current_buffer
->overlay_center
< pos
)
3555 /* The deletion was to our right. No change needed; the before- and
3556 after-lists are still consistent. */
3558 else if (current_buffer
->overlay_center
- pos
> length
)
3559 /* The deletion was to our left. We need to adjust the center value
3560 to account for the change in position, but the lists are consistent
3561 given the new value. */
3562 current_buffer
->overlay_center
-= length
;
3564 /* We're right in the middle. There might be things on the after-list
3565 that now belong on the before-list. Recentering will move them,
3566 and also update the center point. */
3567 recenter_overlay_lists (current_buffer
, pos
);
3570 /* Fix up overlays that were garbled as a result of permuting markers
3571 in the range START through END. Any overlay with at least one
3572 endpoint in this range will need to be unlinked from the overlay
3573 list and reinserted in its proper place.
3574 Such an overlay might even have negative size at this point.
3575 If so, we'll make the overlay empty. */
3577 fix_start_end_in_overlays (register ptrdiff_t start
, register ptrdiff_t end
)
3579 Lisp_Object overlay
;
3580 struct Lisp_Overlay
*before_list
IF_LINT (= NULL
);
3581 struct Lisp_Overlay
*after_list
IF_LINT (= NULL
);
3582 /* These are either nil, indicating that before_list or after_list
3583 should be assigned, or the cons cell the cdr of which should be
3585 struct Lisp_Overlay
*beforep
= NULL
, *afterp
= NULL
;
3586 /* 'Parent', likewise, indicates a cons cell or
3587 current_buffer->overlays_before or overlays_after, depending
3588 which loop we're in. */
3589 struct Lisp_Overlay
*tail
, *parent
;
3590 ptrdiff_t startpos
, endpos
;
3592 /* This algorithm shifts links around instead of consing and GCing.
3593 The loop invariant is that before_list (resp. after_list) is a
3594 well-formed list except that its last element, the CDR of beforep
3595 (resp. afterp) if beforep (afterp) isn't nil or before_list
3596 (after_list) if it is, is still uninitialized. So it's not a bug
3597 that before_list isn't initialized, although it may look
3599 for (parent
= NULL
, tail
= current_buffer
->overlays_before
; tail
;)
3601 XSETMISC (overlay
, tail
);
3603 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3604 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3606 /* If the overlay is backwards, make it empty. */
3607 if (endpos
< startpos
)
3610 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3618 || (startpos
>= start
&& startpos
< end
))
3620 /* Add it to the end of the wrong list. Later on,
3621 recenter_overlay_lists will move it to the right place. */
3622 if (endpos
< current_buffer
->overlay_center
)
3627 afterp
->next
= tail
;
3635 beforep
->next
= tail
;
3639 set_buffer_overlays_before (current_buffer
, tail
->next
);
3641 parent
->next
= tail
->next
;
3645 parent
= tail
, tail
= parent
->next
;
3647 for (parent
= NULL
, tail
= current_buffer
->overlays_after
; tail
;)
3649 XSETMISC (overlay
, tail
);
3651 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3652 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3654 /* If the overlay is backwards, make it empty. */
3655 if (endpos
< startpos
)
3658 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3662 if (startpos
>= end
)
3665 if (startpos
>= start
3666 || (endpos
>= start
&& endpos
< end
))
3668 if (endpos
< current_buffer
->overlay_center
)
3673 afterp
->next
= tail
;
3681 beforep
->next
= tail
;
3685 set_buffer_overlays_after (current_buffer
, tail
->next
);
3687 parent
->next
= tail
->next
;
3691 parent
= tail
, tail
= parent
->next
;
3694 /* Splice the constructed (wrong) lists into the buffer's lists,
3695 and let the recenter function make it sane again. */
3698 beforep
->next
= current_buffer
->overlays_before
;
3699 set_buffer_overlays_before (current_buffer
, before_list
);
3704 afterp
->next
= current_buffer
->overlays_after
;
3705 set_buffer_overlays_after (current_buffer
, after_list
);
3707 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3710 /* We have two types of overlay: the one whose ending marker is
3711 after-insertion-marker (this is the usual case) and the one whose
3712 ending marker is before-insertion-marker. When `overlays_before'
3713 contains overlays of the latter type and the former type in this
3714 order and both overlays end at inserting position, inserting a text
3715 increases only the ending marker of the latter type, which results
3716 in incorrect ordering of `overlays_before'.
3718 This function fixes ordering of overlays in the slot
3719 `overlays_before' of the buffer *BP. Before the insertion, `point'
3720 was at PREV, and now is at POS. */
3723 fix_overlays_before (struct buffer
*bp
, ptrdiff_t prev
, ptrdiff_t pos
)
3725 /* If parent is nil, replace overlays_before; otherwise, parent->next. */
3726 struct Lisp_Overlay
*tail
= bp
->overlays_before
, *parent
= NULL
, *right_pair
;
3728 ptrdiff_t end
IF_LINT (= 0);
3730 /* After the insertion, the several overlays may be in incorrect
3731 order. The possibility is that, in the list `overlays_before',
3732 an overlay which ends at POS appears after an overlay which ends
3733 at PREV. Since POS is greater than PREV, we must fix the
3734 ordering of these overlays, by moving overlays ends at POS before
3735 the overlays ends at PREV. */
3737 /* At first, find a place where disordered overlays should be linked
3738 in. It is where an overlay which end before POS exists. (i.e. an
3739 overlay whose ending marker is after-insertion-marker if disorder
3742 && (XSETMISC (tem
, tail
),
3743 (end
= OVERLAY_POSITION (OVERLAY_END (tem
))) >= pos
))
3749 /* If we don't find such an overlay,
3750 or the found one ends before PREV,
3751 or the found one is the last one in the list,
3752 we don't have to fix anything. */
3753 if (!tail
|| end
< prev
|| !tail
->next
)
3756 right_pair
= parent
;
3760 /* Now, end position of overlays in the list TAIL should be before
3761 or equal to PREV. In the loop, an overlay which ends at POS is
3762 moved ahead to the place indicated by the CDR of RIGHT_PAIR. If
3763 we found an overlay which ends before PREV, the remaining
3764 overlays are in correct order. */
3767 XSETMISC (tem
, tail
);
3768 end
= OVERLAY_POSITION (OVERLAY_END (tem
));
3771 { /* This overlay is disordered. */
3772 struct Lisp_Overlay
*found
= tail
;
3774 /* Unlink the found overlay. */
3776 parent
->next
= tail
;
3777 /* Move an overlay at RIGHT_PLACE to the next of the found one,
3778 and link it into the right place. */
3781 found
->next
= bp
->overlays_before
;
3782 set_buffer_overlays_before (bp
, found
);
3786 found
->next
= right_pair
->next
;
3787 right_pair
->next
= found
;
3790 else if (end
== prev
)
3795 else /* No more disordered overlay. */
3800 DEFUN ("overlayp", Foverlayp
, Soverlayp
, 1, 1, 0,
3801 doc
: /* Return t if OBJECT is an overlay. */)
3802 (Lisp_Object object
)
3804 return (OVERLAYP (object
) ? Qt
: Qnil
);
3807 DEFUN ("make-overlay", Fmake_overlay
, Smake_overlay
, 2, 5, 0,
3808 doc
: /* Create a new overlay with range BEG to END in BUFFER and return it.
3809 If omitted, BUFFER defaults to the current buffer.
3810 BEG and END may be integers or markers.
3811 The fourth arg FRONT-ADVANCE, if non-nil, makes the marker
3812 for the front of the overlay advance when text is inserted there
3813 \(which means the text *is not* included in the overlay).
3814 The fifth arg REAR-ADVANCE, if non-nil, makes the marker
3815 for the rear of the overlay advance when text is inserted there
3816 \(which means the text *is* included in the overlay). */)
3817 (Lisp_Object beg
, Lisp_Object end
, Lisp_Object buffer
,
3818 Lisp_Object front_advance
, Lisp_Object rear_advance
)
3820 Lisp_Object overlay
;
3824 XSETBUFFER (buffer
, current_buffer
);
3826 CHECK_BUFFER (buffer
);
3828 if (MARKERP (beg
) && !EQ (Fmarker_buffer (beg
), buffer
))
3829 signal_error ("Marker points into wrong buffer", beg
);
3830 if (MARKERP (end
) && !EQ (Fmarker_buffer (end
), buffer
))
3831 signal_error ("Marker points into wrong buffer", end
);
3833 CHECK_NUMBER_COERCE_MARKER (beg
);
3834 CHECK_NUMBER_COERCE_MARKER (end
);
3836 if (XINT (beg
) > XINT (end
))
3839 temp
= beg
; beg
= end
; end
= temp
;
3842 b
= XBUFFER (buffer
);
3844 beg
= Fset_marker (Fmake_marker (), beg
, buffer
);
3845 end
= Fset_marker (Fmake_marker (), end
, buffer
);
3847 if (!NILP (front_advance
))
3848 XMARKER (beg
)->insertion_type
= 1;
3849 if (!NILP (rear_advance
))
3850 XMARKER (end
)->insertion_type
= 1;
3852 overlay
= build_overlay (beg
, end
, Qnil
);
3854 /* Put the new overlay on the wrong list. */
3855 end
= OVERLAY_END (overlay
);
3856 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
3858 eassert (b
->overlays_after
|| (XOVERLAY (overlay
)->next
== NULL
));
3859 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3860 set_buffer_overlays_after (b
, XOVERLAY (overlay
));
3864 eassert (b
->overlays_before
|| (XOVERLAY (overlay
)->next
== NULL
));
3865 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3866 set_buffer_overlays_before (b
, XOVERLAY (overlay
));
3868 /* This puts it in the right list, and in the right order. */
3869 recenter_overlay_lists (b
, b
->overlay_center
);
3871 /* We don't need to redisplay the region covered by the overlay, because
3872 the overlay has no properties at the moment. */
3877 /* Mark a section of BUF as needing redisplay because of overlays changes. */
3880 modify_overlay (struct buffer
*buf
, ptrdiff_t start
, ptrdiff_t end
)
3884 ptrdiff_t temp
= start
;
3889 BUF_COMPUTE_UNCHANGED (buf
, start
, end
);
3891 bset_redisplay (buf
);
3893 ++BUF_OVERLAY_MODIFF (buf
);
3896 /* Remove OVERLAY from LIST. */
3898 static struct Lisp_Overlay
*
3899 unchain_overlay (struct Lisp_Overlay
*list
, struct Lisp_Overlay
*overlay
)
3901 register struct Lisp_Overlay
*tail
, **prev
= &list
;
3903 for (tail
= list
; tail
; prev
= &tail
->next
, tail
= *prev
)
3904 if (tail
== overlay
)
3906 *prev
= overlay
->next
;
3907 overlay
->next
= NULL
;
3913 /* Remove OVERLAY from both overlay lists of B. */
3916 unchain_both (struct buffer
*b
, Lisp_Object overlay
)
3918 struct Lisp_Overlay
*ov
= XOVERLAY (overlay
);
3920 set_buffer_overlays_before (b
, unchain_overlay (b
->overlays_before
, ov
));
3921 set_buffer_overlays_after (b
, unchain_overlay (b
->overlays_after
, ov
));
3922 eassert (XOVERLAY (overlay
)->next
== NULL
);
3925 DEFUN ("move-overlay", Fmove_overlay
, Smove_overlay
, 3, 4, 0,
3926 doc
: /* Set the endpoints of OVERLAY to BEG and END in BUFFER.
3927 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.
3928 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current
3930 (Lisp_Object overlay
, Lisp_Object beg
, Lisp_Object end
, Lisp_Object buffer
)
3932 struct buffer
*b
, *ob
= 0;
3933 Lisp_Object obuffer
;
3934 ptrdiff_t count
= SPECPDL_INDEX ();
3935 ptrdiff_t n_beg
, n_end
, o_beg
IF_LINT (= 0), o_end
IF_LINT (= 0);
3937 CHECK_OVERLAY (overlay
);
3939 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3941 XSETBUFFER (buffer
, current_buffer
);
3942 CHECK_BUFFER (buffer
);
3944 if (NILP (Fbuffer_live_p (buffer
)))
3945 error ("Attempt to move overlay to a dead buffer");
3947 if (MARKERP (beg
) && !EQ (Fmarker_buffer (beg
), buffer
))
3948 signal_error ("Marker points into wrong buffer", beg
);
3949 if (MARKERP (end
) && !EQ (Fmarker_buffer (end
), buffer
))
3950 signal_error ("Marker points into wrong buffer", end
);
3952 CHECK_NUMBER_COERCE_MARKER (beg
);
3953 CHECK_NUMBER_COERCE_MARKER (end
);
3955 if (XINT (beg
) > XINT (end
))
3958 temp
= beg
; beg
= end
; end
= temp
;
3961 specbind (Qinhibit_quit
, Qt
);
3963 obuffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3964 b
= XBUFFER (buffer
);
3966 if (!NILP (obuffer
))
3968 ob
= XBUFFER (obuffer
);
3970 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3971 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3973 unchain_both (ob
, overlay
);
3976 /* Set the overlay boundaries, which may clip them. */
3977 Fset_marker (OVERLAY_START (overlay
), beg
, buffer
);
3978 Fset_marker (OVERLAY_END (overlay
), end
, buffer
);
3980 n_beg
= marker_position (OVERLAY_START (overlay
));
3981 n_end
= marker_position (OVERLAY_END (overlay
));
3983 /* If the overlay has changed buffers, do a thorough redisplay. */
3984 if (!EQ (buffer
, obuffer
))
3986 /* Redisplay where the overlay was. */
3988 modify_overlay (ob
, o_beg
, o_end
);
3990 /* Redisplay where the overlay is going to be. */
3991 modify_overlay (b
, n_beg
, n_end
);
3994 /* Redisplay the area the overlay has just left, or just enclosed. */
3997 modify_overlay (b
, o_end
, n_end
);
3998 else if (o_end
== n_end
)
3999 modify_overlay (b
, o_beg
, n_beg
);
4001 modify_overlay (b
, min (o_beg
, n_beg
), max (o_end
, n_end
));
4004 /* Delete the overlay if it is empty after clipping and has the
4005 evaporate property. */
4006 if (n_beg
== n_end
&& !NILP (Foverlay_get (overlay
, Qevaporate
)))
4007 return unbind_to (count
, Fdelete_overlay (overlay
));
4009 /* Put the overlay into the new buffer's overlay lists, first on the
4011 if (n_end
< b
->overlay_center
)
4013 XOVERLAY (overlay
)->next
= b
->overlays_after
;
4014 set_buffer_overlays_after (b
, XOVERLAY (overlay
));
4018 XOVERLAY (overlay
)->next
= b
->overlays_before
;
4019 set_buffer_overlays_before (b
, XOVERLAY (overlay
));
4022 /* This puts it in the right list, and in the right order. */
4023 recenter_overlay_lists (b
, b
->overlay_center
);
4025 return unbind_to (count
, overlay
);
4028 DEFUN ("delete-overlay", Fdelete_overlay
, Sdelete_overlay
, 1, 1, 0,
4029 doc
: /* Delete the overlay OVERLAY from its buffer. */)
4030 (Lisp_Object overlay
)
4034 ptrdiff_t count
= SPECPDL_INDEX ();
4036 CHECK_OVERLAY (overlay
);
4038 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4042 b
= XBUFFER (buffer
);
4043 specbind (Qinhibit_quit
, Qt
);
4045 unchain_both (b
, overlay
);
4046 drop_overlay (b
, XOVERLAY (overlay
));
4048 /* When deleting an overlay with before or after strings, turn off
4049 display optimizations for the affected buffer, on the basis that
4050 these strings may contain newlines. This is easier to do than to
4051 check for that situation during redisplay. */
4052 if (!windows_or_buffers_changed
4053 && (!NILP (Foverlay_get (overlay
, Qbefore_string
))
4054 || !NILP (Foverlay_get (overlay
, Qafter_string
))))
4055 b
->prevent_redisplay_optimizations_p
= 1;
4057 return unbind_to (count
, Qnil
);
4060 DEFUN ("delete-all-overlays", Fdelete_all_overlays
, Sdelete_all_overlays
, 0, 1, 0,
4061 doc
: /* Delete all overlays of BUFFER.
4062 BUFFER omitted or nil means delete all overlays of the current
4064 (Lisp_Object buffer
)
4066 delete_all_overlays (decode_buffer (buffer
));
4070 /* Overlay dissection functions. */
4072 DEFUN ("overlay-start", Foverlay_start
, Soverlay_start
, 1, 1, 0,
4073 doc
: /* Return the position at which OVERLAY starts. */)
4074 (Lisp_Object overlay
)
4076 CHECK_OVERLAY (overlay
);
4078 return (Fmarker_position (OVERLAY_START (overlay
)));
4081 DEFUN ("overlay-end", Foverlay_end
, Soverlay_end
, 1, 1, 0,
4082 doc
: /* Return the position at which OVERLAY ends. */)
4083 (Lisp_Object overlay
)
4085 CHECK_OVERLAY (overlay
);
4087 return (Fmarker_position (OVERLAY_END (overlay
)));
4090 DEFUN ("overlay-buffer", Foverlay_buffer
, Soverlay_buffer
, 1, 1, 0,
4091 doc
: /* Return the buffer OVERLAY belongs to.
4092 Return nil if OVERLAY has been deleted. */)
4093 (Lisp_Object overlay
)
4095 CHECK_OVERLAY (overlay
);
4097 return Fmarker_buffer (OVERLAY_START (overlay
));
4100 DEFUN ("overlay-properties", Foverlay_properties
, Soverlay_properties
, 1, 1, 0,
4101 doc
: /* Return a list of the properties on OVERLAY.
4102 This is a copy of OVERLAY's plist; modifying its conses has no effect on
4104 (Lisp_Object overlay
)
4106 CHECK_OVERLAY (overlay
);
4108 return Fcopy_sequence (XOVERLAY (overlay
)->plist
);
4112 DEFUN ("overlays-at", Foverlays_at
, Soverlays_at
, 1, 2, 0,
4113 doc
: /* Return a list of the overlays that contain the character at POS.
4114 If SORTED is non-nil, then sort them by decreasing priority. */)
4115 (Lisp_Object pos
, Lisp_Object sorted
)
4117 ptrdiff_t len
, noverlays
;
4118 Lisp_Object
*overlay_vec
;
4121 CHECK_NUMBER_COERCE_MARKER (pos
);
4123 if (!buffer_has_overlays ())
4127 /* We can't use alloca here because overlays_at can call xrealloc. */
4128 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4130 /* Put all the overlays we want in a vector in overlay_vec.
4131 Store the length in len. */
4132 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4136 noverlays
= sort_overlays (overlay_vec
, noverlays
,
4137 WINDOWP (sorted
) ? XWINDOW (sorted
) : NULL
);
4139 /* Make a list of them all. */
4140 result
= Flist (noverlays
, overlay_vec
);
4142 xfree (overlay_vec
);
4146 DEFUN ("overlays-in", Foverlays_in
, Soverlays_in
, 2, 2, 0,
4147 doc
: /* Return a list of the overlays that overlap the region BEG ... END.
4148 Overlap means that at least one character is contained within the overlay
4149 and also contained within the specified region.
4150 Empty overlays are included in the result if they are located at BEG,
4151 between BEG and END, or at END provided END denotes the position at the
4152 end of the buffer. */)
4153 (Lisp_Object beg
, Lisp_Object end
)
4155 ptrdiff_t len
, noverlays
;
4156 Lisp_Object
*overlay_vec
;
4159 CHECK_NUMBER_COERCE_MARKER (beg
);
4160 CHECK_NUMBER_COERCE_MARKER (end
);
4162 if (!buffer_has_overlays ())
4166 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4168 /* Put all the overlays we want in a vector in overlay_vec.
4169 Store the length in len. */
4170 noverlays
= overlays_in (XINT (beg
), XINT (end
), 1, &overlay_vec
, &len
,
4173 /* Make a list of them all. */
4174 result
= Flist (noverlays
, overlay_vec
);
4176 xfree (overlay_vec
);
4180 DEFUN ("next-overlay-change", Fnext_overlay_change
, Snext_overlay_change
,
4182 doc
: /* Return the next position after POS where an overlay starts or ends.
4183 If there are no overlay boundaries from POS to (point-max),
4184 the value is (point-max). */)
4187 ptrdiff_t i
, len
, noverlays
;
4189 Lisp_Object
*overlay_vec
;
4191 CHECK_NUMBER_COERCE_MARKER (pos
);
4193 if (!buffer_has_overlays ())
4194 return make_number (ZV
);
4197 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4199 /* Put all the overlays we want in a vector in overlay_vec.
4200 Store the length in len.
4201 endpos gets the position where the next overlay starts. */
4202 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4205 /* If any of these overlays ends before endpos,
4206 use its ending point instead. */
4207 for (i
= 0; i
< noverlays
; i
++)
4212 oend
= OVERLAY_END (overlay_vec
[i
]);
4213 oendpos
= OVERLAY_POSITION (oend
);
4214 if (oendpos
< endpos
)
4218 xfree (overlay_vec
);
4219 return make_number (endpos
);
4222 DEFUN ("previous-overlay-change", Fprevious_overlay_change
,
4223 Sprevious_overlay_change
, 1, 1, 0,
4224 doc
: /* Return the previous position before POS where an overlay starts or ends.
4225 If there are no overlay boundaries from (point-min) to POS,
4226 the value is (point-min). */)
4230 Lisp_Object
*overlay_vec
;
4233 CHECK_NUMBER_COERCE_MARKER (pos
);
4235 if (!buffer_has_overlays ())
4236 return make_number (BEGV
);
4238 /* At beginning of buffer, we know the answer;
4239 avoid bug subtracting 1 below. */
4240 if (XINT (pos
) == BEGV
)
4244 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4246 /* Put all the overlays we want in a vector in overlay_vec.
4247 Store the length in len.
4248 prevpos gets the position of the previous change. */
4249 overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4252 xfree (overlay_vec
);
4253 return make_number (prevpos
);
4256 /* These functions are for debugging overlays. */
4258 DEFUN ("overlay-lists", Foverlay_lists
, Soverlay_lists
, 0, 0, 0,
4259 doc
: /* Return a pair of lists giving all the overlays of the current buffer.
4260 The car has all the overlays before the overlay center;
4261 the cdr has all the overlays after the overlay center.
4262 Recentering overlays moves overlays between these lists.
4263 The lists you get are copies, so that changing them has no effect.
4264 However, the overlays you get are the real objects that the buffer uses. */)
4267 struct Lisp_Overlay
*ol
;
4268 Lisp_Object before
= Qnil
, after
= Qnil
, tmp
;
4270 for (ol
= current_buffer
->overlays_before
; ol
; ol
= ol
->next
)
4273 before
= Fcons (tmp
, before
);
4275 for (ol
= current_buffer
->overlays_after
; ol
; ol
= ol
->next
)
4278 after
= Fcons (tmp
, after
);
4281 return Fcons (Fnreverse (before
), Fnreverse (after
));
4284 DEFUN ("overlay-recenter", Foverlay_recenter
, Soverlay_recenter
, 1, 1, 0,
4285 doc
: /* Recenter the overlays of the current buffer around position POS.
4286 That makes overlay lookup faster for positions near POS (but perhaps slower
4287 for positions far away from POS). */)
4291 CHECK_NUMBER_COERCE_MARKER (pos
);
4293 p
= clip_to_bounds (PTRDIFF_MIN
, XINT (pos
), PTRDIFF_MAX
);
4294 recenter_overlay_lists (current_buffer
, p
);
4298 DEFUN ("overlay-get", Foverlay_get
, Soverlay_get
, 2, 2, 0,
4299 doc
: /* Get the property of overlay OVERLAY with property name PROP. */)
4300 (Lisp_Object overlay
, Lisp_Object prop
)
4302 CHECK_OVERLAY (overlay
);
4303 return lookup_char_property (XOVERLAY (overlay
)->plist
, prop
, 0);
4306 DEFUN ("overlay-put", Foverlay_put
, Soverlay_put
, 3, 3, 0,
4307 doc
: /* Set one property of overlay OVERLAY: give property PROP value VALUE.
4308 VALUE will be returned.*/)
4309 (Lisp_Object overlay
, Lisp_Object prop
, Lisp_Object value
)
4311 Lisp_Object tail
, buffer
;
4314 CHECK_OVERLAY (overlay
);
4316 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4318 for (tail
= XOVERLAY (overlay
)->plist
;
4319 CONSP (tail
) && CONSP (XCDR (tail
));
4320 tail
= XCDR (XCDR (tail
)))
4321 if (EQ (XCAR (tail
), prop
))
4323 changed
= !EQ (XCAR (XCDR (tail
)), value
);
4324 XSETCAR (XCDR (tail
), value
);
4327 /* It wasn't in the list, so add it to the front. */
4328 changed
= !NILP (value
);
4330 (overlay
, Fcons (prop
, Fcons (value
, XOVERLAY (overlay
)->plist
)));
4332 if (! NILP (buffer
))
4335 modify_overlay (XBUFFER (buffer
),
4336 marker_position (OVERLAY_START (overlay
)),
4337 marker_position (OVERLAY_END (overlay
)));
4338 if (EQ (prop
, Qevaporate
) && ! NILP (value
)
4339 && (OVERLAY_POSITION (OVERLAY_START (overlay
))
4340 == OVERLAY_POSITION (OVERLAY_END (overlay
))))
4341 Fdelete_overlay (overlay
);
4347 /* Subroutine of report_overlay_modification. */
4349 /* Lisp vector holding overlay hook functions to call.
4350 Vector elements come in pairs.
4351 Each even-index element is a list of hook functions.
4352 The following odd-index element is the overlay they came from.
4354 Before the buffer change, we fill in this vector
4355 as we call overlay hook functions.
4356 After the buffer change, we get the functions to call from this vector.
4357 This way we always call the same functions before and after the change. */
4358 static Lisp_Object last_overlay_modification_hooks
;
4360 /* Number of elements actually used in last_overlay_modification_hooks. */
4361 static ptrdiff_t last_overlay_modification_hooks_used
;
4363 /* Add one functionlist/overlay pair
4364 to the end of last_overlay_modification_hooks. */
4367 add_overlay_mod_hooklist (Lisp_Object functionlist
, Lisp_Object overlay
)
4369 ptrdiff_t oldsize
= ASIZE (last_overlay_modification_hooks
);
4371 if (oldsize
- 1 <= last_overlay_modification_hooks_used
)
4372 last_overlay_modification_hooks
=
4373 larger_vector (last_overlay_modification_hooks
, 2, -1);
4374 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4375 functionlist
); last_overlay_modification_hooks_used
++;
4376 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4377 overlay
); last_overlay_modification_hooks_used
++;
4380 /* Run the modification-hooks of overlays that include
4381 any part of the text in START to END.
4382 If this change is an insertion, also
4383 run the insert-before-hooks of overlay starting at END,
4384 and the insert-after-hooks of overlay ending at START.
4386 This is called both before and after the modification.
4387 AFTER is true when we call after the modification.
4389 ARG1, ARG2, ARG3 are arguments to pass to the hook functions.
4390 When AFTER is nonzero, they are the start position,
4391 the position after the inserted new text,
4392 and the length of deleted or replaced old text. */
4395 report_overlay_modification (Lisp_Object start
, Lisp_Object end
, bool after
,
4396 Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
)
4398 Lisp_Object prop
, overlay
;
4399 struct Lisp_Overlay
*tail
;
4400 /* True if this change is an insertion. */
4401 bool insertion
= (after
? XFASTINT (arg3
) == 0 : EQ (start
, end
));
4402 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4407 /* We used to run the functions as soon as we found them and only register
4408 them in last_overlay_modification_hooks for the purpose of the `after'
4409 case. But running elisp code as we traverse the list of overlays is
4410 painful because the list can be modified by the elisp code so we had to
4411 copy at several places. We now simply do a read-only traversal that
4412 only collects the functions to run and we run them afterwards. It's
4413 simpler, especially since all the code was already there. -stef */
4417 /* We are being called before a change.
4418 Scan the overlays to find the functions to call. */
4419 last_overlay_modification_hooks_used
= 0;
4420 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4422 ptrdiff_t startpos
, endpos
;
4423 Lisp_Object ostart
, oend
;
4425 XSETMISC (overlay
, tail
);
4427 ostart
= OVERLAY_START (overlay
);
4428 oend
= OVERLAY_END (overlay
);
4429 endpos
= OVERLAY_POSITION (oend
);
4430 if (XFASTINT (start
) > endpos
)
4432 startpos
= OVERLAY_POSITION (ostart
);
4433 if (insertion
&& (XFASTINT (start
) == startpos
4434 || XFASTINT (end
) == startpos
))
4436 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4438 add_overlay_mod_hooklist (prop
, overlay
);
4440 if (insertion
&& (XFASTINT (start
) == endpos
4441 || XFASTINT (end
) == endpos
))
4443 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4445 add_overlay_mod_hooklist (prop
, overlay
);
4447 /* Test for intersecting intervals. This does the right thing
4448 for both insertion and deletion. */
4449 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4451 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4453 add_overlay_mod_hooklist (prop
, overlay
);
4457 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4459 ptrdiff_t startpos
, endpos
;
4460 Lisp_Object ostart
, oend
;
4462 XSETMISC (overlay
, tail
);
4464 ostart
= OVERLAY_START (overlay
);
4465 oend
= OVERLAY_END (overlay
);
4466 startpos
= OVERLAY_POSITION (ostart
);
4467 endpos
= OVERLAY_POSITION (oend
);
4468 if (XFASTINT (end
) < startpos
)
4470 if (insertion
&& (XFASTINT (start
) == startpos
4471 || XFASTINT (end
) == startpos
))
4473 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4475 add_overlay_mod_hooklist (prop
, overlay
);
4477 if (insertion
&& (XFASTINT (start
) == endpos
4478 || XFASTINT (end
) == endpos
))
4480 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4482 add_overlay_mod_hooklist (prop
, overlay
);
4484 /* Test for intersecting intervals. This does the right thing
4485 for both insertion and deletion. */
4486 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4488 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4490 add_overlay_mod_hooklist (prop
, overlay
);
4495 GCPRO4 (overlay
, arg1
, arg2
, arg3
);
4497 /* Call the functions recorded in last_overlay_modification_hooks.
4498 First copy the vector contents, in case some of these hooks
4499 do subsequent modification of the buffer. */
4500 ptrdiff_t size
= last_overlay_modification_hooks_used
;
4505 SAFE_ALLOCA_LISP (copy
, size
);
4506 memcpy (copy
, XVECTOR (last_overlay_modification_hooks
)->contents
,
4509 for (i
= 0; i
< size
;)
4511 Lisp_Object prop_i
, overlay_i
;
4513 overlay_i
= copy
[i
++];
4514 call_overlay_mod_hooks (prop_i
, overlay_i
, after
, arg1
, arg2
, arg3
);
4523 call_overlay_mod_hooks (Lisp_Object list
, Lisp_Object overlay
, bool after
,
4524 Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
)
4526 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4528 GCPRO4 (list
, arg1
, arg2
, arg3
);
4530 while (CONSP (list
))
4533 call4 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
);
4535 call5 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
, arg3
);
4541 /* Delete any zero-sized overlays at position POS, if the `evaporate'
4544 evaporate_overlays (ptrdiff_t pos
)
4546 Lisp_Object overlay
, hit_list
;
4547 struct Lisp_Overlay
*tail
;
4550 if (pos
<= current_buffer
->overlay_center
)
4551 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4554 XSETMISC (overlay
, tail
);
4555 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4558 if (endpos
== pos
&& OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
4559 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4560 hit_list
= Fcons (overlay
, hit_list
);
4563 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4566 XSETMISC (overlay
, tail
);
4567 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4570 if (startpos
== pos
&& OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
4571 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4572 hit_list
= Fcons (overlay
, hit_list
);
4574 for (; CONSP (hit_list
); hit_list
= XCDR (hit_list
))
4575 Fdelete_overlay (XCAR (hit_list
));
4578 /***********************************************************************
4579 Allocation with mmap
4580 ***********************************************************************/
4582 /* Note: WINDOWSNT implements this stuff on w32heap.c. */
4583 #if defined USE_MMAP_FOR_BUFFERS && !defined WINDOWSNT
4585 #include <sys/mman.h>
4588 #ifdef MAP_ANONYMOUS
4589 #define MAP_ANON MAP_ANONYMOUS
4596 #define MAP_FAILED ((void *) -1)
4606 /* Memory is allocated in regions which are mapped using mmap(2).
4607 The current implementation lets the system select mapped
4608 addresses; we're not using MAP_FIXED in general, except when
4609 trying to enlarge regions.
4611 Each mapped region starts with a mmap_region structure, the user
4612 area starts after that structure, aligned to MEM_ALIGN.
4614 +-----------------------+
4615 | struct mmap_info + |
4617 +-----------------------+
4621 +-----------------------+ */
4625 /* User-specified size. */
4626 size_t nbytes_specified
;
4628 /* Number of bytes mapped */
4629 size_t nbytes_mapped
;
4631 /* Pointer to the location holding the address of the memory
4632 allocated with the mmap'd block. The variable actually points
4633 after this structure. */
4636 /* Next and previous in list of all mmap'd regions. */
4637 struct mmap_region
*next
, *prev
;
4640 /* Doubly-linked list of mmap'd regions. */
4642 static struct mmap_region
*mmap_regions
;
4644 /* File descriptor for mmap. If we don't have anonymous mapping,
4645 /dev/zero will be opened on it. */
4649 /* Page size on this system. */
4651 static int mmap_page_size
;
4653 /* 1 means mmap has been initialized. */
4655 static bool mmap_initialized_p
;
4657 /* Value is X rounded up to the next multiple of N. */
4659 #define ROUND(X, N) (((X) + (N) - 1) / (N) * (N))
4661 /* Size of mmap_region structure plus padding. */
4663 #define MMAP_REGION_STRUCT_SIZE \
4664 ROUND (sizeof (struct mmap_region), MEM_ALIGN)
4666 /* Given a pointer P to the start of the user-visible part of a mapped
4667 region, return a pointer to the start of the region. */
4669 #define MMAP_REGION(P) \
4670 ((struct mmap_region *) ((char *) (P) - MMAP_REGION_STRUCT_SIZE))
4672 /* Given a pointer P to the start of a mapped region, return a pointer
4673 to the start of the user-visible part of the region. */
4675 #define MMAP_USER_AREA(P) \
4676 ((void *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
4678 #define MEM_ALIGN sizeof (double)
4680 /* Predicate returning true if part of the address range [START .. END]
4681 is currently mapped. Used to prevent overwriting an existing
4684 Default is to conservatively assume the address range is occupied by
4685 something else. This can be overridden by system configuration
4686 files if system-specific means to determine this exists. */
4688 #ifndef MMAP_ALLOCATED_P
4689 #define MMAP_ALLOCATED_P(start, end) 1
4692 /* Perform necessary initializations for the use of mmap. */
4698 /* The value of mmap_fd is initially 0 in temacs, and -1
4699 in a dumped Emacs. */
4702 /* No anonymous mmap -- we need the file descriptor. */
4703 mmap_fd
= emacs_open ("/dev/zero", O_RDONLY
, 0);
4705 fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno
));
4707 #endif /* MAP_ANON == 0 */
4709 if (mmap_initialized_p
)
4711 mmap_initialized_p
= 1;
4717 mmap_page_size
= getpagesize ();
4720 /* Unmap a region. P is a pointer to the start of the user-araa of
4724 mmap_free_1 (struct mmap_region
*r
)
4727 r
->next
->prev
= r
->prev
;
4729 r
->prev
->next
= r
->next
;
4731 mmap_regions
= r
->next
;
4733 if (munmap (r
, r
->nbytes_mapped
) == -1)
4734 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4738 /* Enlarge region R by NPAGES pages. NPAGES < 0 means shrink R.
4739 Value is true if successful. */
4742 mmap_enlarge (struct mmap_region
*r
, int npages
)
4744 char *region_end
= (char *) r
+ r
->nbytes_mapped
;
4750 /* Unmap pages at the end of the region. */
4751 nbytes
= - npages
* mmap_page_size
;
4752 if (munmap (region_end
- nbytes
, nbytes
) == -1)
4753 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4756 r
->nbytes_mapped
-= nbytes
;
4760 else if (npages
> 0)
4762 nbytes
= npages
* mmap_page_size
;
4764 /* Try to map additional pages at the end of the region. We
4765 cannot do this if the address range is already occupied by
4766 something else because mmap deletes any previous mapping.
4767 I'm not sure this is worth doing, let's see. */
4768 if (!MMAP_ALLOCATED_P (region_end
, region_end
+ nbytes
))
4772 p
= mmap (region_end
, nbytes
, PROT_READ
| PROT_WRITE
,
4773 MAP_ANON
| MAP_PRIVATE
| MAP_FIXED
, mmap_fd
, 0);
4774 if (p
== MAP_FAILED
)
4775 ; /* fprintf (stderr, "mmap: %s\n", emacs_strerror (errno)); */
4776 else if (p
!= region_end
)
4778 /* Kernels are free to choose a different address. In
4779 that case, unmap what we've mapped above; we have
4781 if (munmap (p
, nbytes
) == -1)
4782 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4786 r
->nbytes_mapped
+= nbytes
;
4796 /* Allocate a block of storage large enough to hold NBYTES bytes of
4797 data. A pointer to the data is returned in *VAR. VAR is thus the
4798 address of some variable which will use the data area.
4800 The allocation of 0 bytes is valid.
4802 If we can't allocate the necessary memory, set *VAR to null, and
4806 mmap_alloc (void **var
, size_t nbytes
)
4813 map
= ROUND (nbytes
+ MMAP_REGION_STRUCT_SIZE
, mmap_page_size
);
4814 p
= mmap (NULL
, map
, PROT_READ
| PROT_WRITE
, MAP_ANON
| MAP_PRIVATE
,
4817 if (p
== MAP_FAILED
)
4819 if (errno
!= ENOMEM
)
4820 fprintf (stderr
, "mmap: %s\n", emacs_strerror (errno
));
4825 struct mmap_region
*r
= p
;
4827 r
->nbytes_specified
= nbytes
;
4828 r
->nbytes_mapped
= map
;
4831 r
->next
= mmap_regions
;
4836 p
= MMAP_USER_AREA (p
);
4843 /* Free a block of relocatable storage whose data is pointed to by
4844 PTR. Store 0 in *PTR to show there's no block allocated. */
4847 mmap_free (void **var
)
4853 mmap_free_1 (MMAP_REGION (*var
));
4859 /* Given a pointer at address VAR to data allocated with mmap_alloc,
4860 resize it to size NBYTES. Change *VAR to reflect the new block,
4861 and return this value. If more memory cannot be allocated, then
4862 leave *VAR unchanged, and return null. */
4865 mmap_realloc (void **var
, size_t nbytes
)
4872 result
= mmap_alloc (var
, nbytes
);
4873 else if (nbytes
== 0)
4876 result
= mmap_alloc (var
, nbytes
);
4880 struct mmap_region
*r
= MMAP_REGION (*var
);
4881 size_t room
= r
->nbytes_mapped
- MMAP_REGION_STRUCT_SIZE
;
4886 void *old_ptr
= *var
;
4888 /* Try to map additional pages at the end of the region.
4889 If that fails, allocate a new region, copy data
4890 from the old region, then free it. */
4891 if (mmap_enlarge (r
, (ROUND (nbytes
- room
, mmap_page_size
)
4894 r
->nbytes_specified
= nbytes
;
4895 *var
= result
= old_ptr
;
4897 else if (mmap_alloc (var
, nbytes
))
4899 memcpy (*var
, old_ptr
, r
->nbytes_specified
);
4900 mmap_free_1 (MMAP_REGION (old_ptr
));
4902 r
= MMAP_REGION (result
);
4903 r
->nbytes_specified
= nbytes
;
4911 else if (room
- nbytes
>= mmap_page_size
)
4913 /* Shrinking by at least a page. Let's give some
4914 memory back to the system.
4916 The extra parens are to make the division happens first,
4917 on positive values, so we know it will round towards
4919 mmap_enlarge (r
, - ((room
- nbytes
) / mmap_page_size
));
4921 r
->nbytes_specified
= nbytes
;
4925 /* Leave it alone. */
4927 r
->nbytes_specified
= nbytes
;
4935 #endif /* USE_MMAP_FOR_BUFFERS */
4939 /***********************************************************************
4940 Buffer-text Allocation
4941 ***********************************************************************/
4943 /* Allocate NBYTES bytes for buffer B's text buffer. */
4946 alloc_buffer_text (struct buffer
*b
, ptrdiff_t nbytes
)
4951 #if defined USE_MMAP_FOR_BUFFERS
4952 p
= mmap_alloc ((void **) &b
->text
->beg
, nbytes
);
4953 #elif defined REL_ALLOC
4954 p
= r_alloc ((void **) &b
->text
->beg
, nbytes
);
4956 p
= xmalloc (nbytes
);
4962 memory_full (nbytes
);
4969 /* Enlarge buffer B's text buffer by DELTA bytes. DELTA < 0 means
4973 enlarge_buffer_text (struct buffer
*b
, ptrdiff_t delta
)
4976 ptrdiff_t nbytes
= (BUF_Z_BYTE (b
) - BUF_BEG_BYTE (b
) + BUF_GAP_SIZE (b
) + 1
4979 #if defined USE_MMAP_FOR_BUFFERS
4980 p
= mmap_realloc ((void **) &b
->text
->beg
, nbytes
);
4981 #elif defined REL_ALLOC
4982 p
= r_re_alloc ((void **) &b
->text
->beg
, nbytes
);
4984 p
= xrealloc (b
->text
->beg
, nbytes
);
4990 memory_full (nbytes
);
4993 BUF_BEG_ADDR (b
) = p
;
4998 /* Free buffer B's text buffer. */
5001 free_buffer_text (struct buffer
*b
)
5005 #if defined USE_MMAP_FOR_BUFFERS
5006 mmap_free ((void **) &b
->text
->beg
);
5007 #elif defined REL_ALLOC
5008 r_alloc_free ((void **) &b
->text
->beg
);
5010 xfree (b
->text
->beg
);
5013 BUF_BEG_ADDR (b
) = NULL
;
5019 /***********************************************************************
5021 ***********************************************************************/
5024 init_buffer_once (void)
5028 memset (buffer_permanent_local_flags
, 0, sizeof buffer_permanent_local_flags
);
5030 /* Make sure all markable slots in buffer_defaults
5031 are initialized reasonably, so mark_buffer won't choke. */
5032 reset_buffer (&buffer_defaults
);
5033 eassert (NILP (BVAR (&buffer_defaults
, name
)));
5034 reset_buffer_local_variables (&buffer_defaults
, 1);
5035 eassert (NILP (BVAR (&buffer_local_symbols
, name
)));
5036 reset_buffer (&buffer_local_symbols
);
5037 reset_buffer_local_variables (&buffer_local_symbols
, 1);
5038 /* Prevent GC from getting confused. */
5039 buffer_defaults
.text
= &buffer_defaults
.own_text
;
5040 buffer_local_symbols
.text
= &buffer_local_symbols
.own_text
;
5041 /* No one will share the text with these buffers, but let's play it safe. */
5042 buffer_defaults
.indirections
= 0;
5043 buffer_local_symbols
.indirections
= 0;
5044 /* Likewise no one will display them. */
5045 buffer_defaults
.window_count
= 0;
5046 buffer_local_symbols
.window_count
= 0;
5047 set_buffer_intervals (&buffer_defaults
, NULL
);
5048 set_buffer_intervals (&buffer_local_symbols
, NULL
);
5049 /* This is not strictly necessary, but let's make them initialized. */
5050 bset_name (&buffer_defaults
, build_pure_c_string (" *buffer-defaults*"));
5051 bset_name (&buffer_local_symbols
, build_pure_c_string (" *buffer-local-symbols*"));
5052 BUFFER_PVEC_INIT (&buffer_defaults
);
5053 BUFFER_PVEC_INIT (&buffer_local_symbols
);
5055 /* Set up the default values of various buffer slots. */
5056 /* Must do these before making the first buffer! */
5058 /* real setup is done in bindings.el */
5059 bset_mode_line_format (&buffer_defaults
, build_pure_c_string ("%-"));
5060 bset_header_line_format (&buffer_defaults
, Qnil
);
5061 bset_abbrev_mode (&buffer_defaults
, Qnil
);
5062 bset_overwrite_mode (&buffer_defaults
, Qnil
);
5063 bset_case_fold_search (&buffer_defaults
, Qt
);
5064 bset_auto_fill_function (&buffer_defaults
, Qnil
);
5065 bset_selective_display (&buffer_defaults
, Qnil
);
5066 bset_selective_display_ellipses (&buffer_defaults
, Qt
);
5067 bset_abbrev_table (&buffer_defaults
, Qnil
);
5068 bset_display_table (&buffer_defaults
, Qnil
);
5069 bset_undo_list (&buffer_defaults
, Qnil
);
5070 bset_mark_active (&buffer_defaults
, Qnil
);
5071 bset_file_format (&buffer_defaults
, Qnil
);
5072 bset_auto_save_file_format (&buffer_defaults
, Qt
);
5073 set_buffer_overlays_before (&buffer_defaults
, NULL
);
5074 set_buffer_overlays_after (&buffer_defaults
, NULL
);
5075 buffer_defaults
.overlay_center
= BEG
;
5077 XSETFASTINT (BVAR (&buffer_defaults
, tab_width
), 8);
5078 bset_truncate_lines (&buffer_defaults
, Qnil
);
5079 bset_word_wrap (&buffer_defaults
, Qnil
);
5080 bset_ctl_arrow (&buffer_defaults
, Qt
);
5081 bset_bidi_display_reordering (&buffer_defaults
, Qt
);
5082 bset_bidi_paragraph_direction (&buffer_defaults
, Qnil
);
5083 bset_cursor_type (&buffer_defaults
, Qt
);
5084 bset_extra_line_spacing (&buffer_defaults
, Qnil
);
5085 bset_cursor_in_non_selected_windows (&buffer_defaults
, Qt
);
5087 bset_enable_multibyte_characters (&buffer_defaults
, Qt
);
5088 bset_buffer_file_coding_system (&buffer_defaults
, Qnil
);
5089 XSETFASTINT (BVAR (&buffer_defaults
, fill_column
), 70);
5090 XSETFASTINT (BVAR (&buffer_defaults
, left_margin
), 0);
5091 bset_cache_long_scans (&buffer_defaults
, Qt
);
5092 bset_file_truename (&buffer_defaults
, Qnil
);
5093 XSETFASTINT (BVAR (&buffer_defaults
, display_count
), 0);
5094 XSETFASTINT (BVAR (&buffer_defaults
, left_margin_cols
), 0);
5095 XSETFASTINT (BVAR (&buffer_defaults
, right_margin_cols
), 0);
5096 bset_left_fringe_width (&buffer_defaults
, Qnil
);
5097 bset_right_fringe_width (&buffer_defaults
, Qnil
);
5098 bset_fringes_outside_margins (&buffer_defaults
, Qnil
);
5099 bset_scroll_bar_width (&buffer_defaults
, Qnil
);
5100 bset_scroll_bar_height (&buffer_defaults
, Qnil
);
5101 bset_vertical_scroll_bar_type (&buffer_defaults
, Qt
);
5102 bset_horizontal_scroll_bar_type (&buffer_defaults
, Qt
);
5103 bset_indicate_empty_lines (&buffer_defaults
, Qnil
);
5104 bset_indicate_buffer_boundaries (&buffer_defaults
, Qnil
);
5105 bset_fringe_indicator_alist (&buffer_defaults
, Qnil
);
5106 bset_fringe_cursor_alist (&buffer_defaults
, Qnil
);
5107 bset_scroll_up_aggressively (&buffer_defaults
, Qnil
);
5108 bset_scroll_down_aggressively (&buffer_defaults
, Qnil
);
5109 bset_display_time (&buffer_defaults
, Qnil
);
5111 /* Assign the local-flags to the slots that have default values.
5112 The local flag is a bit that is used in the buffer
5113 to say that it has its own local value for the slot.
5114 The local flag bits are in the local_var_flags slot of the buffer. */
5116 /* Nothing can work if this isn't true */
5117 { verify (sizeof (EMACS_INT
) == word_size
); }
5119 /* 0 means not a lisp var, -1 means always local, else mask */
5120 memset (&buffer_local_flags
, 0, sizeof buffer_local_flags
);
5121 bset_filename (&buffer_local_flags
, make_number (-1));
5122 bset_directory (&buffer_local_flags
, make_number (-1));
5123 bset_backed_up (&buffer_local_flags
, make_number (-1));
5124 bset_save_length (&buffer_local_flags
, make_number (-1));
5125 bset_auto_save_file_name (&buffer_local_flags
, make_number (-1));
5126 bset_read_only (&buffer_local_flags
, make_number (-1));
5127 bset_major_mode (&buffer_local_flags
, make_number (-1));
5128 bset_mode_name (&buffer_local_flags
, make_number (-1));
5129 bset_undo_list (&buffer_local_flags
, make_number (-1));
5130 bset_mark_active (&buffer_local_flags
, make_number (-1));
5131 bset_point_before_scroll (&buffer_local_flags
, make_number (-1));
5132 bset_file_truename (&buffer_local_flags
, make_number (-1));
5133 bset_invisibility_spec (&buffer_local_flags
, make_number (-1));
5134 bset_file_format (&buffer_local_flags
, make_number (-1));
5135 bset_auto_save_file_format (&buffer_local_flags
, make_number (-1));
5136 bset_display_count (&buffer_local_flags
, make_number (-1));
5137 bset_display_time (&buffer_local_flags
, make_number (-1));
5138 bset_enable_multibyte_characters (&buffer_local_flags
, make_number (-1));
5141 XSETFASTINT (BVAR (&buffer_local_flags
, mode_line_format
), idx
); ++idx
;
5142 XSETFASTINT (BVAR (&buffer_local_flags
, abbrev_mode
), idx
); ++idx
;
5143 XSETFASTINT (BVAR (&buffer_local_flags
, overwrite_mode
), idx
); ++idx
;
5144 XSETFASTINT (BVAR (&buffer_local_flags
, case_fold_search
), idx
); ++idx
;
5145 XSETFASTINT (BVAR (&buffer_local_flags
, auto_fill_function
), idx
); ++idx
;
5146 XSETFASTINT (BVAR (&buffer_local_flags
, selective_display
), idx
); ++idx
;
5147 XSETFASTINT (BVAR (&buffer_local_flags
, selective_display_ellipses
), idx
); ++idx
;
5148 XSETFASTINT (BVAR (&buffer_local_flags
, tab_width
), idx
); ++idx
;
5149 XSETFASTINT (BVAR (&buffer_local_flags
, truncate_lines
), idx
); ++idx
;
5150 XSETFASTINT (BVAR (&buffer_local_flags
, word_wrap
), idx
); ++idx
;
5151 XSETFASTINT (BVAR (&buffer_local_flags
, ctl_arrow
), idx
); ++idx
;
5152 XSETFASTINT (BVAR (&buffer_local_flags
, fill_column
), idx
); ++idx
;
5153 XSETFASTINT (BVAR (&buffer_local_flags
, left_margin
), idx
); ++idx
;
5154 XSETFASTINT (BVAR (&buffer_local_flags
, abbrev_table
), idx
); ++idx
;
5155 XSETFASTINT (BVAR (&buffer_local_flags
, display_table
), idx
); ++idx
;
5156 XSETFASTINT (BVAR (&buffer_local_flags
, syntax_table
), idx
); ++idx
;
5157 XSETFASTINT (BVAR (&buffer_local_flags
, cache_long_scans
), idx
); ++idx
;
5158 XSETFASTINT (BVAR (&buffer_local_flags
, category_table
), idx
); ++idx
;
5159 XSETFASTINT (BVAR (&buffer_local_flags
, bidi_display_reordering
), idx
); ++idx
;
5160 XSETFASTINT (BVAR (&buffer_local_flags
, bidi_paragraph_direction
), idx
); ++idx
;
5161 XSETFASTINT (BVAR (&buffer_local_flags
, buffer_file_coding_system
), idx
);
5162 /* Make this one a permanent local. */
5163 buffer_permanent_local_flags
[idx
++] = 1;
5164 XSETFASTINT (BVAR (&buffer_local_flags
, left_margin_cols
), idx
); ++idx
;
5165 XSETFASTINT (BVAR (&buffer_local_flags
, right_margin_cols
), idx
); ++idx
;
5166 XSETFASTINT (BVAR (&buffer_local_flags
, left_fringe_width
), idx
); ++idx
;
5167 XSETFASTINT (BVAR (&buffer_local_flags
, right_fringe_width
), idx
); ++idx
;
5168 XSETFASTINT (BVAR (&buffer_local_flags
, fringes_outside_margins
), idx
); ++idx
;
5169 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_bar_width
), idx
); ++idx
;
5170 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_bar_height
), idx
); ++idx
;
5171 XSETFASTINT (BVAR (&buffer_local_flags
, vertical_scroll_bar_type
), idx
); ++idx
;
5172 XSETFASTINT (BVAR (&buffer_local_flags
, horizontal_scroll_bar_type
), idx
); ++idx
;
5173 XSETFASTINT (BVAR (&buffer_local_flags
, indicate_empty_lines
), idx
); ++idx
;
5174 XSETFASTINT (BVAR (&buffer_local_flags
, indicate_buffer_boundaries
), idx
); ++idx
;
5175 XSETFASTINT (BVAR (&buffer_local_flags
, fringe_indicator_alist
), idx
); ++idx
;
5176 XSETFASTINT (BVAR (&buffer_local_flags
, fringe_cursor_alist
), idx
); ++idx
;
5177 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_up_aggressively
), idx
); ++idx
;
5178 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_down_aggressively
), idx
); ++idx
;
5179 XSETFASTINT (BVAR (&buffer_local_flags
, header_line_format
), idx
); ++idx
;
5180 XSETFASTINT (BVAR (&buffer_local_flags
, cursor_type
), idx
); ++idx
;
5181 XSETFASTINT (BVAR (&buffer_local_flags
, extra_line_spacing
), idx
); ++idx
;
5182 XSETFASTINT (BVAR (&buffer_local_flags
, cursor_in_non_selected_windows
), idx
); ++idx
;
5184 /* Need more room? */
5185 if (idx
>= MAX_PER_BUFFER_VARS
)
5187 last_per_buffer_idx
= idx
;
5189 Vbuffer_alist
= Qnil
;
5193 QSFundamental
= build_pure_c_string ("Fundamental");
5195 DEFSYM (Qfundamental_mode
, "fundamental-mode");
5196 bset_major_mode (&buffer_defaults
, Qfundamental_mode
);
5198 DEFSYM (Qmode_class
, "mode-class");
5199 DEFSYM (Qprotected_field
, "protected-field");
5201 DEFSYM (Qpermanent_local
, "permanent-local");
5202 DEFSYM (Qkill_buffer_hook
, "kill-buffer-hook");
5203 Fput (Qkill_buffer_hook
, Qpermanent_local
, Qt
);
5205 /* super-magic invisible buffer */
5206 Vprin1_to_string_buffer
= Fget_buffer_create (build_pure_c_string (" prin1"));
5207 Vbuffer_alist
= Qnil
;
5209 Fset_buffer (Fget_buffer_create (build_pure_c_string ("*scratch*")));
5211 inhibit_modification_hooks
= 0;
5215 init_buffer (int initialized
)
5221 #ifdef USE_MMAP_FOR_BUFFERS
5227 /* These must be reset in the dumped Emacs, to avoid stale
5228 references to mmap'ed memory from before the dump.
5230 WINDOWSNT doesn't need this because it doesn't track mmap'ed
5231 regions by hand (see w32heap.c, which uses system APIs for
5232 that purpose), and thus doesn't use mmap_regions. */
5233 mmap_regions
= NULL
;
5237 /* The dumped buffers reference addresses of buffer text
5238 recorded by temacs, that cannot be used by the dumped Emacs.
5239 We map new memory for their text here.
5241 Implementation note: the buffers we carry from temacs are:
5242 " prin1", "*scratch*", " *Minibuf-0*", "*Messages*", and
5243 " *code-conversion-work*". They are created by
5244 init_buffer_once and init_window_once (which are not called
5245 in the dumped Emacs), and by the first call to coding.c routines. */
5248 b
->text
->beg
= NULL
;
5249 enlarge_buffer_text (b
, 0);
5256 /* Only buffers with allocated buffer text should be present at
5257 this point in temacs. */
5260 eassert (b
->text
->beg
!= NULL
);
5263 #else /* not USE_MMAP_FOR_BUFFERS */
5264 /* Avoid compiler warnings. */
5266 #endif /* USE_MMAP_FOR_BUFFERS */
5268 AUTO_STRING (scratch
, "*scratch*");
5269 Fset_buffer (Fget_buffer_create (scratch
));
5270 if (NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
)))
5271 Fset_buffer_multibyte (Qnil
);
5273 pwd
= get_current_dir_name ();
5276 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5278 /* Maybe this should really use some standard subroutine
5279 whose definition is filename syntax dependent. */
5281 if (!(IS_DIRECTORY_SEP (pwd
[len
- 1])))
5283 /* Grow buffer to add directory separator and '\0'. */
5284 pwd
= realloc (pwd
, len
+ 2);
5286 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5287 pwd
[len
] = DIRECTORY_SEP
;
5288 pwd
[len
+ 1] = '\0';
5292 /* At this moment, we still don't know how to decode the directory
5293 name. So, we keep the bytes in unibyte form so that file I/O
5294 routines correctly get the original bytes. */
5295 bset_directory (current_buffer
, make_unibyte_string (pwd
, len
));
5297 /* Add /: to the front of the name
5298 if it would otherwise be treated as magic. */
5299 temp
= Ffind_file_name_handler (BVAR (current_buffer
, directory
), Qt
);
5301 /* If the default dir is just /, TEMP is non-nil
5302 because of the ange-ftp completion handler.
5303 However, it is not necessary to turn / into /:/.
5304 So avoid doing that. */
5305 && strcmp ("/", SSDATA (BVAR (current_buffer
, directory
))))
5307 AUTO_STRING (slash_colon
, "/:");
5308 bset_directory (current_buffer
,
5309 concat2 (slash_colon
,
5310 BVAR (current_buffer
, directory
)));
5313 temp
= get_minibuffer (0);
5314 bset_directory (XBUFFER (temp
), BVAR (current_buffer
, directory
));
5319 /* Similar to defvar_lisp but define a variable whose value is the
5320 Lisp_Object stored in the current buffer. LNAME is the Lisp-level
5321 variable name. VNAME is the name of the buffer slot. PREDICATE
5322 is nil for a general Lisp variable. If PREDICATE is non-nil, then
5323 only Lisp values that satisfies the PREDICATE are allowed (except
5324 that nil is allowed too). DOC is a dummy where you write the doc
5325 string as a comment. */
5327 #define DEFVAR_PER_BUFFER(lname, vname, predicate, doc) \
5329 static struct Lisp_Buffer_Objfwd bo_fwd; \
5330 defvar_per_buffer (&bo_fwd, lname, vname, predicate); \
5334 defvar_per_buffer (struct Lisp_Buffer_Objfwd
*bo_fwd
, const char *namestring
,
5335 Lisp_Object
*address
, Lisp_Object predicate
)
5337 struct Lisp_Symbol
*sym
;
5340 sym
= XSYMBOL (intern (namestring
));
5341 offset
= (char *)address
- (char *)current_buffer
;
5343 bo_fwd
->type
= Lisp_Fwd_Buffer_Obj
;
5344 bo_fwd
->offset
= offset
;
5345 bo_fwd
->predicate
= predicate
;
5346 sym
->declared_special
= 1;
5347 sym
->redirect
= SYMBOL_FORWARDED
;
5348 SET_SYMBOL_FWD (sym
, (union Lisp_Fwd
*) bo_fwd
);
5349 XSETSYMBOL (PER_BUFFER_SYMBOL (offset
), sym
);
5351 if (PER_BUFFER_IDX (offset
) == 0)
5352 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
5353 slot of buffer_local_flags. */
5358 /* Initialize the buffer routines. */
5360 syms_of_buffer (void)
5362 staticpro (&last_overlay_modification_hooks
);
5363 last_overlay_modification_hooks
5364 = Fmake_vector (make_number (10), Qnil
);
5366 staticpro (&QSFundamental
);
5367 staticpro (&Vbuffer_alist
);
5369 DEFSYM (Qchoice
, "choice");
5370 DEFSYM (Qleft
, "left");
5371 DEFSYM (Qright
, "right");
5372 DEFSYM (Qrange
, "range");
5374 DEFSYM (Qpermanent_local_hook
, "permanent-local-hook");
5375 DEFSYM (Qoverlayp
, "overlayp");
5376 DEFSYM (Qevaporate
, "evaporate");
5377 DEFSYM (Qmodification_hooks
, "modification-hooks");
5378 DEFSYM (Qinsert_in_front_hooks
, "insert-in-front-hooks");
5379 DEFSYM (Qinsert_behind_hooks
, "insert-behind-hooks");
5380 DEFSYM (Qget_file_buffer
, "get-file-buffer");
5381 DEFSYM (Qpriority
, "priority");
5382 DEFSYM (Qbefore_string
, "before-string");
5383 DEFSYM (Qafter_string
, "after-string");
5384 DEFSYM (Qfirst_change_hook
, "first-change-hook");
5385 DEFSYM (Qbefore_change_functions
, "before-change-functions");
5386 DEFSYM (Qafter_change_functions
, "after-change-functions");
5387 DEFSYM (Qkill_buffer_query_functions
, "kill-buffer-query-functions");
5389 DEFSYM (Qvertical_scroll_bar
, "vertical-scroll-bar");
5390 Fput (Qvertical_scroll_bar
, Qchoice
, list4 (Qnil
, Qt
, Qleft
, Qright
));
5391 DEFSYM (Qhorizontal_scroll_bar
, "horizontal-scroll-bar");
5393 DEFSYM (Qfraction
, "fraction");
5394 Fput (Qfraction
, Qrange
, Fcons (make_float (0.0), make_float (1.0)));
5396 DEFSYM (Qoverwrite_mode
, "overwrite-mode");
5397 Fput (Qoverwrite_mode
, Qchoice
,
5398 list3 (Qnil
, intern ("overwrite-mode-textual"),
5399 intern ("overwrite-mode-binary")));
5401 Fput (Qprotected_field
, Qerror_conditions
,
5402 listn (CONSTYPE_PURE
, 2, Qprotected_field
, Qerror
));
5403 Fput (Qprotected_field
, Qerror_message
,
5404 build_pure_c_string ("Attempt to modify a protected field"));
5406 DEFVAR_BUFFER_DEFAULTS ("default-mode-line-format",
5408 doc
: /* Default value of `mode-line-format' for buffers that don't override it.
5409 This is the same as (default-value 'mode-line-format). */);
5411 DEFVAR_BUFFER_DEFAULTS ("default-header-line-format",
5413 doc
: /* Default value of `header-line-format' for buffers that don't override it.
5414 This is the same as (default-value 'header-line-format). */);
5416 DEFVAR_BUFFER_DEFAULTS ("default-cursor-type", cursor_type
,
5417 doc
: /* Default value of `cursor-type' for buffers that don't override it.
5418 This is the same as (default-value 'cursor-type). */);
5420 DEFVAR_BUFFER_DEFAULTS ("default-line-spacing",
5422 doc
: /* Default value of `line-spacing' for buffers that don't override it.
5423 This is the same as (default-value 'line-spacing). */);
5425 DEFVAR_BUFFER_DEFAULTS ("default-cursor-in-non-selected-windows",
5426 cursor_in_non_selected_windows
,
5427 doc
: /* Default value of `cursor-in-non-selected-windows'.
5428 This is the same as (default-value 'cursor-in-non-selected-windows). */);
5430 DEFVAR_BUFFER_DEFAULTS ("default-abbrev-mode",
5432 doc
: /* Default value of `abbrev-mode' for buffers that do not override it.
5433 This is the same as (default-value 'abbrev-mode). */);
5435 DEFVAR_BUFFER_DEFAULTS ("default-ctl-arrow",
5437 doc
: /* Default value of `ctl-arrow' for buffers that do not override it.
5438 This is the same as (default-value 'ctl-arrow). */);
5440 DEFVAR_BUFFER_DEFAULTS ("default-enable-multibyte-characters",
5441 enable_multibyte_characters
,
5442 doc
: /* Default value of `enable-multibyte-characters' for buffers not overriding it.
5443 This is the same as (default-value 'enable-multibyte-characters). */);
5445 DEFVAR_BUFFER_DEFAULTS ("default-buffer-file-coding-system",
5446 buffer_file_coding_system
,
5447 doc
: /* Default value of `buffer-file-coding-system' for buffers not overriding it.
5448 This is the same as (default-value 'buffer-file-coding-system). */);
5450 DEFVAR_BUFFER_DEFAULTS ("default-truncate-lines",
5452 doc
: /* Default value of `truncate-lines' for buffers that do not override it.
5453 This is the same as (default-value 'truncate-lines). */);
5455 DEFVAR_BUFFER_DEFAULTS ("default-fill-column",
5457 doc
: /* Default value of `fill-column' for buffers that do not override it.
5458 This is the same as (default-value 'fill-column). */);
5460 DEFVAR_BUFFER_DEFAULTS ("default-left-margin",
5462 doc
: /* Default value of `left-margin' for buffers that do not override it.
5463 This is the same as (default-value 'left-margin). */);
5465 DEFVAR_BUFFER_DEFAULTS ("default-tab-width",
5467 doc
: /* Default value of `tab-width' for buffers that do not override it.
5468 NOTE: This controls the display width of a TAB character, and not
5469 the size of an indentation step.
5470 This is the same as (default-value 'tab-width). */);
5472 DEFVAR_BUFFER_DEFAULTS ("default-case-fold-search",
5474 doc
: /* Default value of `case-fold-search' for buffers that don't override it.
5475 This is the same as (default-value 'case-fold-search). */);
5477 DEFVAR_BUFFER_DEFAULTS ("default-left-margin-width",
5479 doc
: /* Default value of `left-margin-width' for buffers that don't override it.
5480 This is the same as (default-value 'left-margin-width). */);
5482 DEFVAR_BUFFER_DEFAULTS ("default-right-margin-width",
5484 doc
: /* Default value of `right-margin-width' for buffers that don't override it.
5485 This is the same as (default-value 'right-margin-width). */);
5487 DEFVAR_BUFFER_DEFAULTS ("default-left-fringe-width",
5489 doc
: /* Default value of `left-fringe-width' for buffers that don't override it.
5490 This is the same as (default-value 'left-fringe-width). */);
5492 DEFVAR_BUFFER_DEFAULTS ("default-right-fringe-width",
5494 doc
: /* Default value of `right-fringe-width' for buffers that don't override it.
5495 This is the same as (default-value 'right-fringe-width). */);
5497 DEFVAR_BUFFER_DEFAULTS ("default-fringes-outside-margins",
5498 fringes_outside_margins
,
5499 doc
: /* Default value of `fringes-outside-margins' for buffers that don't override it.
5500 This is the same as (default-value 'fringes-outside-margins). */);
5502 DEFVAR_BUFFER_DEFAULTS ("default-scroll-bar-width",
5504 doc
: /* Default value of `scroll-bar-width' for buffers that don't override it.
5505 This is the same as (default-value 'scroll-bar-width). */);
5507 DEFVAR_BUFFER_DEFAULTS ("default-vertical-scroll-bar",
5508 vertical_scroll_bar_type
,
5509 doc
: /* Default value of `vertical-scroll-bar' for buffers that don't override it.
5510 This is the same as (default-value 'vertical-scroll-bar). */);
5512 DEFVAR_BUFFER_DEFAULTS ("default-indicate-empty-lines",
5513 indicate_empty_lines
,
5514 doc
: /* Default value of `indicate-empty-lines' for buffers that don't override it.
5515 This is the same as (default-value 'indicate-empty-lines). */);
5517 DEFVAR_BUFFER_DEFAULTS ("default-indicate-buffer-boundaries",
5518 indicate_buffer_boundaries
,
5519 doc
: /* Default value of `indicate-buffer-boundaries' for buffers that don't override it.
5520 This is the same as (default-value 'indicate-buffer-boundaries). */);
5522 DEFVAR_BUFFER_DEFAULTS ("default-fringe-indicator-alist",
5523 fringe_indicator_alist
,
5524 doc
: /* Default value of `fringe-indicator-alist' for buffers that don't override it.
5525 This is the same as (default-value 'fringe-indicator-alist'). */);
5527 DEFVAR_BUFFER_DEFAULTS ("default-fringe-cursor-alist",
5528 fringe_cursor_alist
,
5529 doc
: /* Default value of `fringe-cursor-alist' for buffers that don't override it.
5530 This is the same as (default-value 'fringe-cursor-alist'). */);
5532 DEFVAR_BUFFER_DEFAULTS ("default-scroll-up-aggressively",
5533 scroll_up_aggressively
,
5534 doc
: /* Default value of `scroll-up-aggressively'.
5535 This value applies in buffers that don't have their own local values.
5536 This is the same as (default-value 'scroll-up-aggressively). */);
5538 DEFVAR_BUFFER_DEFAULTS ("default-scroll-down-aggressively",
5539 scroll_down_aggressively
,
5540 doc
: /* Default value of `scroll-down-aggressively'.
5541 This value applies in buffers that don't have their own local values.
5542 This is the same as (default-value 'scroll-down-aggressively). */);
5544 DEFVAR_PER_BUFFER ("header-line-format",
5545 &BVAR (current_buffer
, header_line_format
),
5547 doc
: /* Analogous to `mode-line-format', but controls the header line.
5548 The header line appears, optionally, at the top of a window;
5549 the mode line appears at the bottom. */);
5551 DEFVAR_PER_BUFFER ("mode-line-format", &BVAR (current_buffer
, mode_line_format
),
5553 doc
: /* Template for displaying mode line for current buffer.
5555 The value may be nil, a string, a symbol or a list.
5557 A value of nil means don't display a mode line.
5559 For any symbol other than t or nil, the symbol's value is processed as
5560 a mode line construct. As a special exception, if that value is a
5561 string, the string is processed verbatim, without handling any
5562 %-constructs (see below). Also, unless the symbol has a non-nil
5563 `risky-local-variable' property, all properties in any strings, as
5564 well as all :eval and :propertize forms in the value, are ignored.
5566 A list whose car is a string or list is processed by processing each
5567 of the list elements recursively, as separate mode line constructs,
5568 and concatenating the results.
5570 A list of the form `(:eval FORM)' is processed by evaluating FORM and
5571 using the result as a mode line construct. Be careful--FORM should
5572 not load any files, because that can cause an infinite recursion.
5574 A list of the form `(:propertize ELT PROPS...)' is processed by
5575 processing ELT as the mode line construct, and adding the text
5576 properties PROPS to the result.
5578 A list whose car is a symbol is processed by examining the symbol's
5579 value, and, if that value is non-nil, processing the cadr of the list
5580 recursively; and if that value is nil, processing the caddr of the
5583 A list whose car is an integer is processed by processing the cadr of
5584 the list, and padding (if the number is positive) or truncating (if
5585 negative) to the width specified by that number.
5587 A string is printed verbatim in the mode line except for %-constructs:
5588 %b -- print buffer name. %f -- print visited file name.
5589 %F -- print frame name.
5590 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
5591 %& is like %*, but ignore read-only-ness.
5592 % means buffer is read-only and * means it is modified.
5593 For a modified read-only buffer, %* gives % and %+ gives *.
5594 %s -- print process status. %l -- print the current line number.
5595 %c -- print the current column number (this makes editing slower).
5596 To make the column number update correctly in all cases,
5597 `column-number-mode' must be non-nil.
5598 %i -- print the size of the buffer.
5599 %I -- like %i, but use k, M, G, etc., to abbreviate.
5600 %p -- print percent of buffer above top of window, or Top, Bot or All.
5601 %P -- print percent of buffer above bottom of window, perhaps plus Top,
5602 or print Bottom or All.
5603 %n -- print Narrow if appropriate.
5604 %t -- visited file is text or binary (if OS supports this distinction).
5605 %z -- print mnemonics of keyboard, terminal, and buffer coding systems.
5606 %Z -- like %z, but including the end-of-line format.
5607 %e -- print error message about full memory.
5608 %@ -- print @ or hyphen. @ means that default-directory is on a
5610 %[ -- print one [ for each recursive editing level. %] similar.
5611 %% -- print %. %- -- print infinitely many dashes.
5612 Decimal digits after the % specify field width to which to pad. */);
5614 DEFVAR_BUFFER_DEFAULTS ("default-major-mode", major_mode
,
5615 doc
: /* Value of `major-mode' for new buffers. */);
5617 DEFVAR_PER_BUFFER ("major-mode", &BVAR (current_buffer
, major_mode
),
5619 doc
: /* Symbol for current buffer's major mode.
5620 The default value (normally `fundamental-mode') affects new buffers.
5621 A value of nil means to use the current buffer's major mode, provided
5622 it is not marked as "special".
5624 When a mode is used by default, `find-file' switches to it before it
5625 reads the contents into the buffer and before it finishes setting up
5626 the buffer. Thus, the mode and its hooks should not expect certain
5627 variables such as `buffer-read-only' and `buffer-file-coding-system'
5630 DEFVAR_PER_BUFFER ("mode-name", &BVAR (current_buffer
, mode_name
),
5632 doc
: /* Pretty name of current buffer's major mode.
5633 Usually a string, but can use any of the constructs for `mode-line-format',
5635 Format with `format-mode-line' to produce a string value. */);
5637 DEFVAR_PER_BUFFER ("local-abbrev-table", &BVAR (current_buffer
, abbrev_table
), Qnil
,
5638 doc
: /* Local (mode-specific) abbrev table of current buffer. */);
5640 DEFVAR_PER_BUFFER ("abbrev-mode", &BVAR (current_buffer
, abbrev_mode
), Qnil
,
5641 doc
: /* Non-nil if Abbrev mode is enabled.
5642 Use the command `abbrev-mode' to change this variable. */);
5644 DEFVAR_PER_BUFFER ("case-fold-search", &BVAR (current_buffer
, case_fold_search
),
5646 doc
: /* Non-nil if searches and matches should ignore case. */);
5648 DEFVAR_PER_BUFFER ("fill-column", &BVAR (current_buffer
, fill_column
),
5650 doc
: /* Column beyond which automatic line-wrapping should happen.
5651 Interactively, you can set the buffer local value using \\[set-fill-column]. */);
5653 DEFVAR_PER_BUFFER ("left-margin", &BVAR (current_buffer
, left_margin
),
5655 doc
: /* Column for the default `indent-line-function' to indent to.
5656 Linefeed indents to this column in Fundamental mode. */);
5658 DEFVAR_PER_BUFFER ("tab-width", &BVAR (current_buffer
, tab_width
),
5660 doc
: /* Distance between tab stops (for display of tab characters), in columns.
5661 NOTE: This controls the display width of a TAB character, and not
5662 the size of an indentation step.
5663 This should be an integer greater than zero. */);
5665 DEFVAR_PER_BUFFER ("ctl-arrow", &BVAR (current_buffer
, ctl_arrow
), Qnil
,
5666 doc
: /* Non-nil means display control chars with uparrow.
5667 A value of nil means use backslash and octal digits.
5668 This variable does not apply to characters whose display is specified
5669 in the current display table (if there is one). */);
5671 DEFVAR_PER_BUFFER ("enable-multibyte-characters",
5672 &BVAR (current_buffer
, enable_multibyte_characters
),
5674 doc
: /* Non-nil means the buffer contents are regarded as multi-byte characters.
5675 Otherwise they are regarded as unibyte. This affects the display,
5676 file I/O and the behavior of various editing commands.
5678 This variable is buffer-local but you cannot set it directly;
5679 use the function `set-buffer-multibyte' to change a buffer's representation.
5680 See also Info node `(elisp)Text Representations'. */);
5681 XSYMBOL (intern_c_string ("enable-multibyte-characters"))->constant
= 1;
5683 DEFVAR_PER_BUFFER ("buffer-file-coding-system",
5684 &BVAR (current_buffer
, buffer_file_coding_system
), Qnil
,
5685 doc
: /* Coding system to be used for encoding the buffer contents on saving.
5686 This variable applies to saving the buffer, and also to `write-region'
5687 and other functions that use `write-region'.
5688 It does not apply to sending output to subprocesses, however.
5690 If this is nil, the buffer is saved without any code conversion
5691 unless some coding system is specified in `file-coding-system-alist'
5692 for the buffer file.
5694 If the text to be saved cannot be encoded as specified by this variable,
5695 an alternative encoding is selected by `select-safe-coding-system', which see.
5697 The variable `coding-system-for-write', if non-nil, overrides this variable.
5699 This variable is never applied to a way of decoding a file while reading it. */);
5701 DEFVAR_PER_BUFFER ("bidi-display-reordering",
5702 &BVAR (current_buffer
, bidi_display_reordering
), Qnil
,
5703 doc
: /* Non-nil means reorder bidirectional text for display in the visual order. */);
5705 DEFVAR_PER_BUFFER ("bidi-paragraph-direction",
5706 &BVAR (current_buffer
, bidi_paragraph_direction
), Qnil
,
5707 doc
: /* If non-nil, forces directionality of text paragraphs in the buffer.
5709 If this is nil (the default), the direction of each paragraph is
5710 determined by the first strong directional character of its text.
5711 The values of `right-to-left' and `left-to-right' override that.
5712 Any other value is treated as nil.
5714 This variable has no effect unless the buffer's value of
5715 \`bidi-display-reordering' is non-nil. */);
5717 DEFVAR_PER_BUFFER ("truncate-lines", &BVAR (current_buffer
, truncate_lines
), Qnil
,
5718 doc
: /* Non-nil means do not display continuation lines.
5719 Instead, give each line of text just one screen line.
5721 Note that this is overridden by the variable
5722 `truncate-partial-width-windows' if that variable is non-nil
5723 and this buffer is not full-frame width.
5725 Minibuffers set this variable to nil. */);
5727 DEFVAR_PER_BUFFER ("word-wrap", &BVAR (current_buffer
, word_wrap
), Qnil
,
5728 doc
: /* Non-nil means to use word-wrapping for continuation lines.
5729 When word-wrapping is on, continuation lines are wrapped at the space
5730 or tab character nearest to the right window edge.
5731 If nil, continuation lines are wrapped at the right screen edge.
5733 This variable has no effect if long lines are truncated (see
5734 `truncate-lines' and `truncate-partial-width-windows'). If you use
5735 word-wrapping, you might want to reduce the value of
5736 `truncate-partial-width-windows', since wrapping can make text readable
5737 in narrower windows.
5739 Instead of setting this variable directly, most users should use
5740 Visual Line mode . Visual Line mode, when enabled, sets `word-wrap'
5741 to t, and additionally redefines simple editing commands to act on
5742 visual lines rather than logical lines. See the documentation of
5743 `visual-line-mode'. */);
5745 DEFVAR_PER_BUFFER ("default-directory", &BVAR (current_buffer
, directory
),
5747 doc
: /* Name of default directory of current buffer. Should end with slash.
5748 To interactively change the default directory, use command `cd'. */);
5750 DEFVAR_PER_BUFFER ("auto-fill-function", &BVAR (current_buffer
, auto_fill_function
),
5752 doc
: /* Function called (if non-nil) to perform auto-fill.
5753 It is called after self-inserting any character specified in
5754 the `auto-fill-chars' table.
5755 NOTE: This variable is not a hook;
5756 its value may not be a list of functions. */);
5758 DEFVAR_PER_BUFFER ("buffer-file-name", &BVAR (current_buffer
, filename
),
5760 doc
: /* Name of file visited in current buffer, or nil if not visiting a file.
5761 This should be an absolute file name. */);
5763 DEFVAR_PER_BUFFER ("buffer-file-truename", &BVAR (current_buffer
, file_truename
),
5765 doc
: /* Abbreviated truename of file visited in current buffer, or nil if none.
5766 The truename of a file is calculated by `file-truename'
5767 and then abbreviated with `abbreviate-file-name'. */);
5769 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
5770 &BVAR (current_buffer
, auto_save_file_name
),
5772 doc
: /* Name of file for auto-saving current buffer.
5773 If it is nil, that means don't auto-save this buffer. */);
5775 DEFVAR_PER_BUFFER ("buffer-read-only", &BVAR (current_buffer
, read_only
), Qnil
,
5776 doc
: /* Non-nil if this buffer is read-only. */);
5778 DEFVAR_PER_BUFFER ("buffer-backed-up", &BVAR (current_buffer
, backed_up
), Qnil
,
5779 doc
: /* Non-nil if this buffer's file has been backed up.
5780 Backing up is done before the first time the file is saved. */);
5782 DEFVAR_PER_BUFFER ("buffer-saved-size", &BVAR (current_buffer
, save_length
),
5784 doc
: /* Length of current buffer when last read in, saved or auto-saved.
5786 -1 means auto-saving turned off until next real save.
5788 If you set this to -2, that means don't turn off auto-saving in this buffer
5789 if its text size shrinks. If you use `buffer-swap-text' on a buffer,
5790 you probably should set this to -2 in that buffer. */);
5792 DEFVAR_PER_BUFFER ("selective-display", &BVAR (current_buffer
, selective_display
),
5794 doc
: /* Non-nil enables selective display.
5795 An integer N as value means display only lines
5796 that start with less than N columns of space.
5797 A value of t means that the character ^M makes itself and
5798 all the rest of the line invisible; also, when saving the buffer
5799 in a file, save the ^M as a newline. */);
5801 DEFVAR_PER_BUFFER ("selective-display-ellipses",
5802 &BVAR (current_buffer
, selective_display_ellipses
),
5804 doc
: /* Non-nil means display ... on previous line when a line is invisible. */);
5806 DEFVAR_PER_BUFFER ("overwrite-mode", &BVAR (current_buffer
, overwrite_mode
),
5808 doc
: /* Non-nil if self-insertion should replace existing text.
5809 The value should be one of `overwrite-mode-textual',
5810 `overwrite-mode-binary', or nil.
5811 If it is `overwrite-mode-textual', self-insertion still
5812 inserts at the end of a line, and inserts when point is before a tab,
5813 until the tab is filled in.
5814 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too. */);
5816 DEFVAR_PER_BUFFER ("buffer-display-table", &BVAR (current_buffer
, display_table
),
5818 doc
: /* Display table that controls display of the contents of current buffer.
5820 If this variable is nil, the value of `standard-display-table' is used.
5821 Each window can have its own, overriding display table, see
5822 `set-window-display-table' and `window-display-table'.
5824 The display table is a char-table created with `make-display-table'.
5825 A char-table is an array indexed by character codes. Normal array
5826 primitives `aref' and `aset' can be used to access elements of a char-table.
5828 Each of the char-table elements control how to display the corresponding
5829 text character: the element at index C in the table says how to display
5830 the character whose code is C. Each element should be a vector of
5831 characters or nil. The value nil means display the character in the
5832 default fashion; otherwise, the characters from the vector are delivered
5833 to the screen instead of the original character.
5835 For example, (aset buffer-display-table ?X [?Y]) tells Emacs
5836 to display a capital Y instead of each X character.
5838 In addition, a char-table has six extra slots to control the display of:
5840 the end of a truncated screen line (extra-slot 0, a single character);
5841 the end of a continued line (extra-slot 1, a single character);
5842 the escape character used to display character codes in octal
5843 (extra-slot 2, a single character);
5844 the character used as an arrow for control characters (extra-slot 3,
5845 a single character);
5846 the decoration indicating the presence of invisible lines (extra-slot 4,
5847 a vector of characters);
5848 the character used to draw the border between side-by-side windows
5849 (extra-slot 5, a single character).
5851 See also the functions `display-table-slot' and `set-display-table-slot'. */);
5853 DEFVAR_PER_BUFFER ("left-margin-width", &BVAR (current_buffer
, left_margin_cols
),
5855 doc
: /* Width in columns of left marginal area for display of a buffer.
5856 A value of nil means no marginal area.
5858 Setting this variable does not take effect until a new buffer is displayed
5859 in a window. To make the change take effect, call `set-window-buffer'. */);
5861 DEFVAR_PER_BUFFER ("right-margin-width", &BVAR (current_buffer
, right_margin_cols
),
5863 doc
: /* Width in columns of right marginal area for display of a buffer.
5864 A value of nil means no marginal area.
5866 Setting this variable does not take effect until a new buffer is displayed
5867 in a window. To make the change take effect, call `set-window-buffer'. */);
5869 DEFVAR_PER_BUFFER ("left-fringe-width", &BVAR (current_buffer
, left_fringe_width
),
5871 doc
: /* Width of this buffer's left fringe (in pixels).
5872 A value of 0 means no left fringe is shown in this buffer's window.
5873 A value of nil means to use the left fringe width from the window's frame.
5875 Setting this variable does not take effect until a new buffer is displayed
5876 in a window. To make the change take effect, call `set-window-buffer'. */);
5878 DEFVAR_PER_BUFFER ("right-fringe-width", &BVAR (current_buffer
, right_fringe_width
),
5880 doc
: /* Width of this buffer's right fringe (in pixels).
5881 A value of 0 means no right fringe is shown in this buffer's window.
5882 A value of nil means to use the right fringe width from the window's frame.
5884 Setting this variable does not take effect until a new buffer is displayed
5885 in a window. To make the change take effect, call `set-window-buffer'. */);
5887 DEFVAR_PER_BUFFER ("fringes-outside-margins", &BVAR (current_buffer
, fringes_outside_margins
),
5889 doc
: /* Non-nil means to display fringes outside display margins.
5890 A value of nil means to display fringes between margins and buffer text.
5892 Setting this variable does not take effect until a new buffer is displayed
5893 in a window. To make the change take effect, call `set-window-buffer'. */);
5895 DEFVAR_PER_BUFFER ("scroll-bar-width", &BVAR (current_buffer
, scroll_bar_width
),
5897 doc
: /* Width of this buffer's vertical scroll bars in pixels.
5898 A value of nil means to use the scroll bar width from the window's frame. */);
5900 DEFVAR_PER_BUFFER ("scroll-bar-height", &BVAR (current_buffer
, scroll_bar_height
),
5902 doc
: /* Height of this buffer's horizontal scroll bars in pixels.
5903 A value of nil means to use the scroll bar height from the window's frame. */);
5905 DEFVAR_PER_BUFFER ("vertical-scroll-bar", &BVAR (current_buffer
, vertical_scroll_bar_type
),
5906 Qvertical_scroll_bar
,
5907 doc
: /* Position of this buffer's vertical scroll bar.
5908 The value takes effect whenever you tell a window to display this buffer;
5909 for instance, with `set-window-buffer' or when `display-buffer' displays it.
5911 A value of `left' or `right' means put the vertical scroll bar at that side
5912 of the window; a value of nil means don't show any vertical scroll bars.
5913 A value of t (the default) means do whatever the window's frame specifies. */);
5915 DEFVAR_PER_BUFFER ("horizontal-scroll-bar", &BVAR (current_buffer
, horizontal_scroll_bar_type
),
5917 doc
: /* Position of this buffer's horizontal scroll bar.
5918 The value takes effect whenever you tell a window to display this buffer;
5919 for instance, with `set-window-buffer' or when `display-buffer' displays it.
5921 A value of `bottom' means put the horizontal scroll bar at the bottom of
5922 the window; a value of nil means don't show any horizontal scroll bars.
5923 A value of t (the default) means do whatever the window's frame
5926 DEFVAR_PER_BUFFER ("indicate-empty-lines",
5927 &BVAR (current_buffer
, indicate_empty_lines
), Qnil
,
5928 doc
: /* Visually indicate empty lines after the buffer end.
5929 If non-nil, a bitmap is displayed in the left fringe of a window on
5930 window-systems. */);
5932 DEFVAR_PER_BUFFER ("indicate-buffer-boundaries",
5933 &BVAR (current_buffer
, indicate_buffer_boundaries
), Qnil
,
5934 doc
: /* Visually indicate buffer boundaries and scrolling.
5935 If non-nil, the first and last line of the buffer are marked in the fringe
5936 of a window on window-systems with angle bitmaps, or if the window can be
5937 scrolled, the top and bottom line of the window are marked with up and down
5940 If value is a symbol `left' or `right', both angle and arrow bitmaps
5941 are displayed in the left or right fringe, resp. Any other value
5942 that doesn't look like an alist means display the angle bitmaps in
5943 the left fringe but no arrows.
5945 You can exercise more precise control by using an alist as the
5946 value. Each alist element (INDICATOR . POSITION) specifies
5947 where to show one of the indicators. INDICATOR is one of `top',
5948 `bottom', `up', `down', or t, which specifies the default position,
5949 and POSITION is one of `left', `right', or nil, meaning do not show
5952 For example, ((top . left) (t . right)) places the top angle bitmap in
5953 left fringe, the bottom angle bitmap in right fringe, and both arrow
5954 bitmaps in right fringe. To show just the angle bitmaps in the left
5955 fringe, but no arrow bitmaps, use ((top . left) (bottom . left)). */);
5957 DEFVAR_PER_BUFFER ("fringe-indicator-alist",
5958 &BVAR (current_buffer
, fringe_indicator_alist
), Qnil
,
5959 doc
: /* Mapping from logical to physical fringe indicator bitmaps.
5960 The value is an alist where each element (INDICATOR . BITMAPS)
5961 specifies the fringe bitmaps used to display a specific logical
5964 INDICATOR specifies the logical indicator type which is one of the
5965 following symbols: `truncation' , `continuation', `overlay-arrow',
5966 `top', `bottom', `top-bottom', `up', `down', empty-line', or `unknown'.
5968 BITMAPS is a list of symbols (LEFT RIGHT [LEFT1 RIGHT1]) which specifies
5969 the actual bitmap shown in the left or right fringe for the logical
5970 indicator. LEFT and RIGHT are the bitmaps shown in the left and/or
5971 right fringe for the specific indicator. The LEFT1 or RIGHT1 bitmaps
5972 are used only for the `bottom' and `top-bottom' indicators when the
5973 last (only) line has no final newline. BITMAPS may also be a single
5974 symbol which is used in both left and right fringes. */);
5976 DEFVAR_PER_BUFFER ("fringe-cursor-alist",
5977 &BVAR (current_buffer
, fringe_cursor_alist
), Qnil
,
5978 doc
: /* Mapping from logical to physical fringe cursor bitmaps.
5979 The value is an alist where each element (CURSOR . BITMAP)
5980 specifies the fringe bitmaps used to display a specific logical
5981 cursor type in the fringe.
5983 CURSOR specifies the logical cursor type which is one of the following
5984 symbols: `box' , `hollow', `bar', `hbar', or `hollow-small'. The last
5985 one is used to show a hollow cursor on narrow lines display lines
5986 where the normal hollow cursor will not fit.
5988 BITMAP is the corresponding fringe bitmap shown for the logical
5991 DEFVAR_PER_BUFFER ("scroll-up-aggressively",
5992 &BVAR (current_buffer
, scroll_up_aggressively
), Qfraction
,
5993 doc
: /* How far to scroll windows upward.
5994 If you move point off the bottom, the window scrolls automatically.
5995 This variable controls how far it scrolls. The value nil, the default,
5996 means scroll to center point. A fraction means scroll to put point
5997 that fraction of the window's height from the bottom of the window.
5998 When the value is 0.0, point goes at the bottom line, which in the
5999 simple case that you moved off with C-f means scrolling just one line.
6000 1.0 means point goes at the top, so that in that simple case, the
6001 window scrolls by a full window height. Meaningful values are
6002 between 0.0 and 1.0, inclusive. */);
6004 DEFVAR_PER_BUFFER ("scroll-down-aggressively",
6005 &BVAR (current_buffer
, scroll_down_aggressively
), Qfraction
,
6006 doc
: /* How far to scroll windows downward.
6007 If you move point off the top, the window scrolls automatically.
6008 This variable controls how far it scrolls. The value nil, the default,
6009 means scroll to center point. A fraction means scroll to put point
6010 that fraction of the window's height from the top of the window.
6011 When the value is 0.0, point goes at the top line, which in the
6012 simple case that you moved off with C-b means scrolling just one line.
6013 1.0 means point goes at the bottom, so that in that simple case, the
6014 window scrolls by a full window height. Meaningful values are
6015 between 0.0 and 1.0, inclusive. */);
6017 DEFVAR_LISP ("before-change-functions", Vbefore_change_functions
,
6018 doc
: /* List of functions to call before each text change.
6019 Two arguments are passed to each function: the positions of
6020 the beginning and end of the range of old text to be changed.
6021 \(For an insertion, the beginning and end are at the same place.)
6022 No information is given about the length of the text after the change.
6024 Buffer changes made while executing the `before-change-functions'
6025 don't call any before-change or after-change functions.
6026 That's because `inhibit-modification-hooks' is temporarily set non-nil.
6028 If an unhandled error happens in running these functions,
6029 the variable's value remains nil. That prevents the error
6030 from happening repeatedly and making Emacs nonfunctional. */);
6031 Vbefore_change_functions
= Qnil
;
6033 DEFVAR_LISP ("after-change-functions", Vafter_change_functions
,
6034 doc
: /* List of functions to call after each text change.
6035 Three arguments are passed to each function: the positions of
6036 the beginning and end of the range of changed text,
6037 and the length in chars of the pre-change text replaced by that range.
6038 \(For an insertion, the pre-change length is zero;
6039 for a deletion, that length is the number of chars deleted,
6040 and the post-change beginning and end are at the same place.)
6042 Buffer changes made while executing the `after-change-functions'
6043 don't call any before-change or after-change functions.
6044 That's because `inhibit-modification-hooks' is temporarily set non-nil.
6046 If an unhandled error happens in running these functions,
6047 the variable's value remains nil. That prevents the error
6048 from happening repeatedly and making Emacs nonfunctional. */);
6049 Vafter_change_functions
= Qnil
;
6051 DEFVAR_LISP ("first-change-hook", Vfirst_change_hook
,
6052 doc
: /* A list of functions to call before changing a buffer which is unmodified.
6053 The functions are run using the `run-hooks' function. */);
6054 Vfirst_change_hook
= Qnil
;
6056 DEFVAR_PER_BUFFER ("buffer-undo-list", &BVAR (current_buffer
, undo_list
), Qnil
,
6057 doc
: /* List of undo entries in current buffer.
6058 Recent changes come first; older changes follow newer.
6060 An entry (BEG . END) represents an insertion which begins at
6061 position BEG and ends at position END.
6063 An entry (TEXT . POSITION) represents the deletion of the string TEXT
6064 from (abs POSITION). If POSITION is positive, point was at the front
6065 of the text being deleted; if negative, point was at the end.
6067 An entry (t HIGH LOW USEC PSEC) indicates that the buffer was previously
6068 unmodified; (HIGH LOW USEC PSEC) is in the same style as (current-time)
6069 and is the visited file's modification time, as of that time. If the
6070 modification time of the most recent save is different, this entry is
6073 An entry (t . 0) means means the buffer was previously unmodified but
6074 its time stamp was unknown because it was not associated with a file.
6075 An entry (t . -1) is similar, except that it means the buffer's visited
6078 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
6079 was modified between BEG and END. PROPERTY is the property name,
6080 and VALUE is the old value.
6082 An entry (apply FUN-NAME . ARGS) means undo the change with
6083 \(apply FUN-NAME ARGS).
6085 An entry (apply DELTA BEG END FUN-NAME . ARGS) supports selective undo
6086 in the active region. BEG and END is the range affected by this entry
6087 and DELTA is the number of characters added or deleted in that range by
6090 An entry (MARKER . DISTANCE) indicates that the marker MARKER
6091 was adjusted in position by the offset DISTANCE (an integer).
6093 An entry of the form POSITION indicates that point was at the buffer
6094 location given by the integer. Undoing an entry of this form places
6097 Entries with value `nil' mark undo boundaries. The undo command treats
6098 the changes between two undo boundaries as a single step to be undone.
6100 If the value of the variable is t, undo information is not recorded. */);
6102 DEFVAR_PER_BUFFER ("mark-active", &BVAR (current_buffer
, mark_active
), Qnil
,
6103 doc
: /* Non-nil means the mark and region are currently active in this buffer. */);
6105 DEFVAR_PER_BUFFER ("cache-long-scans", &BVAR (current_buffer
, cache_long_scans
), Qnil
,
6106 doc
: /* Non-nil means that Emacs should use caches in attempt to speedup buffer scans.
6108 There is no reason to set this to nil except for debugging purposes.
6110 Normally, the line-motion functions work by scanning the buffer for
6111 newlines. Columnar operations (like `move-to-column' and
6112 `compute-motion') also work by scanning the buffer, summing character
6113 widths as they go. This works well for ordinary text, but if the
6114 buffer's lines are very long (say, more than 500 characters), these
6115 motion functions will take longer to execute. Emacs may also take
6116 longer to update the display.
6118 If `cache-long-scans' is non-nil, these motion functions cache the
6119 results of their scans, and consult the cache to avoid rescanning
6120 regions of the buffer until the text is modified. The caches are most
6121 beneficial when they prevent the most searching---that is, when the
6122 buffer contains long lines and large regions of characters with the
6123 same, fixed screen width.
6125 When `cache-long-scans' is non-nil, processing short lines will
6126 become slightly slower (because of the overhead of consulting the
6127 cache), and the caches will use memory roughly proportional to the
6128 number of newlines and characters whose screen width varies.
6130 Bidirectional editing also requires buffer scans to find paragraph
6131 separators. If you have large paragraphs or no paragraph separators
6132 at all, these scans may be slow. If `cache-long-scans' is non-nil,
6133 results of these scans are cached. This doesn't help too much if
6134 paragraphs are of the reasonable (few thousands of characters) size.
6136 The caches require no explicit maintenance; their accuracy is
6137 maintained internally by the Emacs primitives. Enabling or disabling
6138 the cache should not affect the behavior of any of the motion
6139 functions; it should only affect their performance. */);
6141 DEFVAR_PER_BUFFER ("point-before-scroll", &BVAR (current_buffer
, point_before_scroll
), Qnil
,
6142 doc
: /* Value of point before the last series of scroll operations, or nil. */);
6144 DEFVAR_PER_BUFFER ("buffer-file-format", &BVAR (current_buffer
, file_format
), Qnil
,
6145 doc
: /* List of formats to use when saving this buffer.
6146 Formats are defined by `format-alist'. This variable is
6147 set when a file is visited. */);
6149 DEFVAR_PER_BUFFER ("buffer-auto-save-file-format",
6150 &BVAR (current_buffer
, auto_save_file_format
), Qnil
,
6151 doc
: /* Format in which to write auto-save files.
6152 Should be a list of symbols naming formats that are defined in `format-alist'.
6153 If it is t, which is the default, auto-save files are written in the
6154 same format as a regular save would use. */);
6156 DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
6157 &BVAR (current_buffer
, invisibility_spec
), Qnil
,
6158 doc
: /* Invisibility spec of this buffer.
6159 The default is t, which means that text is invisible if it has a non-nil
6160 `invisible' property.
6161 This variable can also be a list. The list can have two kinds of elements:
6162 `ATOM' and `(ATOM . ELLIPSIS)'. A text character is invisible if its
6163 `invisible' property is `ATOM', or has an `invisible' property that is a list
6164 that contains `ATOM'.
6165 If the `(ATOM . ELLIPSIS)' form is used, and `ELLIPSIS' is non-nil, an
6166 ellipsis will be displayed after the invisible characters.
6167 Setting this variable is very fast, much faster than scanning all the text in
6168 the buffer looking for properties to change. */);
6170 DEFVAR_PER_BUFFER ("buffer-display-count",
6171 &BVAR (current_buffer
, display_count
), Qintegerp
,
6172 doc
: /* A number incremented each time this buffer is displayed in a window.
6173 The function `set-window-buffer' increments it. */);
6175 DEFVAR_PER_BUFFER ("buffer-display-time",
6176 &BVAR (current_buffer
, display_time
), Qnil
,
6177 doc
: /* Time stamp updated each time this buffer is displayed in a window.
6178 The function `set-window-buffer' updates this variable
6179 to the value obtained by calling `current-time'.
6180 If the buffer has never been shown in a window, the value is nil. */);
6182 DEFVAR_LISP ("transient-mark-mode", Vtransient_mark_mode
,
6183 doc
: /* Non-nil if Transient Mark mode is enabled.
6184 See the command `transient-mark-mode' for a description of this minor mode.
6186 Non-nil also enables highlighting of the region whenever the mark is active.
6187 The variable `highlight-nonselected-windows' controls whether to highlight
6188 all windows or just the selected window.
6190 Lisp programs may give this variable certain special values:
6192 - A value of `lambda' enables Transient Mark mode temporarily.
6193 It is disabled again after any subsequent action that would
6194 normally deactivate the mark (e.g. buffer modification).
6196 - A value of (only . OLDVAL) enables Transient Mark mode
6197 temporarily. After any subsequent point motion command that is
6198 not shift-translated, or any other action that would normally
6199 deactivate the mark (e.g. buffer modification), the value of
6200 `transient-mark-mode' is set to OLDVAL. */);
6201 Vtransient_mark_mode
= Qnil
;
6203 DEFVAR_LISP ("inhibit-read-only", Vinhibit_read_only
,
6204 doc
: /* Non-nil means disregard read-only status of buffers or characters.
6205 If the value is t, disregard `buffer-read-only' and all `read-only'
6206 text properties. If the value is a list, disregard `buffer-read-only'
6207 and disregard a `read-only' text property if the property value
6208 is a member of the list. */);
6209 Vinhibit_read_only
= Qnil
;
6211 DEFVAR_PER_BUFFER ("cursor-type", &BVAR (current_buffer
, cursor_type
), Qnil
,
6212 doc
: /* Cursor to use when this buffer is in the selected window.
6213 Values are interpreted as follows:
6215 t use the cursor specified for the frame
6216 nil don't display a cursor
6217 box display a filled box cursor
6218 hollow display a hollow box cursor
6219 bar display a vertical bar cursor with default width
6220 (bar . WIDTH) display a vertical bar cursor with width WIDTH
6221 hbar display a horizontal bar cursor with default height
6222 (hbar . HEIGHT) display a horizontal bar cursor with height HEIGHT
6223 ANYTHING ELSE display a hollow box cursor
6225 When the buffer is displayed in a non-selected window, the
6226 cursor's appearance is instead controlled by the variable
6227 `cursor-in-non-selected-windows'. */);
6229 DEFVAR_PER_BUFFER ("line-spacing",
6230 &BVAR (current_buffer
, extra_line_spacing
), Qnumberp
,
6231 doc
: /* Additional space to put between lines when displaying a buffer.
6232 The space is measured in pixels, and put below lines on graphic displays,
6233 see `display-graphic-p'.
6234 If value is a floating point number, it specifies the spacing relative
6235 to the default frame line height. A value of nil means add no extra space. */);
6237 DEFVAR_PER_BUFFER ("cursor-in-non-selected-windows",
6238 &BVAR (current_buffer
, cursor_in_non_selected_windows
), Qnil
,
6239 doc
: /* Non-nil means show a cursor in non-selected windows.
6240 If nil, only shows a cursor in the selected window.
6241 If t, displays a cursor related to the usual cursor type
6242 \(a solid box becomes hollow, a bar becomes a narrower bar).
6243 You can also specify the cursor type as in the `cursor-type' variable.
6244 Use Custom to set this variable and update the display." */);
6246 DEFVAR_LISP ("kill-buffer-query-functions", Vkill_buffer_query_functions
,
6247 doc
: /* List of functions called with no args to query before killing a buffer.
6248 The buffer being killed will be current while the functions are running.
6250 If any of them returns nil, the buffer is not killed. Functions run by
6251 this hook are supposed to not change the current buffer. */);
6252 Vkill_buffer_query_functions
= Qnil
;
6254 DEFVAR_LISP ("change-major-mode-hook", Vchange_major_mode_hook
,
6255 doc
: /* Normal hook run before changing the major mode of a buffer.
6256 The function `kill-all-local-variables' runs this before doing anything else. */);
6257 Vchange_major_mode_hook
= Qnil
;
6258 DEFSYM (Qchange_major_mode_hook
, "change-major-mode-hook");
6260 DEFVAR_LISP ("buffer-list-update-hook", Vbuffer_list_update_hook
,
6261 doc
: /* Hook run when the buffer list changes.
6262 Functions running this hook are, `get-buffer-create',
6263 `make-indirect-buffer', `rename-buffer', `kill-buffer',
6264 `bury-buffer-internal' and `select-window'. */);
6265 Vbuffer_list_update_hook
= Qnil
;
6266 DEFSYM (Qbuffer_list_update_hook
, "buffer-list-update-hook");
6268 defsubr (&Sbuffer_live_p
);
6269 defsubr (&Sbuffer_list
);
6270 defsubr (&Sget_buffer
);
6271 defsubr (&Sget_file_buffer
);
6272 defsubr (&Sget_buffer_create
);
6273 defsubr (&Smake_indirect_buffer
);
6274 defsubr (&Sgenerate_new_buffer_name
);
6275 defsubr (&Sbuffer_name
);
6276 defsubr (&Sbuffer_file_name
);
6277 defsubr (&Sbuffer_base_buffer
);
6278 defsubr (&Sbuffer_local_value
);
6279 defsubr (&Sbuffer_local_variables
);
6280 defsubr (&Sbuffer_modified_p
);
6281 defsubr (&Sforce_mode_line_update
);
6282 defsubr (&Sset_buffer_modified_p
);
6283 defsubr (&Sbuffer_modified_tick
);
6284 defsubr (&Sbuffer_chars_modified_tick
);
6285 defsubr (&Srename_buffer
);
6286 defsubr (&Sother_buffer
);
6287 defsubr (&Sbuffer_enable_undo
);
6288 defsubr (&Skill_buffer
);
6289 defsubr (&Sbury_buffer_internal
);
6290 defsubr (&Sset_buffer_major_mode
);
6291 defsubr (&Scurrent_buffer
);
6292 defsubr (&Sset_buffer
);
6293 defsubr (&Sbarf_if_buffer_read_only
);
6294 defsubr (&Serase_buffer
);
6295 defsubr (&Sbuffer_swap_text
);
6296 defsubr (&Sset_buffer_multibyte
);
6297 defsubr (&Skill_all_local_variables
);
6299 defsubr (&Soverlayp
);
6300 defsubr (&Smake_overlay
);
6301 defsubr (&Sdelete_overlay
);
6302 defsubr (&Sdelete_all_overlays
);
6303 defsubr (&Smove_overlay
);
6304 defsubr (&Soverlay_start
);
6305 defsubr (&Soverlay_end
);
6306 defsubr (&Soverlay_buffer
);
6307 defsubr (&Soverlay_properties
);
6308 defsubr (&Soverlays_at
);
6309 defsubr (&Soverlays_in
);
6310 defsubr (&Snext_overlay_change
);
6311 defsubr (&Sprevious_overlay_change
);
6312 defsubr (&Soverlay_recenter
);
6313 defsubr (&Soverlay_lists
);
6314 defsubr (&Soverlay_get
);
6315 defsubr (&Soverlay_put
);
6316 defsubr (&Srestore_buffer_modified_p
);
6320 keys_of_buffer (void)
6322 initial_define_key (control_x_map
, 'b', "switch-to-buffer");
6323 initial_define_key (control_x_map
, 'k', "kill-buffer");
6325 /* This must not be in syms_of_buffer, because Qdisabled is not
6326 initialized when that function gets called. */
6327 Fput (intern_c_string ("erase-buffer"), Qdisabled
, Qt
);