1 /* Buffer manipulation primitives for GNU Emacs.
3 Copyright (C) 1985-1989, 1993-1995, 1997-2012 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
22 #include <sys/types.h>
24 #include <sys/param.h>
33 #include "intervals.h"
36 #include "character.h"
38 #include "region-cache.h"
40 #include "blockinput.h"
45 struct buffer
*current_buffer
; /* the current buffer */
47 /* First buffer in chain of all buffers (in reverse order of creation).
48 Threaded through ->header.next.buffer. */
50 struct buffer
*all_buffers
;
52 /* This structure holds the default values of the buffer-local variables
53 defined with DEFVAR_PER_BUFFER, that have special slots in each buffer.
54 The default value occupies the same slot in this structure
55 as an individual buffer's value occupies in that buffer.
56 Setting the default value also goes through the alist of buffers
57 and stores into each buffer that does not say it has a local value. */
59 DECL_ALIGN (struct buffer
, buffer_defaults
);
61 /* A Lisp_Object pointer to the above, used for staticpro */
63 static Lisp_Object Vbuffer_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 DECL_ALIGN (struct buffer
, buffer_local_symbols
);
88 /* A Lisp_Object pointer to the above, used for staticpro */
89 static Lisp_Object Vbuffer_local_symbols
;
91 /* Return the symbol of the per-buffer variable at offset OFFSET in
92 the buffer structure. */
94 #define PER_BUFFER_SYMBOL(OFFSET) \
95 (*(Lisp_Object *)((OFFSET) + (char *) &buffer_local_symbols))
97 /* Maximum length of an overlay vector. */
98 #define OVERLAY_COUNT_MAX \
99 ((ptrdiff_t) min (MOST_POSITIVE_FIXNUM, \
100 min (PTRDIFF_MAX, SIZE_MAX) / sizeof (Lisp_Object)))
102 /* Flags indicating which built-in buffer-local variables
103 are permanent locals. */
104 static char buffer_permanent_local_flags
[MAX_PER_BUFFER_VARS
];
106 /* Number of per-buffer variables used. */
108 int last_per_buffer_idx
;
110 static void call_overlay_mod_hooks (Lisp_Object list
, Lisp_Object overlay
,
111 int after
, Lisp_Object arg1
,
112 Lisp_Object arg2
, Lisp_Object arg3
);
113 static void swap_out_buffer_local_variables (struct buffer
*b
);
114 static void reset_buffer_local_variables (struct buffer
*b
, int permanent_too
);
116 /* Alist of all buffer names vs the buffers. */
117 /* This used to be a variable, but is no longer,
118 to prevent lossage due to user rplac'ing this alist or its elements. */
119 Lisp_Object Vbuffer_alist
;
121 static Lisp_Object Qkill_buffer_query_functions
;
123 /* Hook run before changing a major mode. */
124 static Lisp_Object Qchange_major_mode_hook
;
126 Lisp_Object Qfirst_change_hook
;
127 Lisp_Object Qbefore_change_functions
;
128 Lisp_Object Qafter_change_functions
;
130 static Lisp_Object Qfundamental_mode
, Qmode_class
, Qpermanent_local
;
131 static Lisp_Object Qpermanent_local_hook
;
133 static Lisp_Object Qprotected_field
;
135 static Lisp_Object QSFundamental
; /* A string "Fundamental" */
137 static Lisp_Object Qkill_buffer_hook
;
138 static Lisp_Object Qbuffer_list_update_hook
;
140 static Lisp_Object Qget_file_buffer
;
142 static Lisp_Object Qoverlayp
;
144 Lisp_Object Qpriority
, Qbefore_string
, Qafter_string
;
146 static Lisp_Object Qevaporate
;
148 Lisp_Object Qmodification_hooks
;
149 Lisp_Object Qinsert_in_front_hooks
;
150 Lisp_Object Qinsert_behind_hooks
;
152 static void alloc_buffer_text (struct buffer
*, ptrdiff_t);
153 static void free_buffer_text (struct buffer
*b
);
154 static struct Lisp_Overlay
* copy_overlays (struct buffer
*, struct Lisp_Overlay
*);
155 static void modify_overlay (struct buffer
*, ptrdiff_t, ptrdiff_t);
156 static Lisp_Object
buffer_lisp_local_variables (struct buffer
*, int);
158 /* For debugging; temporary. See set_buffer_internal. */
159 /* Lisp_Object Qlisp_mode, Vcheck_symbol; */
162 nsberror (Lisp_Object spec
)
165 error ("No buffer named %s", SDATA (spec
));
166 error ("Invalid buffer argument");
169 DEFUN ("buffer-live-p", Fbuffer_live_p
, Sbuffer_live_p
, 1, 1, 0,
170 doc
: /* Return non-nil if OBJECT is a buffer which has not been killed.
171 Value is nil if OBJECT is not a buffer or if it has been killed. */)
174 return ((BUFFERP (object
) && ! NILP (BVAR (XBUFFER (object
), name
)))
178 DEFUN ("buffer-list", Fbuffer_list
, Sbuffer_list
, 0, 1, 0,
179 doc
: /* Return a list of all existing live buffers.
180 If the optional arg FRAME is a frame, we return the buffer list in the
181 proper order for that frame: the buffers show in FRAME come first,
182 followed by the rest of the buffers. */)
186 general
= Fmapcar (Qcdr
, Vbuffer_alist
);
190 Lisp_Object framelist
, prevlist
, tail
;
194 framelist
= Fcopy_sequence (XFRAME (frame
)->buffer_list
);
195 prevlist
= Fnreverse (Fcopy_sequence
196 (XFRAME (frame
)->buried_buffer_list
));
198 /* Remove from GENERAL any buffer that duplicates one in
199 FRAMELIST or PREVLIST. */
203 general
= Fdelq (XCAR (tail
), general
);
209 general
= Fdelq (XCAR (tail
), general
);
216 return Fnconc (3, args
);
222 /* Like Fassoc, but use Fstring_equal to compare
223 (which ignores text properties),
224 and don't ever QUIT. */
227 assoc_ignore_text_properties (register Lisp_Object key
, Lisp_Object list
)
229 register Lisp_Object tail
;
230 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
232 register Lisp_Object elt
, tem
;
234 tem
= Fstring_equal (Fcar (elt
), key
);
241 DEFUN ("get-buffer", Fget_buffer
, Sget_buffer
, 1, 1, 0,
242 doc
: /* Return the buffer named BUFFER-OR-NAME.
243 BUFFER-OR-NAME must be either a string or a buffer. If BUFFER-OR-NAME
244 is a string and there is no buffer with that name, return nil. If
245 BUFFER-OR-NAME is a buffer, return it as given. */)
246 (register Lisp_Object buffer_or_name
)
248 if (BUFFERP (buffer_or_name
))
249 return buffer_or_name
;
250 CHECK_STRING (buffer_or_name
);
252 return Fcdr (assoc_ignore_text_properties (buffer_or_name
, Vbuffer_alist
));
255 DEFUN ("get-file-buffer", Fget_file_buffer
, Sget_file_buffer
, 1, 1, 0,
256 doc
: /* Return the buffer visiting file FILENAME (a string).
257 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
258 If there is no such live buffer, return nil.
259 See also `find-buffer-visiting'. */)
260 (register Lisp_Object filename
)
262 register Lisp_Object tail
, buf
, tem
;
265 CHECK_STRING (filename
);
266 filename
= Fexpand_file_name (filename
, Qnil
);
268 /* If the file name has special constructs in it,
269 call the corresponding file handler. */
270 handler
= Ffind_file_name_handler (filename
, Qget_file_buffer
);
273 Lisp_Object handled_buf
= call2 (handler
, Qget_file_buffer
,
275 return BUFFERP (handled_buf
) ? handled_buf
: Qnil
;
278 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
280 buf
= Fcdr (XCAR (tail
));
281 if (!BUFFERP (buf
)) continue;
282 if (!STRINGP (BVAR (XBUFFER (buf
), filename
))) continue;
283 tem
= Fstring_equal (BVAR (XBUFFER (buf
), filename
), filename
);
291 get_truename_buffer (register Lisp_Object filename
)
293 register Lisp_Object tail
, buf
, tem
;
295 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
297 buf
= Fcdr (XCAR (tail
));
298 if (!BUFFERP (buf
)) continue;
299 if (!STRINGP (BVAR (XBUFFER (buf
), file_truename
))) continue;
300 tem
= Fstring_equal (BVAR (XBUFFER (buf
), file_truename
), filename
);
307 DEFUN ("get-buffer-create", Fget_buffer_create
, Sget_buffer_create
, 1, 1, 0,
308 doc
: /* Return the buffer specified by BUFFER-OR-NAME, creating a new one if needed.
309 If BUFFER-OR-NAME is a string and a live buffer with that name exists,
310 return that buffer. If no such buffer exists, create a new buffer with
311 that name and return it. If BUFFER-OR-NAME starts with a space, the new
312 buffer does not keep undo information.
314 If BUFFER-OR-NAME is a buffer instead of a string, return it as given,
315 even if it is dead. The return value is never nil. */)
316 (register Lisp_Object buffer_or_name
)
318 register Lisp_Object buffer
, name
;
319 register struct buffer
*b
;
321 buffer
= Fget_buffer (buffer_or_name
);
325 if (SCHARS (buffer_or_name
) == 0)
326 error ("Empty string for buffer name is not allowed");
328 b
= allocate_buffer ();
330 /* An ordinary buffer uses its own struct buffer_text. */
331 b
->text
= &b
->own_text
;
332 b
->base_buffer
= NULL
;
333 /* No one shares the text with us now. */
336 BUF_GAP_SIZE (b
) = 20;
338 /* We allocate extra 1-byte at the tail and keep it always '\0' for
339 anchoring a search. */
340 alloc_buffer_text (b
, BUF_GAP_SIZE (b
) + 1);
342 if (! BUF_BEG_ADDR (b
))
343 buffer_memory_full (BUF_GAP_SIZE (b
) + 1);
348 b
->pt_byte
= BEG_BYTE
;
349 b
->begv_byte
= BEG_BYTE
;
350 b
->zv_byte
= BEG_BYTE
;
353 BUF_GPT_BYTE (b
) = BEG_BYTE
;
356 BUF_Z_BYTE (b
) = BEG_BYTE
;
358 BUF_CHARS_MODIFF (b
) = 1;
359 BUF_OVERLAY_MODIFF (b
) = 1;
360 BUF_SAVE_MODIFF (b
) = 1;
361 BUF_INTERVALS (b
) = 0;
362 BUF_UNCHANGED_MODIFIED (b
) = 1;
363 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = 1;
364 BUF_END_UNCHANGED (b
) = 0;
365 BUF_BEG_UNCHANGED (b
) = 0;
366 *(BUF_GPT_ADDR (b
)) = *(BUF_Z_ADDR (b
)) = 0; /* Put an anchor '\0'. */
367 b
->text
->inhibit_shrinking
= 0;
369 b
->newline_cache
= 0;
370 b
->width_run_cache
= 0;
371 BVAR (b
, width_table
) = Qnil
;
372 b
->prevent_redisplay_optimizations_p
= 1;
374 /* Put this on the chain of all buffers including killed ones. */
375 b
->header
.next
.buffer
= all_buffers
;
378 /* An ordinary buffer normally doesn't need markers
379 to handle BEGV and ZV. */
380 BVAR (b
, pt_marker
) = Qnil
;
381 BVAR (b
, begv_marker
) = Qnil
;
382 BVAR (b
, zv_marker
) = Qnil
;
384 name
= Fcopy_sequence (buffer_or_name
);
385 STRING_SET_INTERVALS (name
, NULL_INTERVAL
);
386 BVAR (b
, name
) = name
;
388 BVAR (b
, undo_list
) = (SREF (name
, 0) != ' ') ? Qnil
: Qt
;
391 reset_buffer_local_variables (b
, 1);
393 BVAR (b
, mark
) = Fmake_marker ();
394 BUF_MARKERS (b
) = NULL
;
396 /* Put this in the alist of all live buffers. */
397 XSETBUFFER (buffer
, b
);
398 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buffer
), Qnil
));
399 /* And run buffer-list-update-hook. */
400 if (!NILP (Vrun_hooks
))
401 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
407 /* Return a list of overlays which is a copy of the overlay list
408 LIST, but for buffer B. */
410 static struct Lisp_Overlay
*
411 copy_overlays (struct buffer
*b
, struct Lisp_Overlay
*list
)
414 struct Lisp_Overlay
*result
= NULL
, *tail
= NULL
;
416 XSETBUFFER (buffer
, b
);
418 for (; list
; list
= list
->next
)
420 Lisp_Object overlay
, start
, end
, old_overlay
;
423 XSETMISC (old_overlay
, list
);
424 charpos
= marker_position (OVERLAY_START (old_overlay
));
425 start
= Fmake_marker ();
426 Fset_marker (start
, make_number (charpos
), buffer
);
427 XMARKER (start
)->insertion_type
428 = XMARKER (OVERLAY_START (old_overlay
))->insertion_type
;
430 charpos
= marker_position (OVERLAY_END (old_overlay
));
431 end
= Fmake_marker ();
432 Fset_marker (end
, make_number (charpos
), buffer
);
433 XMARKER (end
)->insertion_type
434 = XMARKER (OVERLAY_END (old_overlay
))->insertion_type
;
436 overlay
= allocate_misc ();
437 XMISCTYPE (overlay
) = Lisp_Misc_Overlay
;
438 OVERLAY_START (overlay
) = start
;
439 OVERLAY_END (overlay
) = end
;
440 OVERLAY_PLIST (overlay
) = Fcopy_sequence (OVERLAY_PLIST (old_overlay
));
441 XOVERLAY (overlay
)->next
= NULL
;
444 tail
= tail
->next
= XOVERLAY (overlay
);
446 result
= tail
= XOVERLAY (overlay
);
453 /* Clone per-buffer values of buffer FROM.
455 Buffer TO gets the same per-buffer values as FROM, with the
456 following exceptions: (1) TO's name is left untouched, (2) markers
457 are copied and made to refer to TO, and (3) overlay lists are
461 clone_per_buffer_values (struct buffer
*from
, struct buffer
*to
)
465 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
469 /* Don't touch the `name' which should be unique for every buffer. */
470 if (offset
== PER_BUFFER_VAR_OFFSET (name
))
473 obj
= PER_BUFFER_VALUE (from
, offset
);
474 if (MARKERP (obj
) && XMARKER (obj
)->buffer
== from
)
476 struct Lisp_Marker
*m
= XMARKER (obj
);
478 obj
= build_marker (to
, m
->charpos
, m
->bytepos
);
479 XMARKER (obj
)->insertion_type
= m
->insertion_type
;
482 PER_BUFFER_VALUE (to
, offset
) = obj
;
485 memcpy (to
->local_flags
, from
->local_flags
, sizeof to
->local_flags
);
487 to
->overlays_before
= copy_overlays (to
, from
->overlays_before
);
488 to
->overlays_after
= copy_overlays (to
, from
->overlays_after
);
490 /* Get (a copy of) the alist of Lisp-level local variables of FROM
491 and install that in TO. */
492 BVAR (to
, local_var_alist
) = buffer_lisp_local_variables (from
, 1);
496 /* If buffer B has markers to record PT, BEGV and ZV when it is not
497 current, update these markers. */
500 record_buffer_markers (struct buffer
*b
)
502 if (! NILP (BVAR (b
, pt_marker
)))
506 eassert (!NILP (BVAR (b
, begv_marker
)));
507 eassert (!NILP (BVAR (b
, zv_marker
)));
509 XSETBUFFER (buffer
, b
);
510 set_marker_both (BVAR (b
, pt_marker
), buffer
, b
->pt
, b
->pt_byte
);
511 set_marker_both (BVAR (b
, begv_marker
), buffer
, b
->begv
, b
->begv_byte
);
512 set_marker_both (BVAR (b
, zv_marker
), buffer
, b
->zv
, b
->zv_byte
);
517 /* If buffer B has markers to record PT, BEGV and ZV when it is not
518 current, fetch these values into B->begv etc. */
521 fetch_buffer_markers (struct buffer
*b
)
523 if (! NILP (BVAR (b
, pt_marker
)))
527 eassert (!NILP (BVAR (b
, begv_marker
)));
528 eassert (!NILP (BVAR (b
, zv_marker
)));
530 m
= BVAR (b
, pt_marker
);
531 SET_BUF_PT_BOTH (b
, marker_position (m
), marker_byte_position (m
));
533 m
= BVAR (b
, begv_marker
);
534 SET_BUF_BEGV_BOTH (b
, marker_position (m
), marker_byte_position (m
));
536 m
= BVAR (b
, zv_marker
);
537 SET_BUF_ZV_BOTH (b
, marker_position (m
), marker_byte_position (m
));
542 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer
, Smake_indirect_buffer
,
544 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ",
545 doc
: /* Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.
546 BASE-BUFFER should be a live buffer, or the name of an existing buffer.
547 NAME should be a string which is not the name of an existing buffer.
548 Optional argument CLONE non-nil means preserve BASE-BUFFER's state,
549 such as major and minor modes, in the indirect buffer.
550 CLONE nil means the indirect buffer's state is reset to default values. */)
551 (Lisp_Object base_buffer
, Lisp_Object name
, Lisp_Object clone
)
553 Lisp_Object buf
, tem
;
557 buf
= Fget_buffer (name
);
559 error ("Buffer name `%s' is in use", SDATA (name
));
562 base_buffer
= Fget_buffer (base_buffer
);
563 if (NILP (base_buffer
))
564 error ("No such buffer: `%s'", SDATA (tem
));
565 if (NILP (BVAR (XBUFFER (base_buffer
), name
)))
566 error ("Base buffer has been killed");
568 if (SCHARS (name
) == 0)
569 error ("Empty string for buffer name is not allowed");
571 b
= allocate_buffer ();
573 /* No double indirection - if base buffer is indirect,
574 new buffer becomes an indirect to base's base. */
575 b
->base_buffer
= (XBUFFER (base_buffer
)->base_buffer
576 ? XBUFFER (base_buffer
)->base_buffer
577 : XBUFFER (base_buffer
));
579 /* Use the base buffer's text object. */
580 b
->text
= b
->base_buffer
->text
;
581 /* We have no own text. */
582 b
->indirections
= -1;
583 /* Notify base buffer that we share the text now. */
584 b
->base_buffer
->indirections
++;
586 b
->pt
= b
->base_buffer
->pt
;
587 b
->begv
= b
->base_buffer
->begv
;
588 b
->zv
= b
->base_buffer
->zv
;
589 b
->pt_byte
= b
->base_buffer
->pt_byte
;
590 b
->begv_byte
= b
->base_buffer
->begv_byte
;
591 b
->zv_byte
= b
->base_buffer
->zv_byte
;
593 b
->newline_cache
= 0;
594 b
->width_run_cache
= 0;
595 BVAR (b
, width_table
) = Qnil
;
597 /* Put this on the chain of all buffers including killed ones. */
598 b
->header
.next
.buffer
= all_buffers
;
601 name
= Fcopy_sequence (name
);
602 STRING_SET_INTERVALS (name
, NULL_INTERVAL
);
603 BVAR (b
, name
) = name
;
606 reset_buffer_local_variables (b
, 1);
608 /* Put this in the alist of all live buffers. */
610 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buf
), Qnil
));
612 BVAR (b
, mark
) = Fmake_marker ();
614 /* The multibyte status belongs to the base buffer. */
615 BVAR (b
, enable_multibyte_characters
) = BVAR (b
->base_buffer
, enable_multibyte_characters
);
617 /* Make sure the base buffer has markers for its narrowing. */
618 if (NILP (BVAR (b
->base_buffer
, pt_marker
)))
620 eassert (NILP (BVAR (b
->base_buffer
, begv_marker
)));
621 eassert (NILP (BVAR (b
->base_buffer
, zv_marker
)));
623 BVAR (b
->base_buffer
, pt_marker
)
624 = build_marker (b
->base_buffer
, b
->base_buffer
->pt
, b
->base_buffer
->pt_byte
);
626 BVAR (b
->base_buffer
, begv_marker
)
627 = build_marker (b
->base_buffer
, b
->base_buffer
->begv
, b
->base_buffer
->begv_byte
);
629 BVAR (b
->base_buffer
, zv_marker
)
630 = build_marker (b
->base_buffer
, b
->base_buffer
->zv
, b
->base_buffer
->zv_byte
);
632 XMARKER (BVAR (b
->base_buffer
, zv_marker
))->insertion_type
= 1;
637 /* Give the indirect buffer markers for its narrowing. */
638 BVAR (b
, pt_marker
) = build_marker (b
, b
->pt
, b
->pt_byte
);
639 BVAR (b
, begv_marker
) = build_marker (b
, b
->begv
, b
->begv_byte
);
640 BVAR (b
, zv_marker
) = build_marker (b
, b
->zv
, b
->zv_byte
);
641 XMARKER (BVAR (b
, zv_marker
))->insertion_type
= 1;
645 struct buffer
*old_b
= current_buffer
;
647 clone_per_buffer_values (b
->base_buffer
, b
);
648 BVAR (b
, filename
) = Qnil
;
649 BVAR (b
, file_truename
) = Qnil
;
650 BVAR (b
, display_count
) = make_number (0);
651 BVAR (b
, backed_up
) = Qnil
;
652 BVAR (b
, auto_save_file_name
) = Qnil
;
653 set_buffer_internal_1 (b
);
654 Fset (intern ("buffer-save-without-query"), Qnil
);
655 Fset (intern ("buffer-file-number"), Qnil
);
656 Fset (intern ("buffer-stale-function"), Qnil
);
657 set_buffer_internal_1 (old_b
);
660 /* Run buffer-list-update-hook. */
661 if (!NILP (Vrun_hooks
))
662 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
667 /* Mark OV as no longer associated with B. */
670 drop_overlay (struct buffer
*b
, struct Lisp_Overlay
*ov
)
672 eassert (b
== XBUFFER (Fmarker_buffer (ov
->start
)));
673 modify_overlay (b
, marker_position (ov
->start
), marker_position (ov
->end
));
674 Fset_marker (ov
->start
, Qnil
, Qnil
);
675 Fset_marker (ov
->end
, Qnil
, Qnil
);
679 /* Delete all overlays of B and reset it's overlay lists. */
682 delete_all_overlays (struct buffer
*b
)
684 struct Lisp_Overlay
*ov
, *next
;
686 for (ov
= b
->overlays_before
; ov
; ov
= next
)
688 drop_overlay (b
, ov
);
693 for (ov
= b
->overlays_after
; ov
; ov
= next
)
695 drop_overlay (b
, ov
);
700 b
->overlays_before
= b
->overlays_after
= NULL
;
703 /* Reinitialize everything about a buffer except its name and contents
705 If called on an already-initialized buffer, the list of overlays
706 should be deleted before calling this function, otherwise we end up
707 with overlays that claim to belong to the buffer but the buffer
708 claims it doesn't belong to it. */
711 reset_buffer (register struct buffer
*b
)
713 BVAR (b
, filename
) = Qnil
;
714 BVAR (b
, file_truename
) = Qnil
;
715 BVAR (b
, directory
) = (current_buffer
) ? BVAR (current_buffer
, directory
) : Qnil
;
716 b
->modtime
= make_emacs_time (0, UNKNOWN_MODTIME_NSECS
);
717 b
->modtime_size
= -1;
718 XSETFASTINT (BVAR (b
, save_length
), 0);
719 b
->last_window_start
= 1;
720 /* It is more conservative to start out "changed" than "unchanged". */
722 b
->prevent_redisplay_optimizations_p
= 1;
723 BVAR (b
, backed_up
) = Qnil
;
724 BUF_AUTOSAVE_MODIFF (b
) = 0;
725 b
->auto_save_failure_time
= 0;
726 BVAR (b
, auto_save_file_name
) = Qnil
;
727 BVAR (b
, read_only
) = Qnil
;
728 b
->overlays_before
= NULL
;
729 b
->overlays_after
= NULL
;
730 b
->overlay_center
= BEG
;
731 BVAR (b
, mark_active
) = Qnil
;
732 BVAR (b
, point_before_scroll
) = Qnil
;
733 BVAR (b
, file_format
) = Qnil
;
734 BVAR (b
, auto_save_file_format
) = Qt
;
735 BVAR (b
, last_selected_window
) = Qnil
;
736 XSETINT (BVAR (b
, display_count
), 0);
737 BVAR (b
, display_time
) = Qnil
;
738 BVAR (b
, enable_multibyte_characters
) = BVAR (&buffer_defaults
, enable_multibyte_characters
);
739 BVAR (b
, cursor_type
) = BVAR (&buffer_defaults
, cursor_type
);
740 BVAR (b
, extra_line_spacing
) = BVAR (&buffer_defaults
, extra_line_spacing
);
742 b
->display_error_modiff
= 0;
745 /* Reset buffer B's local variables info.
746 Don't use this on a buffer that has already been in use;
747 it does not treat permanent locals consistently.
748 Instead, use Fkill_all_local_variables.
750 If PERMANENT_TOO is 1, then we reset permanent
751 buffer-local variables. If PERMANENT_TOO is 0,
752 we preserve those. */
755 reset_buffer_local_variables (register struct buffer
*b
, int permanent_too
)
760 /* Reset the major mode to Fundamental, together with all the
761 things that depend on the major mode.
762 default-major-mode is handled at a higher level.
763 We ignore it here. */
764 BVAR (b
, major_mode
) = Qfundamental_mode
;
765 BVAR (b
, keymap
) = Qnil
;
766 BVAR (b
, mode_name
) = QSFundamental
;
767 BVAR (b
, minor_modes
) = Qnil
;
769 /* If the standard case table has been altered and invalidated,
770 fix up its insides first. */
771 if (! (CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[0])
772 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[1])
773 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[2])))
774 Fset_standard_case_table (Vascii_downcase_table
);
776 BVAR (b
, downcase_table
) = Vascii_downcase_table
;
777 BVAR (b
, upcase_table
) = XCHAR_TABLE (Vascii_downcase_table
)->extras
[0];
778 BVAR (b
, case_canon_table
) = XCHAR_TABLE (Vascii_downcase_table
)->extras
[1];
779 BVAR (b
, case_eqv_table
) = XCHAR_TABLE (Vascii_downcase_table
)->extras
[2];
780 BVAR (b
, invisibility_spec
) = Qt
;
782 /* Reset all (or most) per-buffer variables to their defaults. */
784 BVAR (b
, local_var_alist
) = Qnil
;
787 Lisp_Object tmp
, prop
, last
= Qnil
;
788 for (tmp
= BVAR (b
, local_var_alist
); CONSP (tmp
); tmp
= XCDR (tmp
))
789 if (!NILP (prop
= Fget (XCAR (XCAR (tmp
)), Qpermanent_local
)))
791 /* If permanent-local, keep it. */
793 if (EQ (prop
, Qpermanent_local_hook
))
795 /* This is a partially permanent hook variable.
796 Preserve only the elements that want to be preserved. */
797 Lisp_Object list
, newlist
;
798 list
= XCDR (XCAR (tmp
));
802 for (newlist
= Qnil
; CONSP (list
); list
= XCDR (list
))
804 Lisp_Object elt
= XCAR (list
);
805 /* Preserve element ELT if it's t,
806 if it is a function with a `permanent-local-hook' property,
807 or if it's not a symbol. */
810 || !NILP (Fget (elt
, Qpermanent_local_hook
)))
811 newlist
= Fcons (elt
, newlist
);
813 XSETCDR (XCAR (tmp
), Fnreverse (newlist
));
816 /* Delete this local variable. */
817 else if (NILP (last
))
818 BVAR (b
, local_var_alist
) = XCDR (tmp
);
820 XSETCDR (last
, XCDR (tmp
));
823 for (i
= 0; i
< last_per_buffer_idx
; ++i
)
824 if (permanent_too
|| buffer_permanent_local_flags
[i
] == 0)
825 SET_PER_BUFFER_VALUE_P (b
, i
, 0);
827 /* For each slot that has a default value, copy that into the slot. */
828 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
830 int idx
= PER_BUFFER_IDX (offset
);
833 || buffer_permanent_local_flags
[idx
] == 0)))
834 PER_BUFFER_VALUE (b
, offset
) = PER_BUFFER_DEFAULT (offset
);
838 /* We split this away from generate-new-buffer, because rename-buffer
839 and set-visited-file-name ought to be able to use this to really
840 rename the buffer properly. */
842 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name
,
843 Sgenerate_new_buffer_name
, 1, 2, 0,
844 doc
: /* Return a string that is the name of no existing buffer based on NAME.
845 If there is no live buffer named NAME, then return NAME.
846 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
847 \(starting at 2) until an unused name is found, and then return that name.
848 Optional second argument IGNORE specifies a name that is okay to use (if
849 it is in the sequence to be tried) even if a buffer with that name exists.
851 If NAME begins with a space (i.e., a buffer that is not normally
852 visible to users), then if buffer NAME already exists a random number
853 is first appended to NAME, to speed up finding a non-existent buffer. */)
854 (register Lisp_Object name
, Lisp_Object ignore
)
856 register Lisp_Object gentemp
, tem
, tem2
;
858 char number
[INT_BUFSIZE_BOUND (ptrdiff_t) + sizeof "<>"];
862 tem
= Fstring_equal (name
, ignore
);
865 tem
= Fget_buffer (name
);
869 if (!strncmp (SSDATA (name
), " ", 1)) /* see bug#1229 */
871 /* Note fileio.c:make_temp_name does random differently. */
872 tem2
= concat2 (name
, make_formatted_string
874 XFASTINT (Frandom (make_number (999999)))));
875 tem
= Fget_buffer (tem2
);
885 gentemp
= concat2 (tem2
, make_formatted_string
886 (number
, "<%"pD
"d>", ++count
));
887 tem
= Fstring_equal (gentemp
, ignore
);
890 tem
= Fget_buffer (gentemp
);
897 DEFUN ("buffer-name", Fbuffer_name
, Sbuffer_name
, 0, 1, 0,
898 doc
: /* Return the name of BUFFER, as a string.
899 BUFFER defaults to the current buffer.
900 Return nil if BUFFER has been killed. */)
901 (register Lisp_Object buffer
)
904 return BVAR (current_buffer
, name
);
905 CHECK_BUFFER (buffer
);
906 return BVAR (XBUFFER (buffer
), name
);
909 DEFUN ("buffer-file-name", Fbuffer_file_name
, Sbuffer_file_name
, 0, 1, 0,
910 doc
: /* Return name of file BUFFER is visiting, or nil if none.
911 No argument or nil as argument means use the current buffer. */)
912 (register Lisp_Object buffer
)
915 return BVAR (current_buffer
, filename
);
916 CHECK_BUFFER (buffer
);
917 return BVAR (XBUFFER (buffer
), filename
);
920 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer
, Sbuffer_base_buffer
,
922 doc
: /* Return the base buffer of indirect buffer BUFFER.
923 If BUFFER is not indirect, return nil.
924 BUFFER defaults to the current buffer. */)
925 (register Lisp_Object buffer
)
928 Lisp_Object base_buffer
;
931 base
= current_buffer
->base_buffer
;
934 CHECK_BUFFER (buffer
);
935 base
= XBUFFER (buffer
)->base_buffer
;
940 XSETBUFFER (base_buffer
, base
);
944 DEFUN ("buffer-local-value", Fbuffer_local_value
,
945 Sbuffer_local_value
, 2, 2, 0,
946 doc
: /* Return the value of VARIABLE in BUFFER.
947 If VARIABLE does not have a buffer-local binding in BUFFER, the value
948 is the default binding of the variable. */)
949 (register Lisp_Object variable
, register Lisp_Object buffer
)
951 register Lisp_Object result
= buffer_local_value_1 (variable
, buffer
);
953 if (EQ (result
, Qunbound
))
954 xsignal1 (Qvoid_variable
, variable
);
960 /* Like Fbuffer_local_value, but return Qunbound if the variable is
964 buffer_local_value_1 (Lisp_Object variable
, Lisp_Object buffer
)
966 register struct buffer
*buf
;
967 register Lisp_Object result
;
968 struct Lisp_Symbol
*sym
;
970 CHECK_SYMBOL (variable
);
971 CHECK_BUFFER (buffer
);
972 buf
= XBUFFER (buffer
);
973 sym
= XSYMBOL (variable
);
976 switch (sym
->redirect
)
978 case SYMBOL_VARALIAS
: sym
= indirect_variable (sym
); goto start
;
979 case SYMBOL_PLAINVAL
: result
= SYMBOL_VAL (sym
); break;
980 case SYMBOL_LOCALIZED
:
981 { /* Look in local_var_alist. */
982 struct Lisp_Buffer_Local_Value
*blv
= SYMBOL_BLV (sym
);
983 XSETSYMBOL (variable
, sym
); /* Update In case of aliasing. */
984 result
= Fassoc (variable
, BVAR (buf
, local_var_alist
));
988 { /* What binding is loaded right now? */
989 Lisp_Object current_alist_element
= blv
->valcell
;
991 /* The value of the currently loaded binding is not
992 stored in it, but rather in the realvalue slot.
993 Store that value into the binding it belongs to
994 in case that is the one we are about to use. */
996 XSETCDR (current_alist_element
,
997 do_symval_forwarding (blv
->fwd
));
999 /* Now get the (perhaps updated) value out of the binding. */
1000 result
= XCDR (result
);
1003 result
= Fdefault_value (variable
);
1006 case SYMBOL_FORWARDED
:
1008 union Lisp_Fwd
*fwd
= SYMBOL_FWD (sym
);
1009 if (BUFFER_OBJFWDP (fwd
))
1010 result
= PER_BUFFER_VALUE (buf
, XBUFFER_OBJFWD (fwd
)->offset
);
1012 result
= Fdefault_value (variable
);
1021 /* Return an alist of the Lisp-level buffer-local bindings of
1022 buffer BUF. That is, don't include the variables maintained
1023 in special slots in the buffer object.
1024 If CLONE is zero elements of the form (VAR . unbound) are replaced
1028 buffer_lisp_local_variables (struct buffer
*buf
, int clone
)
1030 Lisp_Object result
= Qnil
;
1031 register Lisp_Object tail
;
1032 for (tail
= BVAR (buf
, local_var_alist
); CONSP (tail
); tail
= XCDR (tail
))
1034 Lisp_Object val
, elt
;
1038 /* Reference each variable in the alist in buf.
1039 If inquiring about the current buffer, this gets the current values,
1040 so store them into the alist so the alist is up to date.
1041 If inquiring about some other buffer, this swaps out any values
1042 for that buffer, making the alist up to date automatically. */
1043 val
= find_symbol_value (XCAR (elt
));
1044 /* Use the current buffer value only if buf is the current buffer. */
1045 if (buf
!= current_buffer
)
1048 result
= Fcons (!clone
&& EQ (val
, Qunbound
)
1050 : Fcons (XCAR (elt
), val
),
1057 DEFUN ("buffer-local-variables", Fbuffer_local_variables
,
1058 Sbuffer_local_variables
, 0, 1, 0,
1059 doc
: /* Return an alist of variables that are buffer-local in BUFFER.
1060 Most elements look like (SYMBOL . VALUE), describing one variable.
1061 For a symbol that is locally unbound, just the symbol appears in the value.
1062 Note that storing new VALUEs in these elements doesn't change the variables.
1063 No argument or nil as argument means use current buffer as BUFFER. */)
1064 (register Lisp_Object buffer
)
1066 register struct buffer
*buf
;
1067 register Lisp_Object result
;
1070 buf
= current_buffer
;
1073 CHECK_BUFFER (buffer
);
1074 buf
= XBUFFER (buffer
);
1077 result
= buffer_lisp_local_variables (buf
, 0);
1079 /* Add on all the variables stored in special slots. */
1083 FOR_EACH_PER_BUFFER_OBJECT_AT (offset
)
1085 idx
= PER_BUFFER_IDX (offset
);
1086 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
1087 && SYMBOLP (PER_BUFFER_SYMBOL (offset
)))
1089 Lisp_Object sym
= PER_BUFFER_SYMBOL (offset
);
1090 Lisp_Object val
= PER_BUFFER_VALUE (buf
, offset
);
1091 result
= Fcons (EQ (val
, Qunbound
) ? sym
: Fcons (sym
, val
),
1100 DEFUN ("buffer-modified-p", Fbuffer_modified_p
, Sbuffer_modified_p
,
1102 doc
: /* Return t if BUFFER was modified since its file was last read or saved.
1103 No argument or nil as argument means use current buffer as BUFFER. */)
1104 (register Lisp_Object buffer
)
1106 register struct buffer
*buf
;
1108 buf
= current_buffer
;
1111 CHECK_BUFFER (buffer
);
1112 buf
= XBUFFER (buffer
);
1115 return BUF_SAVE_MODIFF (buf
) < BUF_MODIFF (buf
) ? Qt
: Qnil
;
1118 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p
, Sset_buffer_modified_p
,
1120 doc
: /* Mark current buffer as modified or unmodified according to FLAG.
1121 A non-nil FLAG means mark the buffer modified. */)
1122 (register Lisp_Object flag
)
1124 register int already
;
1125 register Lisp_Object fn
;
1126 Lisp_Object buffer
, window
;
1128 #ifdef CLASH_DETECTION
1129 /* If buffer becoming modified, lock the file.
1130 If buffer becoming unmodified, unlock the file. */
1132 fn
= BVAR (current_buffer
, file_truename
);
1133 /* Test buffer-file-name so that binding it to nil is effective. */
1134 if (!NILP (fn
) && ! NILP (BVAR (current_buffer
, filename
)))
1136 already
= SAVE_MODIFF
< MODIFF
;
1137 if (!already
&& !NILP (flag
))
1139 else if (already
&& NILP (flag
))
1142 #endif /* CLASH_DETECTION */
1144 /* Here we have a problem. SAVE_MODIFF is used here to encode
1145 buffer-modified-p (as SAVE_MODIFF<MODIFF) as well as
1146 recent-auto-save-p (as SAVE_MODIFF<auto_save_modified). So if we
1147 modify SAVE_MODIFF to affect one, we may affect the other
1149 E.g. if FLAG is nil we need to set SAVE_MODIFF to MODIFF, but
1150 if SAVE_MODIFF<auto_save_modified that means we risk changing
1151 recent-auto-save-p from t to nil.
1152 Vice versa, if FLAG is non-nil and SAVE_MODIFF>=auto_save_modified
1153 we risk changing recent-auto-save-p from nil to t. */
1154 SAVE_MODIFF
= (NILP (flag
)
1155 /* FIXME: This unavoidably sets recent-auto-save-p to nil. */
1157 /* Let's try to preserve recent-auto-save-p. */
1158 : SAVE_MODIFF
< MODIFF
? SAVE_MODIFF
1159 /* If SAVE_MODIFF == auto_save_modified == MODIFF,
1160 we can either decrease SAVE_MODIFF and auto_save_modified
1161 or increase MODIFF. */
1164 /* Set update_mode_lines only if buffer is displayed in some window.
1165 Packages like jit-lock or lazy-lock preserve a buffer's modified
1166 state by recording/restoring the state around blocks of code.
1167 Setting update_mode_lines makes redisplay consider all windows
1168 (on all frames). Stealth fontification of buffers not displayed
1169 would incur additional redisplay costs if we'd set
1170 update_modes_lines unconditionally.
1172 Ideally, I think there should be another mechanism for fontifying
1173 buffers without "modifying" buffers, or redisplay should be
1174 smarter about updating the `*' in mode lines. --gerd */
1175 XSETBUFFER (buffer
, current_buffer
);
1176 window
= Fget_buffer_window (buffer
, Qt
);
1177 if (WINDOWP (window
))
1179 ++update_mode_lines
;
1180 current_buffer
->prevent_redisplay_optimizations_p
= 1;
1186 DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p
,
1187 Srestore_buffer_modified_p
, 1, 1, 0,
1188 doc
: /* Like `set-buffer-modified-p', with a difference concerning redisplay.
1189 It is not ensured that mode lines will be updated to show the modified
1190 state of the current buffer. Use with care. */)
1193 #ifdef CLASH_DETECTION
1196 /* If buffer becoming modified, lock the file.
1197 If buffer becoming unmodified, unlock the file. */
1199 fn
= BVAR (current_buffer
, file_truename
);
1200 /* Test buffer-file-name so that binding it to nil is effective. */
1201 if (!NILP (fn
) && ! NILP (BVAR (current_buffer
, filename
)))
1203 int already
= SAVE_MODIFF
< MODIFF
;
1204 if (!already
&& !NILP (flag
))
1206 else if (already
&& NILP (flag
))
1209 #endif /* CLASH_DETECTION */
1211 SAVE_MODIFF
= NILP (flag
) ? MODIFF
: 0;
1215 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick
, Sbuffer_modified_tick
,
1217 doc
: /* Return BUFFER's tick counter, incremented for each change in text.
1218 Each buffer has a tick counter which is incremented each time the
1219 text in that buffer is changed. It wraps around occasionally.
1220 No argument or nil as argument means use current buffer as BUFFER. */)
1221 (register Lisp_Object buffer
)
1223 register struct buffer
*buf
;
1225 buf
= current_buffer
;
1228 CHECK_BUFFER (buffer
);
1229 buf
= XBUFFER (buffer
);
1232 return make_number (BUF_MODIFF (buf
));
1235 DEFUN ("buffer-chars-modified-tick", Fbuffer_chars_modified_tick
,
1236 Sbuffer_chars_modified_tick
, 0, 1, 0,
1237 doc
: /* Return BUFFER's character-change tick counter.
1238 Each buffer has a character-change tick counter, which is set to the
1239 value of the buffer's tick counter \(see `buffer-modified-tick'), each
1240 time text in that buffer is inserted or deleted. By comparing the
1241 values returned by two individual calls of `buffer-chars-modified-tick',
1242 you can tell whether a character change occurred in that buffer in
1243 between these calls. No argument or nil as argument means use current
1244 buffer as BUFFER. */)
1245 (register Lisp_Object buffer
)
1247 register struct buffer
*buf
;
1249 buf
= current_buffer
;
1252 CHECK_BUFFER (buffer
);
1253 buf
= XBUFFER (buffer
);
1256 return make_number (BUF_CHARS_MODIFF (buf
));
1259 DEFUN ("rename-buffer", Frename_buffer
, Srename_buffer
, 1, 2,
1260 "(list (read-string \"Rename buffer (to new name): \" \
1261 nil 'buffer-name-history (buffer-name (current-buffer))) \
1262 current-prefix-arg)",
1263 doc
: /* Change current buffer's name to NEWNAME (a string).
1264 If second arg UNIQUE is nil or omitted, it is an error if a
1265 buffer named NEWNAME already exists.
1266 If UNIQUE is non-nil, come up with a new name using
1267 `generate-new-buffer-name'.
1268 Interactively, you can set UNIQUE with a prefix argument.
1269 We return the name we actually gave the buffer.
1270 This does not change the name of the visited file (if any). */)
1271 (register Lisp_Object newname
, Lisp_Object unique
)
1273 register Lisp_Object tem
, buf
;
1275 CHECK_STRING (newname
);
1277 if (SCHARS (newname
) == 0)
1278 error ("Empty string is invalid as a buffer name");
1280 tem
= Fget_buffer (newname
);
1283 /* Don't short-circuit if UNIQUE is t. That is a useful way to
1284 rename the buffer automatically so you can create another
1285 with the original name. It makes UNIQUE equivalent to
1286 (rename-buffer (generate-new-buffer-name NEWNAME)). */
1287 if (NILP (unique
) && XBUFFER (tem
) == current_buffer
)
1288 return BVAR (current_buffer
, name
);
1290 newname
= Fgenerate_new_buffer_name (newname
, BVAR (current_buffer
, name
));
1292 error ("Buffer name `%s' is in use", SDATA (newname
));
1295 BVAR (current_buffer
, name
) = newname
;
1297 /* Catch redisplay's attention. Unless we do this, the mode lines for
1298 any windows displaying current_buffer will stay unchanged. */
1299 update_mode_lines
++;
1301 XSETBUFFER (buf
, current_buffer
);
1302 Fsetcar (Frassq (buf
, Vbuffer_alist
), newname
);
1303 if (NILP (BVAR (current_buffer
, filename
))
1304 && !NILP (BVAR (current_buffer
, auto_save_file_name
)))
1305 call0 (intern ("rename-auto-save-file"));
1307 /* Run buffer-list-update-hook. */
1308 if (!NILP (Vrun_hooks
))
1309 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1311 /* Refetch since that last call may have done GC. */
1312 return BVAR (current_buffer
, name
);
1315 DEFUN ("other-buffer", Fother_buffer
, Sother_buffer
, 0, 3, 0,
1316 doc
: /* Return most recently selected buffer other than BUFFER.
1317 Buffers not visible in windows are preferred to visible buffers, unless
1318 optional second argument VISIBLE-OK is non-nil. Ignore the argument
1319 BUFFER unless it denotes a live buffer. If the optional third argument
1320 FRAME is non-nil, use that frame's buffer list instead of the selected
1321 frame's buffer list.
1323 The buffer is found by scanning the selected or specified frame's buffer
1324 list first, followed by the list of all buffers. If no other buffer
1325 exists, return the buffer `*scratch*' (creating it if necessary). */)
1326 (register Lisp_Object buffer
, Lisp_Object visible_ok
, Lisp_Object frame
)
1328 Lisp_Object
Fset_buffer_major_mode (Lisp_Object buffer
);
1329 Lisp_Object tail
, buf
, pred
;
1330 Lisp_Object notsogood
= Qnil
;
1333 frame
= selected_frame
;
1335 CHECK_FRAME (frame
);
1337 pred
= frame_buffer_predicate (frame
);
1338 /* Consider buffers that have been seen in the frame first. */
1339 tail
= XFRAME (frame
)->buffer_list
;
1340 for (; CONSP (tail
); tail
= XCDR (tail
))
1343 if (BUFFERP (buf
) && !EQ (buf
, buffer
)
1344 && !NILP (BVAR (XBUFFER (buf
), name
))
1345 && (SREF (BVAR (XBUFFER (buf
), name
), 0) != ' ')
1346 /* If the frame has a buffer_predicate, disregard buffers that
1347 don't fit the predicate. */
1348 && (NILP (pred
) || !NILP (call1 (pred
, buf
))))
1350 if (!NILP (visible_ok
)
1351 || NILP (Fget_buffer_window (buf
, Qvisible
)))
1353 else if (NILP (notsogood
))
1358 /* Consider alist of all buffers next. */
1359 tail
= Vbuffer_alist
;
1360 for (; CONSP (tail
); tail
= XCDR (tail
))
1362 buf
= Fcdr (XCAR (tail
));
1363 if (BUFFERP (buf
) && !EQ (buf
, buffer
)
1364 && !NILP (BVAR (XBUFFER (buf
), name
))
1365 && (SREF (BVAR (XBUFFER (buf
), name
), 0) != ' ')
1366 /* If the frame has a buffer_predicate, disregard buffers that
1367 don't fit the predicate. */
1368 && (NILP (pred
) || !NILP (call1 (pred
, buf
))))
1370 if (!NILP (visible_ok
)
1371 || NILP (Fget_buffer_window (buf
, Qvisible
)))
1373 else if (NILP (notsogood
))
1378 if (!NILP (notsogood
))
1382 buf
= Fget_buffer (build_string ("*scratch*"));
1385 buf
= Fget_buffer_create (build_string ("*scratch*"));
1386 Fset_buffer_major_mode (buf
);
1392 /* The following function is a safe variant of Fother_buffer: It doesn't
1393 pay attention to any frame-local buffer lists, doesn't care about
1394 visibility of buffers, and doesn't evaluate any frame predicates. */
1397 other_buffer_safely (Lisp_Object buffer
)
1399 Lisp_Object
Fset_buffer_major_mode (Lisp_Object buffer
);
1400 Lisp_Object tail
, buf
;
1402 tail
= Vbuffer_alist
;
1403 for (; CONSP (tail
); tail
= XCDR (tail
))
1405 buf
= Fcdr (XCAR (tail
));
1406 if (BUFFERP (buf
) && !EQ (buf
, buffer
)
1407 && !NILP (BVAR (XBUFFER (buf
), name
))
1408 && (SREF (BVAR (XBUFFER (buf
), name
), 0) != ' '))
1412 buf
= Fget_buffer (build_string ("*scratch*"));
1415 buf
= Fget_buffer_create (build_string ("*scratch*"));
1416 Fset_buffer_major_mode (buf
);
1422 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo
, Sbuffer_enable_undo
,
1424 doc
: /* Start keeping undo information for buffer BUFFER.
1425 No argument or nil as argument means do this for the current buffer. */)
1426 (register Lisp_Object buffer
)
1428 Lisp_Object real_buffer
;
1431 XSETBUFFER (real_buffer
, current_buffer
);
1434 real_buffer
= Fget_buffer (buffer
);
1435 if (NILP (real_buffer
))
1439 if (EQ (BVAR (XBUFFER (real_buffer
), undo_list
), Qt
))
1440 BVAR (XBUFFER (real_buffer
), undo_list
) = Qnil
;
1445 /* Truncate undo list and shrink the gap of BUFFER. */
1448 compact_buffer (struct buffer
*buffer
)
1450 /* Verify indirection counters. */
1451 if (buffer
->base_buffer
)
1453 eassert (buffer
->indirections
== -1);
1454 eassert (buffer
->base_buffer
->indirections
> 0);
1457 eassert (buffer
->indirections
>= 0);
1459 /* Skip dead buffers, indirect buffers and buffers
1460 which aren't changed since last compaction. */
1461 if (!NILP (buffer
->BUFFER_INTERNAL_FIELD (name
))
1462 && (buffer
->base_buffer
== NULL
)
1463 && (buffer
->text
->compact
!= buffer
->text
->modiff
))
1465 /* If a buffer's undo list is Qt, that means that undo is
1466 turned off in that buffer. Calling truncate_undo_list on
1467 Qt tends to return NULL, which effectively turns undo back on.
1468 So don't call truncate_undo_list if undo_list is Qt. */
1469 if (!EQ (buffer
->BUFFER_INTERNAL_FIELD (undo_list
), Qt
))
1470 truncate_undo_list (buffer
);
1472 /* Shrink buffer gaps. */
1473 if (!buffer
->text
->inhibit_shrinking
)
1475 /* If a buffer's gap size is more than 10% of the buffer
1476 size, or larger than 2000 bytes, then shrink it
1477 accordingly. Keep a minimum size of 20 bytes. */
1478 int size
= min (2000, max (20, (buffer
->text
->z_byte
/ 10)));
1480 if (buffer
->text
->gap_size
> size
)
1482 struct buffer
*save_current
= current_buffer
;
1483 current_buffer
= buffer
;
1484 make_gap (-(buffer
->text
->gap_size
- size
));
1485 current_buffer
= save_current
;
1488 buffer
->text
->compact
= buffer
->text
->modiff
;
1494 DEFUN ("kill-buffer", Fkill_buffer
, Skill_buffer
, 0, 1, "bKill buffer: ",
1495 doc
: /* Kill the buffer specified by BUFFER-OR-NAME.
1496 The argument may be a buffer or the name of an existing buffer.
1497 Argument nil or omitted means kill the current buffer. Return t if the
1498 buffer is actually killed, nil otherwise.
1500 The functions in `kill-buffer-query-functions' are called with the
1501 buffer to be killed as the current buffer. If any of them returns nil,
1502 the buffer is not killed. The hook `kill-buffer-hook' is run before the
1503 buffer is actually killed. The buffer being killed will be current
1504 while the hook is running. Functions called by any of these hooks are
1505 supposed to not change the current buffer.
1507 Any processes that have this buffer as the `process-buffer' are killed
1508 with SIGHUP. This function calls `replace-buffer-in-windows' for
1509 cleaning up all windows currently displaying the buffer to be killed. */)
1510 (Lisp_Object buffer_or_name
)
1513 register struct buffer
*b
;
1514 register Lisp_Object tem
;
1515 register struct Lisp_Marker
*m
;
1516 struct gcpro gcpro1
;
1518 if (NILP (buffer_or_name
))
1519 buffer
= Fcurrent_buffer ();
1521 buffer
= Fget_buffer (buffer_or_name
);
1523 nsberror (buffer_or_name
);
1525 b
= XBUFFER (buffer
);
1527 /* Avoid trouble for buffer already dead. */
1528 if (NILP (BVAR (b
, name
)))
1531 /* Query if the buffer is still modified. */
1532 if (INTERACTIVE
&& !NILP (BVAR (b
, filename
))
1533 && BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
1536 tem
= do_yes_or_no_p (format2 ("Buffer %s modified; kill anyway? ",
1537 BVAR (b
, name
), make_number (0)));
1543 /* Run hooks with the buffer to be killed the current buffer. */
1545 ptrdiff_t count
= SPECPDL_INDEX ();
1546 Lisp_Object arglist
[1];
1548 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1549 set_buffer_internal (b
);
1551 /* First run the query functions; if any query is answered no,
1552 don't kill the buffer. */
1553 arglist
[0] = Qkill_buffer_query_functions
;
1554 tem
= Frun_hook_with_args_until_failure (1, arglist
);
1556 return unbind_to (count
, Qnil
);
1558 /* Then run the hooks. */
1559 Frun_hooks (1, &Qkill_buffer_hook
);
1560 unbind_to (count
, Qnil
);
1563 /* If the hooks have killed the buffer, exit now. */
1564 if (NILP (BVAR (b
, name
)))
1567 /* We have no more questions to ask. Verify that it is valid
1568 to kill the buffer. This must be done after the questions
1569 since anything can happen within do_yes_or_no_p. */
1571 /* Don't kill the minibuffer now current. */
1572 if (EQ (buffer
, XWINDOW (minibuf_window
)->buffer
))
1575 /* Notify our base buffer that we don't share the text anymore. */
1578 eassert (b
->indirections
== -1);
1579 b
->base_buffer
->indirections
--;
1580 eassert (b
->base_buffer
->indirections
>= 0);
1583 /* When we kill an ordinary buffer which shares it's buffer text
1584 with indirect buffer(s), we must kill indirect buffer(s) too.
1585 We do it at this stage so nothing terrible happens if they
1586 ask questions or their hooks get errors. */
1587 if (!b
->base_buffer
&& b
->indirections
> 0)
1589 struct buffer
*other
;
1593 FOR_EACH_BUFFER (other
)
1594 if (other
->base_buffer
== b
)
1597 XSETBUFFER (buf
, other
);
1603 /* Exit if we now have killed the base buffer (Bug#11665). */
1604 if (NILP (BVAR (b
, name
)))
1608 /* Run replace_buffer_in_windows before making another buffer current
1609 since set-window-buffer-start-and-point will refuse to make another
1610 buffer current if the selected window does not show the current
1611 buffer. (Bug#10114) */
1612 replace_buffer_in_windows (buffer
);
1614 /* Exit if replacing the buffer in windows has killed our buffer. */
1615 if (NILP (BVAR (b
, name
)))
1618 /* Make this buffer not be current. Exit if it is the sole visible
1620 if (b
== current_buffer
)
1622 tem
= Fother_buffer (buffer
, Qnil
, Qnil
);
1624 if (b
== current_buffer
)
1628 /* If the buffer now current is shown in the minibuffer and our buffer
1629 is the sole other buffer give up. */
1630 XSETBUFFER (tem
, current_buffer
);
1631 if (EQ (tem
, XWINDOW (minibuf_window
)->buffer
)
1632 && EQ (buffer
, Fother_buffer (buffer
, Qnil
, Qnil
)))
1635 /* Now there is no question: we can kill the buffer. */
1637 #ifdef CLASH_DETECTION
1638 /* Unlock this buffer's file, if it is locked. */
1640 #endif /* CLASH_DETECTION */
1643 kill_buffer_processes (buffer
);
1646 /* Killing buffer processes may run sentinels which may have killed
1648 if (NILP (BVAR (b
, name
)))
1651 /* These may run Lisp code and into infinite loops (if someone
1652 insisted on circular lists) so allow quitting here. */
1653 frames_discard_buffer (buffer
);
1655 clear_charpos_cache (b
);
1657 tem
= Vinhibit_quit
;
1659 /* Remove the buffer from the list of all buffers. */
1660 Vbuffer_alist
= Fdelq (Frassq (buffer
, Vbuffer_alist
), Vbuffer_alist
);
1661 /* If replace_buffer_in_windows didn't do its job fix that now. */
1662 replace_buffer_in_windows_safely (buffer
);
1663 Vinhibit_quit
= tem
;
1665 /* Delete any auto-save file, if we saved it in this session.
1666 But not if the buffer is modified. */
1667 if (STRINGP (BVAR (b
, auto_save_file_name
))
1668 && BUF_AUTOSAVE_MODIFF (b
) != 0
1669 && BUF_SAVE_MODIFF (b
) < BUF_AUTOSAVE_MODIFF (b
)
1670 && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
)
1671 && NILP (Fsymbol_value (intern ("auto-save-visited-file-name"))))
1674 delete = Fsymbol_value (intern ("delete-auto-save-files"));
1675 if (! NILP (delete))
1676 internal_delete_file (BVAR (b
, auto_save_file_name
));
1679 /* Deleting an auto-save file could have killed our buffer. */
1680 if (NILP (BVAR (b
, name
)))
1685 /* Unchain all markers that belong to this indirect buffer.
1686 Don't unchain the markers that belong to the base buffer
1687 or its other indirect buffers. */
1688 for (m
= BUF_MARKERS (b
); m
; )
1690 struct Lisp_Marker
*next
= m
->next
;
1698 /* Unchain all markers of this buffer and its indirect buffers.
1699 and leave them pointing nowhere. */
1700 for (m
= BUF_MARKERS (b
); m
; )
1702 struct Lisp_Marker
*next
= m
->next
;
1707 BUF_MARKERS (b
) = NULL
;
1708 BUF_INTERVALS (b
) = NULL_INTERVAL
;
1710 /* Perhaps we should explicitly free the interval tree here... */
1713 /* Reset the local variables, so that this buffer's local values
1714 won't be protected from GC. They would be protected
1715 if they happened to remain cached in their symbols.
1716 This gets rid of them for certain. */
1717 swap_out_buffer_local_variables (b
);
1718 reset_buffer_local_variables (b
, 1);
1720 BVAR (b
, name
) = Qnil
;
1723 if (! b
->base_buffer
)
1724 free_buffer_text (b
);
1726 if (b
->newline_cache
)
1728 free_region_cache (b
->newline_cache
);
1729 b
->newline_cache
= 0;
1731 if (b
->width_run_cache
)
1733 free_region_cache (b
->width_run_cache
);
1734 b
->width_run_cache
= 0;
1736 BVAR (b
, width_table
) = Qnil
;
1738 BVAR (b
, undo_list
) = Qnil
;
1740 /* Run buffer-list-update-hook. */
1741 if (!NILP (Vrun_hooks
))
1742 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1747 /* Move association for BUFFER to the front of buffer (a)lists. Since
1748 we do this each time BUFFER is selected visibly, the more recently
1749 selected buffers are always closer to the front of those lists. This
1750 means that other_buffer is more likely to choose a relevant buffer.
1752 Note that this moves BUFFER to the front of the buffer lists of the
1753 selected frame even if BUFFER is not shown there. If BUFFER is not
1754 shown in the selected frame, consider the present behavior a feature.
1755 `select-window' gets this right since it shows BUFFER in the selected
1756 window when calling us. */
1759 record_buffer (Lisp_Object buffer
)
1761 Lisp_Object aelt
, aelt_cons
, tem
;
1762 register struct frame
*f
= XFRAME (selected_frame
);
1764 CHECK_BUFFER (buffer
);
1766 /* Update Vbuffer_alist (we know that it has an entry for BUFFER).
1767 Don't allow quitting since this might leave the buffer list in an
1768 inconsistent state. */
1769 tem
= Vinhibit_quit
;
1771 aelt
= Frassq (buffer
, Vbuffer_alist
);
1772 aelt_cons
= Fmemq (aelt
, Vbuffer_alist
);
1773 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
1774 XSETCDR (aelt_cons
, Vbuffer_alist
);
1775 Vbuffer_alist
= aelt_cons
;
1776 Vinhibit_quit
= tem
;
1778 /* Update buffer list of selected frame. */
1779 f
->buffer_list
= Fcons (buffer
, Fdelq (buffer
, f
->buffer_list
));
1780 f
->buried_buffer_list
= Fdelq (buffer
, f
->buried_buffer_list
);
1782 /* Run buffer-list-update-hook. */
1783 if (!NILP (Vrun_hooks
))
1784 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1788 /* Move BUFFER to the end of the buffer (a)lists. Do nothing if the
1789 buffer is killed. For the selected frame's buffer list this moves
1790 BUFFER to its end even if it was never shown in that frame. If
1791 this happens we have a feature, hence `bury-buffer-internal' should be
1792 called only when BUFFER was shown in the selected frame. */
1794 DEFUN ("bury-buffer-internal", Fbury_buffer_internal
, Sbury_buffer_internal
,
1796 doc
: /* Move BUFFER to the end of the buffer list. */)
1797 (Lisp_Object buffer
)
1799 Lisp_Object aelt
, aelt_cons
, tem
;
1800 register struct frame
*f
= XFRAME (selected_frame
);
1802 CHECK_BUFFER (buffer
);
1804 /* Update Vbuffer_alist (we know that it has an entry for BUFFER).
1805 Don't allow quitting since this might leave the buffer list in an
1806 inconsistent state. */
1807 tem
= Vinhibit_quit
;
1809 aelt
= Frassq (buffer
, Vbuffer_alist
);
1810 aelt_cons
= Fmemq (aelt
, Vbuffer_alist
);
1811 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
1812 XSETCDR (aelt_cons
, Qnil
);
1813 Vbuffer_alist
= nconc2 (Vbuffer_alist
, aelt_cons
);
1814 Vinhibit_quit
= tem
;
1816 /* Update buffer lists of selected frame. */
1817 f
->buffer_list
= Fdelq (buffer
, f
->buffer_list
);
1818 f
->buried_buffer_list
= Fcons (buffer
, Fdelq (buffer
, f
->buried_buffer_list
));
1820 /* Run buffer-list-update-hook. */
1821 if (!NILP (Vrun_hooks
))
1822 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1827 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode
, Sset_buffer_major_mode
, 1, 1, 0,
1828 doc
: /* Set an appropriate major mode for BUFFER.
1829 For the *scratch* buffer, use `initial-major-mode', otherwise choose a mode
1830 according to `default-major-mode'.
1831 Use this function before selecting the buffer, since it may need to inspect
1832 the current buffer's major mode. */)
1833 (Lisp_Object buffer
)
1836 Lisp_Object function
;
1838 CHECK_BUFFER (buffer
);
1840 if (STRINGP (BVAR (XBUFFER (buffer
), name
))
1841 && strcmp (SSDATA (BVAR (XBUFFER (buffer
), name
)), "*scratch*") == 0)
1842 function
= find_symbol_value (intern ("initial-major-mode"));
1845 function
= BVAR (&buffer_defaults
, major_mode
);
1847 && NILP (Fget (BVAR (current_buffer
, major_mode
), Qmode_class
)))
1848 function
= BVAR (current_buffer
, major_mode
);
1851 if (NILP (function
) || EQ (function
, Qfundamental_mode
))
1854 count
= SPECPDL_INDEX ();
1856 /* To select a nonfundamental mode,
1857 select the buffer temporarily and then call the mode function. */
1859 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1861 Fset_buffer (buffer
);
1864 return unbind_to (count
, Qnil
);
1867 DEFUN ("current-buffer", Fcurrent_buffer
, Scurrent_buffer
, 0, 0, 0,
1868 doc
: /* Return the current buffer as a Lisp object. */)
1871 register Lisp_Object buf
;
1872 XSETBUFFER (buf
, current_buffer
);
1876 /* Set the current buffer to B.
1878 We previously set windows_or_buffers_changed here to invalidate
1879 global unchanged information in beg_unchanged and end_unchanged.
1880 This is no longer necessary because we now compute unchanged
1881 information on a buffer-basis. Every action affecting other
1882 windows than the selected one requires a select_window at some
1883 time, and that increments windows_or_buffers_changed. */
1886 set_buffer_internal (register struct buffer
*b
)
1888 if (current_buffer
!= b
)
1889 set_buffer_internal_1 (b
);
1892 /* Set the current buffer to B, and do not set windows_or_buffers_changed.
1893 This is used by redisplay. */
1896 set_buffer_internal_1 (register struct buffer
*b
)
1898 register struct buffer
*old_buf
;
1899 register Lisp_Object tail
;
1901 #ifdef USE_MMAP_FOR_BUFFERS
1902 if (b
->text
->beg
== NULL
)
1903 enlarge_buffer_text (b
, 0);
1904 #endif /* USE_MMAP_FOR_BUFFERS */
1906 if (current_buffer
== b
)
1909 old_buf
= current_buffer
;
1911 last_known_column_point
= -1; /* invalidate indentation cache */
1915 /* Put the undo list back in the base buffer, so that it appears
1916 that an indirect buffer shares the undo list of its base. */
1917 if (old_buf
->base_buffer
)
1918 BVAR (old_buf
->base_buffer
, undo_list
) = BVAR (old_buf
, undo_list
);
1920 /* If the old current buffer has markers to record PT, BEGV and ZV
1921 when it is not current, update them now. */
1922 record_buffer_markers (old_buf
);
1925 /* Get the undo list from the base buffer, so that it appears
1926 that an indirect buffer shares the undo list of its base. */
1928 BVAR (b
, undo_list
) = BVAR (b
->base_buffer
, undo_list
);
1930 /* If the new current buffer has markers to record PT, BEGV and ZV
1931 when it is not current, fetch them now. */
1932 fetch_buffer_markers (b
);
1934 /* Look down buffer's list of local Lisp variables
1935 to find and update any that forward into C variables. */
1939 for (tail
= BVAR (b
, local_var_alist
); CONSP (tail
); tail
= XCDR (tail
))
1941 Lisp_Object var
= XCAR (XCAR (tail
));
1942 struct Lisp_Symbol
*sym
= XSYMBOL (var
);
1943 if (sym
->redirect
== SYMBOL_LOCALIZED
/* Just to be sure. */
1944 && SYMBOL_BLV (sym
)->fwd
)
1945 /* Just reference the variable
1946 to cause it to become set for this buffer. */
1947 Fsymbol_value (var
);
1950 /* Do the same with any others that were local to the previous buffer */
1951 while (b
!= old_buf
&& (b
= old_buf
, b
));
1954 /* Switch to buffer B temporarily for redisplay purposes.
1955 This avoids certain things that don't need to be done within redisplay. */
1958 set_buffer_temp (struct buffer
*b
)
1960 register struct buffer
*old_buf
;
1962 if (current_buffer
== b
)
1965 old_buf
= current_buffer
;
1968 /* If the old current buffer has markers to record PT, BEGV and ZV
1969 when it is not current, update them now. */
1970 record_buffer_markers (old_buf
);
1972 /* If the new current buffer has markers to record PT, BEGV and ZV
1973 when it is not current, fetch them now. */
1974 fetch_buffer_markers (b
);
1977 DEFUN ("set-buffer", Fset_buffer
, Sset_buffer
, 1, 1, 0,
1978 doc
: /* Make buffer BUFFER-OR-NAME current for editing operations.
1979 BUFFER-OR-NAME may be a buffer or the name of an existing buffer. See
1980 also `save-excursion' when you want to make a buffer current
1981 temporarily. This function does not display the buffer, so its effect
1982 ends when the current command terminates. Use `switch-to-buffer' or
1983 `pop-to-buffer' to switch buffers permanently. */)
1984 (register Lisp_Object buffer_or_name
)
1986 register Lisp_Object buffer
;
1987 buffer
= Fget_buffer (buffer_or_name
);
1989 nsberror (buffer_or_name
);
1990 if (NILP (BVAR (XBUFFER (buffer
), name
)))
1991 error ("Selecting deleted buffer");
1992 set_buffer_internal (XBUFFER (buffer
));
1996 /* Set the current buffer to BUFFER provided it is alive. */
1999 set_buffer_if_live (Lisp_Object buffer
)
2001 if (! NILP (BVAR (XBUFFER (buffer
), name
)))
2002 Fset_buffer (buffer
);
2006 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only
,
2007 Sbarf_if_buffer_read_only
, 0, 0, 0,
2008 doc
: /* Signal a `buffer-read-only' error if the current buffer is read-only. */)
2011 if (!NILP (BVAR (current_buffer
, read_only
))
2012 && NILP (Vinhibit_read_only
))
2013 xsignal1 (Qbuffer_read_only
, Fcurrent_buffer ());
2017 DEFUN ("erase-buffer", Ferase_buffer
, Serase_buffer
, 0, 0, "*",
2018 doc
: /* Delete the entire contents of the current buffer.
2019 Any narrowing restriction in effect (see `narrow-to-region') is removed,
2020 so the buffer is truly empty after this. */)
2027 current_buffer
->last_window_start
= 1;
2028 /* Prevent warnings, or suspension of auto saving, that would happen
2029 if future size is less than past size. Use of erase-buffer
2030 implies that the future text is not really related to the past text. */
2031 XSETFASTINT (BVAR (current_buffer
, save_length
), 0);
2036 validate_region (register Lisp_Object
*b
, register Lisp_Object
*e
)
2038 CHECK_NUMBER_COERCE_MARKER (*b
);
2039 CHECK_NUMBER_COERCE_MARKER (*e
);
2041 if (XINT (*b
) > XINT (*e
))
2044 tem
= *b
; *b
= *e
; *e
= tem
;
2047 if (! (BEGV
<= XINT (*b
) && XINT (*e
) <= ZV
))
2048 args_out_of_range (*b
, *e
);
2051 /* Advance BYTE_POS up to a character boundary
2052 and return the adjusted position. */
2055 advance_to_char_boundary (ptrdiff_t byte_pos
)
2059 if (byte_pos
== BEG
)
2060 /* Beginning of buffer is always a character boundary. */
2063 c
= FETCH_BYTE (byte_pos
);
2064 if (! CHAR_HEAD_P (c
))
2066 /* We should advance BYTE_POS only when C is a constituent of a
2067 multibyte sequence. */
2068 ptrdiff_t orig_byte_pos
= byte_pos
;
2073 c
= FETCH_BYTE (byte_pos
);
2075 while (! CHAR_HEAD_P (c
) && byte_pos
> BEG
);
2077 if (byte_pos
< orig_byte_pos
)
2078 byte_pos
= orig_byte_pos
;
2079 /* If C is a constituent of a multibyte sequence, BYTE_POS was
2080 surely advance to the correct character boundary. If C is
2081 not, BYTE_POS was unchanged. */
2087 DEFUN ("buffer-swap-text", Fbuffer_swap_text
, Sbuffer_swap_text
,
2089 doc
: /* Swap the text between current buffer and BUFFER. */)
2090 (Lisp_Object buffer
)
2092 struct buffer
*other_buffer
;
2093 CHECK_BUFFER (buffer
);
2094 other_buffer
= XBUFFER (buffer
);
2096 if (NILP (BVAR (other_buffer
, name
)))
2097 error ("Cannot swap a dead buffer's text");
2099 /* Actually, it probably works just fine.
2100 * if (other_buffer == current_buffer)
2101 * error ("Cannot swap a buffer's text with itself"); */
2103 /* Actually, this may be workable as well, tho probably only if they're
2105 if (other_buffer
->base_buffer
2106 || current_buffer
->base_buffer
)
2107 error ("Cannot swap indirect buffers's text");
2109 { /* This is probably harder to make work. */
2110 struct buffer
*other
;
2111 FOR_EACH_BUFFER (other
)
2112 if (other
->base_buffer
== other_buffer
2113 || other
->base_buffer
== current_buffer
)
2114 error ("One of the buffers to swap has indirect buffers");
2117 #define swapfield(field, type) \
2119 type tmp##field = other_buffer->field; \
2120 other_buffer->field = current_buffer->field; \
2121 current_buffer->field = tmp##field; \
2123 #define swapfield_(field, type) \
2125 type tmp##field = BVAR (other_buffer, field); \
2126 BVAR (other_buffer, field) = BVAR (current_buffer, field); \
2127 BVAR (current_buffer, field) = tmp##field; \
2130 swapfield (own_text
, struct buffer_text
);
2131 eassert (current_buffer
->text
== ¤t_buffer
->own_text
);
2132 eassert (other_buffer
->text
== &other_buffer
->own_text
);
2134 r_alloc_reset_variable ((void **) ¤t_buffer
->own_text
.beg
,
2135 (void **) &other_buffer
->own_text
.beg
);
2136 r_alloc_reset_variable ((void **) &other_buffer
->own_text
.beg
,
2137 (void **) ¤t_buffer
->own_text
.beg
);
2138 #endif /* REL_ALLOC */
2140 swapfield (pt
, ptrdiff_t);
2141 swapfield (pt_byte
, ptrdiff_t);
2142 swapfield (begv
, ptrdiff_t);
2143 swapfield (begv_byte
, ptrdiff_t);
2144 swapfield (zv
, ptrdiff_t);
2145 swapfield (zv_byte
, ptrdiff_t);
2146 eassert (!current_buffer
->base_buffer
);
2147 eassert (!other_buffer
->base_buffer
);
2148 current_buffer
->clip_changed
= 1; other_buffer
->clip_changed
= 1;
2149 swapfield (newline_cache
, struct region_cache
*);
2150 swapfield (width_run_cache
, struct region_cache
*);
2151 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2152 other_buffer
->prevent_redisplay_optimizations_p
= 1;
2153 swapfield (overlays_before
, struct Lisp_Overlay
*);
2154 swapfield (overlays_after
, struct Lisp_Overlay
*);
2155 swapfield (overlay_center
, ptrdiff_t);
2156 swapfield_ (undo_list
, Lisp_Object
);
2157 swapfield_ (mark
, Lisp_Object
);
2158 swapfield_ (enable_multibyte_characters
, Lisp_Object
);
2159 swapfield_ (bidi_display_reordering
, Lisp_Object
);
2160 swapfield_ (bidi_paragraph_direction
, Lisp_Object
);
2161 /* FIXME: Not sure what we should do with these *_marker fields.
2162 Hopefully they're just nil anyway. */
2163 swapfield_ (pt_marker
, Lisp_Object
);
2164 swapfield_ (begv_marker
, Lisp_Object
);
2165 swapfield_ (zv_marker
, Lisp_Object
);
2166 BVAR (current_buffer
, point_before_scroll
) = Qnil
;
2167 BVAR (other_buffer
, point_before_scroll
) = Qnil
;
2169 current_buffer
->text
->modiff
++; other_buffer
->text
->modiff
++;
2170 current_buffer
->text
->chars_modiff
++; other_buffer
->text
->chars_modiff
++;
2171 current_buffer
->text
->overlay_modiff
++; other_buffer
->text
->overlay_modiff
++;
2172 current_buffer
->text
->beg_unchanged
= current_buffer
->text
->gpt
;
2173 current_buffer
->text
->end_unchanged
= current_buffer
->text
->gpt
;
2174 other_buffer
->text
->beg_unchanged
= other_buffer
->text
->gpt
;
2175 other_buffer
->text
->end_unchanged
= other_buffer
->text
->gpt
;
2177 struct Lisp_Marker
*m
;
2178 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
2179 if (m
->buffer
== other_buffer
)
2180 m
->buffer
= current_buffer
;
2182 /* Since there's no indirect buffer in sight, markers on
2183 BUF_MARKERS(buf) should either be for `buf' or dead. */
2184 eassert (!m
->buffer
);
2185 for (m
= BUF_MARKERS (other_buffer
); m
; m
= m
->next
)
2186 if (m
->buffer
== current_buffer
)
2187 m
->buffer
= other_buffer
;
2189 /* Since there's no indirect buffer in sight, markers on
2190 BUF_MARKERS(buf) should either be for `buf' or dead. */
2191 eassert (!m
->buffer
);
2193 { /* Some of the C code expects that w->buffer == w->pointm->buffer.
2194 So since we just swapped the markers between the two buffers, we need
2195 to undo the effect of this swap for window markers. */
2196 Lisp_Object w
= Fselected_window (), ws
= Qnil
;
2197 Lisp_Object buf1
, buf2
;
2198 XSETBUFFER (buf1
, current_buffer
); XSETBUFFER (buf2
, other_buffer
);
2200 while (NILP (Fmemq (w
, ws
)))
2203 if (MARKERP (XWINDOW (w
)->pointm
)
2204 && (EQ (XWINDOW (w
)->buffer
, buf1
)
2205 || EQ (XWINDOW (w
)->buffer
, buf2
)))
2206 Fset_marker (XWINDOW (w
)->pointm
,
2207 make_number (BUF_BEGV (XBUFFER (XWINDOW (w
)->buffer
))),
2208 XWINDOW (w
)->buffer
);
2209 w
= Fnext_window (w
, Qt
, Qt
);
2213 if (current_buffer
->text
->intervals
)
2214 (eassert (EQ (current_buffer
->text
->intervals
->up
.obj
, buffer
)),
2215 XSETBUFFER (current_buffer
->text
->intervals
->up
.obj
, current_buffer
));
2216 if (other_buffer
->text
->intervals
)
2217 (eassert (EQ (other_buffer
->text
->intervals
->up
.obj
, Fcurrent_buffer ())),
2218 XSETBUFFER (other_buffer
->text
->intervals
->up
.obj
, other_buffer
));
2223 DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte
, Sset_buffer_multibyte
,
2225 doc
: /* Set the multibyte flag of the current buffer to FLAG.
2226 If FLAG is t, this makes the buffer a multibyte buffer.
2227 If FLAG is nil, this makes the buffer a single-byte buffer.
2228 In these cases, the buffer contents remain unchanged as a sequence of
2229 bytes but the contents viewed as characters do change.
2230 If FLAG is `to', this makes the buffer a multibyte buffer by changing
2231 all eight-bit bytes to eight-bit characters.
2232 If the multibyte flag was really changed, undo information of the
2233 current buffer is cleared. */)
2236 struct Lisp_Marker
*tail
, *markers
;
2237 struct buffer
*other
;
2239 int narrowed
= (BEG
!= BEGV
|| Z
!= ZV
);
2240 int modified_p
= !NILP (Fbuffer_modified_p (Qnil
));
2241 Lisp_Object old_undo
= BVAR (current_buffer
, undo_list
);
2242 struct gcpro gcpro1
;
2244 if (current_buffer
->base_buffer
)
2245 error ("Cannot do `set-buffer-multibyte' on an indirect buffer");
2247 /* Do nothing if nothing actually changes. */
2248 if (NILP (flag
) == NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
2253 /* Don't record these buffer changes. We will put a special undo entry
2255 BVAR (current_buffer
, undo_list
) = Qt
;
2257 /* If the cached position is for this buffer, clear it out. */
2258 clear_charpos_cache (current_buffer
);
2261 begv
= BEGV_BYTE
, zv
= ZV_BYTE
;
2263 begv
= BEGV
, zv
= ZV
;
2270 ptrdiff_t pos
, stop
;
2273 /* Do this first, so it can use CHAR_TO_BYTE
2274 to calculate the old correspondences. */
2275 set_intervals_multibyte (0);
2277 BVAR (current_buffer
, enable_multibyte_characters
) = Qnil
;
2283 TEMP_SET_PT_BOTH (PT_BYTE
, PT_BYTE
);
2286 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
2287 tail
->charpos
= tail
->bytepos
;
2289 /* Convert multibyte form of 8-bit characters to unibyte. */
2304 if (ASCII_BYTE_P (*p
))
2306 else if (CHAR_BYTE8_HEAD_P (*p
))
2308 c
= STRING_CHAR_AND_LENGTH (p
, bytes
);
2309 /* Delete all bytes for this 8-bit character but the
2310 last one, and change the last one to the character
2313 del_range_2 (pos
, pos
, pos
+ bytes
, pos
+ bytes
, 0);
2325 bytes
= BYTES_BY_CHAR_HEAD (*p
);
2326 p
+= bytes
, pos
+= bytes
;
2330 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2335 ptrdiff_t pos
, stop
;
2336 unsigned char *p
, *pend
;
2338 /* Be sure not to have a multibyte sequence striding over the GAP.
2339 Ex: We change this: "...abc\302 _GAP_ \241def..."
2340 to: "...abc _GAP_ \302\241def..." */
2343 && GPT_BYTE
> 1 && GPT_BYTE
< Z_BYTE
2344 && ! CHAR_HEAD_P (*(GAP_END_ADDR
)))
2346 unsigned char *q
= GPT_ADDR
- 1;
2348 while (! CHAR_HEAD_P (*q
) && q
> BEG_ADDR
) q
--;
2349 if (LEADING_CODE_P (*q
))
2351 ptrdiff_t new_gpt
= GPT_BYTE
- (GPT_ADDR
- q
);
2353 move_gap_both (new_gpt
, new_gpt
);
2357 /* Make the buffer contents valid as multibyte by converting
2358 8-bit characters to multibyte form. */
2376 if (ASCII_BYTE_P (*p
))
2378 else if (EQ (flag
, Qt
)
2379 && ! CHAR_BYTE8_HEAD_P (*p
)
2380 && (bytes
= MULTIBYTE_LENGTH (p
, pend
)) > 0)
2381 p
+= bytes
, pos
+= bytes
;
2384 unsigned char tmp
[MAX_MULTIBYTE_LENGTH
];
2387 c
= BYTE8_TO_CHAR (*p
);
2388 bytes
= CHAR_STRING (c
, tmp
);
2390 TEMP_SET_PT_BOTH (pos
+ 1, pos
+ 1);
2392 insert_1_both ((char *) tmp
+ 1, bytes
, bytes
, 1, 0, 0);
2393 /* Now the gap is after the just inserted data. */
2411 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2413 /* Do this first, so that chars_in_text asks the right question.
2414 set_intervals_multibyte needs it too. */
2415 BVAR (current_buffer
, enable_multibyte_characters
) = Qt
;
2417 GPT_BYTE
= advance_to_char_boundary (GPT_BYTE
);
2418 GPT
= chars_in_text (BEG_ADDR
, GPT_BYTE
- BEG_BYTE
) + BEG
;
2420 Z
= chars_in_text (GAP_END_ADDR
, Z_BYTE
- GPT_BYTE
) + GPT
;
2422 BEGV_BYTE
= advance_to_char_boundary (BEGV_BYTE
);
2423 if (BEGV_BYTE
> GPT_BYTE
)
2424 BEGV
= chars_in_text (GAP_END_ADDR
, BEGV_BYTE
- GPT_BYTE
) + GPT
;
2426 BEGV
= chars_in_text (BEG_ADDR
, BEGV_BYTE
- BEG_BYTE
) + BEG
;
2428 ZV_BYTE
= advance_to_char_boundary (ZV_BYTE
);
2429 if (ZV_BYTE
> GPT_BYTE
)
2430 ZV
= chars_in_text (GAP_END_ADDR
, ZV_BYTE
- GPT_BYTE
) + GPT
;
2432 ZV
= chars_in_text (BEG_ADDR
, ZV_BYTE
- BEG_BYTE
) + BEG
;
2435 ptrdiff_t byte
= advance_to_char_boundary (PT_BYTE
);
2438 if (byte
> GPT_BYTE
)
2439 position
= chars_in_text (GAP_END_ADDR
, byte
- GPT_BYTE
) + GPT
;
2441 position
= chars_in_text (BEG_ADDR
, byte
- BEG_BYTE
) + BEG
;
2442 TEMP_SET_PT_BOTH (position
, byte
);
2445 tail
= markers
= BUF_MARKERS (current_buffer
);
2447 /* This prevents BYTE_TO_CHAR (that is, buf_bytepos_to_charpos) from
2448 getting confused by the markers that have not yet been updated.
2449 It is also a signal that it should never create a marker. */
2450 BUF_MARKERS (current_buffer
) = NULL
;
2452 for (; tail
; tail
= tail
->next
)
2454 tail
->bytepos
= advance_to_char_boundary (tail
->bytepos
);
2455 tail
->charpos
= BYTE_TO_CHAR (tail
->bytepos
);
2458 /* Make sure no markers were put on the chain
2459 while the chain value was incorrect. */
2460 if (BUF_MARKERS (current_buffer
))
2463 BUF_MARKERS (current_buffer
) = markers
;
2465 /* Do this last, so it can calculate the new correspondences
2466 between chars and bytes. */
2467 set_intervals_multibyte (1);
2470 if (!EQ (old_undo
, Qt
))
2472 /* Represent all the above changes by a special undo entry. */
2473 BVAR (current_buffer
, undo_list
) = Fcons (list3 (Qapply
,
2474 intern ("set-buffer-multibyte"),
2475 NILP (flag
) ? Qt
: Qnil
),
2481 /* Changing the multibyteness of a buffer means that all windows
2482 showing that buffer must be updated thoroughly. */
2483 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2484 ++windows_or_buffers_changed
;
2486 /* Copy this buffer's new multibyte status
2487 into all of its indirect buffers. */
2488 FOR_EACH_BUFFER (other
)
2489 if (other
->base_buffer
== current_buffer
&& !NILP (BVAR (other
, name
)))
2491 BVAR (other
, enable_multibyte_characters
)
2492 = BVAR (current_buffer
, enable_multibyte_characters
);
2493 other
->prevent_redisplay_optimizations_p
= 1;
2496 /* Restore the modifiedness of the buffer. */
2497 if (!modified_p
&& !NILP (Fbuffer_modified_p (Qnil
)))
2498 Fset_buffer_modified_p (Qnil
);
2500 /* Update coding systems of this buffer's process (if any). */
2502 Lisp_Object process
;
2504 process
= Fget_buffer_process (Fcurrent_buffer ());
2505 if (PROCESSP (process
))
2506 setup_process_coding_systems (process
);
2512 DEFUN ("kill-all-local-variables", Fkill_all_local_variables
,
2513 Skill_all_local_variables
, 0, 0, 0,
2514 doc
: /* Switch to Fundamental mode by killing current buffer's local variables.
2515 Most local variable bindings are eliminated so that the default values
2516 become effective once more. Also, the syntax table is set from
2517 `standard-syntax-table', the local keymap is set to nil,
2518 and the abbrev table from `fundamental-mode-abbrev-table'.
2519 This function also forces redisplay of the mode line.
2521 Every function to select a new major mode starts by
2522 calling this function.
2524 As a special exception, local variables whose names have
2525 a non-nil `permanent-local' property are not eliminated by this function.
2527 The first thing this function does is run
2528 the normal hook `change-major-mode-hook'. */)
2531 Frun_hooks (1, &Qchange_major_mode_hook
);
2533 /* Make sure none of the bindings in local_var_alist
2534 remain swapped in, in their symbols. */
2536 swap_out_buffer_local_variables (current_buffer
);
2538 /* Actually eliminate all local bindings of this buffer. */
2540 reset_buffer_local_variables (current_buffer
, 0);
2542 /* Force mode-line redisplay. Useful here because all major mode
2543 commands call this function. */
2544 update_mode_lines
++;
2549 /* Make sure no local variables remain set up with buffer B
2550 for their current values. */
2553 swap_out_buffer_local_variables (struct buffer
*b
)
2555 Lisp_Object oalist
, alist
, buffer
;
2557 XSETBUFFER (buffer
, b
);
2558 oalist
= BVAR (b
, local_var_alist
);
2560 for (alist
= oalist
; CONSP (alist
); alist
= XCDR (alist
))
2562 Lisp_Object sym
= XCAR (XCAR (alist
));
2563 eassert (XSYMBOL (sym
)->redirect
== SYMBOL_LOCALIZED
);
2564 /* Need not do anything if some other buffer's binding is
2566 if (EQ (SYMBOL_BLV (XSYMBOL (sym
))->where
, buffer
))
2568 /* Symbol is set up for this buffer's old local value:
2570 swap_in_global_binding (XSYMBOL (sym
));
2575 /* Find all the overlays in the current buffer that contain position POS.
2576 Return the number found, and store them in a vector in *VEC_PTR.
2577 Store in *LEN_PTR the size allocated for the vector.
2578 Store in *NEXT_PTR the next position after POS where an overlay starts,
2579 or ZV if there are no more overlays between POS and ZV.
2580 Store in *PREV_PTR the previous position before POS where an overlay ends,
2581 or where an overlay starts which ends at or after POS;
2582 or BEGV if there are no such overlays from BEGV to POS.
2583 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2585 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2586 when this function is called.
2588 If EXTEND is non-zero, we make the vector bigger if necessary.
2589 If EXTEND is zero, we never extend the vector,
2590 and we store only as many overlays as will fit.
2591 But we still return the total number of overlays.
2593 If CHANGE_REQ is true, then any position written into *PREV_PTR or
2594 *NEXT_PTR is guaranteed to be not equal to POS, unless it is the
2595 default (BEGV or ZV). */
2598 overlays_at (EMACS_INT pos
, int extend
, Lisp_Object
**vec_ptr
,
2600 ptrdiff_t *next_ptr
, ptrdiff_t *prev_ptr
, int change_req
)
2602 Lisp_Object overlay
, start
, end
;
2603 struct Lisp_Overlay
*tail
;
2605 ptrdiff_t len
= *len_ptr
;
2606 Lisp_Object
*vec
= *vec_ptr
;
2607 ptrdiff_t next
= ZV
;
2608 ptrdiff_t prev
= BEGV
;
2609 int inhibit_storing
= 0;
2611 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2613 ptrdiff_t startpos
, endpos
;
2615 XSETMISC (overlay
, tail
);
2617 start
= OVERLAY_START (overlay
);
2618 end
= OVERLAY_END (overlay
);
2619 endpos
= OVERLAY_POSITION (end
);
2626 startpos
= OVERLAY_POSITION (start
);
2627 /* This one ends at or after POS
2628 so its start counts for PREV_PTR if it's before POS. */
2629 if (prev
< startpos
&& startpos
< pos
)
2633 if (startpos
<= pos
)
2637 /* The supplied vector is full.
2638 Either make it bigger, or don't store any more in it. */
2641 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2647 inhibit_storing
= 1;
2650 if (!inhibit_storing
)
2652 /* Keep counting overlays even if we can't return them all. */
2655 else if (startpos
< next
)
2659 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2661 ptrdiff_t startpos
, endpos
;
2663 XSETMISC (overlay
, tail
);
2665 start
= OVERLAY_START (overlay
);
2666 end
= OVERLAY_END (overlay
);
2667 startpos
= OVERLAY_POSITION (start
);
2670 if (startpos
< next
)
2674 endpos
= OVERLAY_POSITION (end
);
2681 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2687 inhibit_storing
= 1;
2690 if (!inhibit_storing
)
2694 if (startpos
< pos
&& startpos
> prev
)
2697 else if (endpos
< pos
&& endpos
> prev
)
2699 else if (endpos
== pos
&& startpos
> prev
2700 && (!change_req
|| startpos
< pos
))
2711 /* Find all the overlays in the current buffer that overlap the range
2712 BEG-END, or are empty at BEG, or are empty at END provided END
2713 denotes the position at the end of the current buffer.
2715 Return the number found, and store them in a vector in *VEC_PTR.
2716 Store in *LEN_PTR the size allocated for the vector.
2717 Store in *NEXT_PTR the next position after POS where an overlay starts,
2718 or ZV if there are no more overlays.
2719 Store in *PREV_PTR the previous position before POS where an overlay ends,
2720 or BEGV if there are no previous overlays.
2721 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2723 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2724 when this function is called.
2726 If EXTEND is non-zero, we make the vector bigger if necessary.
2727 If EXTEND is zero, we never extend the vector,
2728 and we store only as many overlays as will fit.
2729 But we still return the total number of overlays. */
2732 overlays_in (EMACS_INT beg
, EMACS_INT end
, int extend
,
2733 Lisp_Object
**vec_ptr
, ptrdiff_t *len_ptr
,
2734 ptrdiff_t *next_ptr
, ptrdiff_t *prev_ptr
)
2736 Lisp_Object overlay
, ostart
, oend
;
2737 struct Lisp_Overlay
*tail
;
2739 ptrdiff_t len
= *len_ptr
;
2740 Lisp_Object
*vec
= *vec_ptr
;
2741 ptrdiff_t next
= ZV
;
2742 ptrdiff_t prev
= BEGV
;
2743 int inhibit_storing
= 0;
2744 int end_is_Z
= end
== Z
;
2746 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2748 ptrdiff_t startpos
, endpos
;
2750 XSETMISC (overlay
, tail
);
2752 ostart
= OVERLAY_START (overlay
);
2753 oend
= OVERLAY_END (overlay
);
2754 endpos
= OVERLAY_POSITION (oend
);
2761 startpos
= OVERLAY_POSITION (ostart
);
2762 /* Count an interval if it overlaps the range, is empty at the
2763 start of the range, or is empty at END provided END denotes the
2764 end of the buffer. */
2765 if ((beg
< endpos
&& startpos
< end
)
2766 || (startpos
== endpos
2767 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
2771 /* The supplied vector is full.
2772 Either make it bigger, or don't store any more in it. */
2775 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2781 inhibit_storing
= 1;
2784 if (!inhibit_storing
)
2786 /* Keep counting overlays even if we can't return them all. */
2789 else if (startpos
< next
)
2793 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2795 ptrdiff_t startpos
, endpos
;
2797 XSETMISC (overlay
, tail
);
2799 ostart
= OVERLAY_START (overlay
);
2800 oend
= OVERLAY_END (overlay
);
2801 startpos
= OVERLAY_POSITION (ostart
);
2804 if (startpos
< next
)
2808 endpos
= OVERLAY_POSITION (oend
);
2809 /* Count an interval if it overlaps the range, is empty at the
2810 start of the range, or is empty at END provided END denotes the
2811 end of the buffer. */
2812 if ((beg
< endpos
&& startpos
< end
)
2813 || (startpos
== endpos
2814 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
2820 vec
= xpalloc (vec
, len_ptr
, 1, OVERLAY_COUNT_MAX
,
2826 inhibit_storing
= 1;
2829 if (!inhibit_storing
)
2833 else if (endpos
< beg
&& endpos
> prev
)
2845 /* Return non-zero if there exists an overlay with a non-nil
2846 `mouse-face' property overlapping OVERLAY. */
2849 mouse_face_overlay_overlaps (Lisp_Object overlay
)
2851 ptrdiff_t start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2852 ptrdiff_t end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2853 ptrdiff_t n
, i
, size
;
2854 Lisp_Object
*v
, tem
;
2857 v
= alloca (size
* sizeof *v
);
2858 n
= overlays_in (start
, end
, 0, &v
, &size
, NULL
, NULL
);
2861 v
= alloca (n
* sizeof *v
);
2862 overlays_in (start
, end
, 0, &v
, &n
, NULL
, NULL
);
2865 for (i
= 0; i
< n
; ++i
)
2866 if (!EQ (v
[i
], overlay
)
2867 && (tem
= Foverlay_get (overlay
, Qmouse_face
),
2876 /* Fast function to just test if we're at an overlay boundary. */
2878 overlay_touches_p (ptrdiff_t pos
)
2880 Lisp_Object overlay
;
2881 struct Lisp_Overlay
*tail
;
2883 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2887 XSETMISC (overlay
,tail
);
2888 eassert (OVERLAYP (overlay
));
2890 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2893 if (endpos
== pos
|| OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
)
2897 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2901 XSETMISC (overlay
, tail
);
2902 eassert (OVERLAYP (overlay
));
2904 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2907 if (startpos
== pos
|| OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
)
2915 Lisp_Object overlay
;
2921 compare_overlays (const void *v1
, const void *v2
)
2923 const struct sortvec
*s1
= (const struct sortvec
*) v1
;
2924 const struct sortvec
*s2
= (const struct sortvec
*) v2
;
2925 if (s1
->priority
!= s2
->priority
)
2926 return s1
->priority
< s2
->priority
? -1 : 1;
2927 if (s1
->beg
!= s2
->beg
)
2928 return s1
->beg
< s2
->beg
? -1 : 1;
2929 if (s1
->end
!= s2
->end
)
2930 return s2
->end
< s1
->end
? -1 : 1;
2931 /* Avoid the non-determinism of qsort by choosing an arbitrary ordering
2932 between "equal" overlays. The result can still change between
2933 invocations of Emacs, but it won't change in the middle of
2934 `find_field' (bug#6830). */
2935 if (XHASH (s1
->overlay
) != XHASH (s2
->overlay
))
2936 return XHASH (s1
->overlay
) < XHASH (s2
->overlay
) ? -1 : 1;
2940 /* Sort an array of overlays by priority. The array is modified in place.
2941 The return value is the new size; this may be smaller than the original
2942 size if some of the overlays were invalid or were window-specific. */
2944 sort_overlays (Lisp_Object
*overlay_vec
, ptrdiff_t noverlays
, struct window
*w
)
2947 struct sortvec
*sortvec
= alloca (noverlays
* sizeof *sortvec
);
2949 /* Put the valid and relevant overlays into sortvec. */
2951 for (i
= 0, j
= 0; i
< noverlays
; i
++)
2954 Lisp_Object overlay
;
2956 overlay
= overlay_vec
[i
];
2957 if (OVERLAYP (overlay
)
2958 && OVERLAY_POSITION (OVERLAY_START (overlay
)) > 0
2959 && OVERLAY_POSITION (OVERLAY_END (overlay
)) > 0)
2961 /* If we're interested in a specific window, then ignore
2962 overlays that are limited to some other window. */
2967 window
= Foverlay_get (overlay
, Qwindow
);
2968 if (WINDOWP (window
) && XWINDOW (window
) != w
)
2972 /* This overlay is good and counts: put it into sortvec. */
2973 sortvec
[j
].overlay
= overlay
;
2974 sortvec
[j
].beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2975 sortvec
[j
].end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2976 tem
= Foverlay_get (overlay
, Qpriority
);
2978 sortvec
[j
].priority
= XINT (tem
);
2980 sortvec
[j
].priority
= 0;
2986 /* Sort the overlays into the proper order: increasing priority. */
2989 qsort (sortvec
, noverlays
, sizeof (struct sortvec
), compare_overlays
);
2991 for (i
= 0; i
< noverlays
; i
++)
2992 overlay_vec
[i
] = sortvec
[i
].overlay
;
2998 Lisp_Object string
, string2
;
3005 struct sortstr
*buf
; /* An array that expands as needed; never freed. */
3006 ptrdiff_t size
; /* Allocated length of that array. */
3007 ptrdiff_t used
; /* How much of the array is currently in use. */
3008 ptrdiff_t bytes
; /* Total length of the strings in buf. */
3011 /* Buffers for storing information about the overlays touching a given
3012 position. These could be automatic variables in overlay_strings, but
3013 it's more efficient to hold onto the memory instead of repeatedly
3014 allocating and freeing it. */
3015 static struct sortstrlist overlay_heads
, overlay_tails
;
3016 static unsigned char *overlay_str_buf
;
3018 /* Allocated length of overlay_str_buf. */
3019 static ptrdiff_t overlay_str_len
;
3021 /* A comparison function suitable for passing to qsort. */
3023 cmp_for_strings (const void *as1
, const void *as2
)
3025 struct sortstr
*s1
= (struct sortstr
*)as1
;
3026 struct sortstr
*s2
= (struct sortstr
*)as2
;
3027 if (s1
->size
!= s2
->size
)
3028 return s2
->size
< s1
->size
? -1 : 1;
3029 if (s1
->priority
!= s2
->priority
)
3030 return s1
->priority
< s2
->priority
? -1 : 1;
3035 record_overlay_string (struct sortstrlist
*ssl
, Lisp_Object str
,
3036 Lisp_Object str2
, Lisp_Object pri
, ptrdiff_t size
)
3040 if (ssl
->used
== ssl
->size
)
3041 ssl
->buf
= xpalloc (ssl
->buf
, &ssl
->size
, 5, -1, sizeof *ssl
->buf
);
3042 ssl
->buf
[ssl
->used
].string
= str
;
3043 ssl
->buf
[ssl
->used
].string2
= str2
;
3044 ssl
->buf
[ssl
->used
].size
= size
;
3045 ssl
->buf
[ssl
->used
].priority
= (INTEGERP (pri
) ? XINT (pri
) : 0);
3048 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3049 nbytes
= SCHARS (str
);
3050 else if (! STRING_MULTIBYTE (str
))
3051 nbytes
= count_size_as_multibyte (SDATA (str
),
3054 nbytes
= SBYTES (str
);
3056 if (INT_ADD_OVERFLOW (ssl
->bytes
, nbytes
))
3057 memory_full (SIZE_MAX
);
3058 ssl
->bytes
+= nbytes
;
3062 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3063 nbytes
= SCHARS (str2
);
3064 else if (! STRING_MULTIBYTE (str2
))
3065 nbytes
= count_size_as_multibyte (SDATA (str2
),
3068 nbytes
= SBYTES (str2
);
3070 if (INT_ADD_OVERFLOW (ssl
->bytes
, nbytes
))
3071 memory_full (SIZE_MAX
);
3072 ssl
->bytes
+= nbytes
;
3076 /* Return the concatenation of the strings associated with overlays that
3077 begin or end at POS, ignoring overlays that are specific to a window
3078 other than W. The strings are concatenated in the appropriate order:
3079 shorter overlays nest inside longer ones, and higher priority inside
3080 lower. Normally all of the after-strings come first, but zero-sized
3081 overlays have their after-strings ride along with the before-strings
3082 because it would look strange to print them inside-out.
3084 Returns the string length, and stores the contents indirectly through
3085 PSTR, if that variable is non-null. The string may be overwritten by
3086 subsequent calls. */
3089 overlay_strings (ptrdiff_t pos
, struct window
*w
, unsigned char **pstr
)
3091 Lisp_Object overlay
, window
, str
;
3092 struct Lisp_Overlay
*ov
;
3093 ptrdiff_t startpos
, endpos
;
3094 int multibyte
= ! NILP (BVAR (current_buffer
, enable_multibyte_characters
));
3096 overlay_heads
.used
= overlay_heads
.bytes
= 0;
3097 overlay_tails
.used
= overlay_tails
.bytes
= 0;
3098 for (ov
= current_buffer
->overlays_before
; ov
; ov
= ov
->next
)
3100 XSETMISC (overlay
, ov
);
3101 eassert (OVERLAYP (overlay
));
3103 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3104 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3107 if (endpos
!= pos
&& startpos
!= pos
)
3109 window
= Foverlay_get (overlay
, Qwindow
);
3110 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3113 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3114 record_overlay_string (&overlay_heads
, str
,
3116 ? Foverlay_get (overlay
, Qafter_string
)
3118 Foverlay_get (overlay
, Qpriority
),
3120 else if (endpos
== pos
3121 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3122 record_overlay_string (&overlay_tails
, str
, Qnil
,
3123 Foverlay_get (overlay
, Qpriority
),
3126 for (ov
= current_buffer
->overlays_after
; ov
; ov
= ov
->next
)
3128 XSETMISC (overlay
, ov
);
3129 eassert (OVERLAYP (overlay
));
3131 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3132 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3135 if (endpos
!= pos
&& startpos
!= pos
)
3137 window
= Foverlay_get (overlay
, Qwindow
);
3138 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3141 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3142 record_overlay_string (&overlay_heads
, str
,
3144 ? Foverlay_get (overlay
, Qafter_string
)
3146 Foverlay_get (overlay
, Qpriority
),
3148 else if (endpos
== pos
3149 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3150 record_overlay_string (&overlay_tails
, str
, Qnil
,
3151 Foverlay_get (overlay
, Qpriority
),
3154 if (overlay_tails
.used
> 1)
3155 qsort (overlay_tails
.buf
, overlay_tails
.used
, sizeof (struct sortstr
),
3157 if (overlay_heads
.used
> 1)
3158 qsort (overlay_heads
.buf
, overlay_heads
.used
, sizeof (struct sortstr
),
3160 if (overlay_heads
.bytes
|| overlay_tails
.bytes
)
3167 if (INT_ADD_OVERFLOW (overlay_heads
.bytes
, overlay_tails
.bytes
))
3168 memory_full (SIZE_MAX
);
3169 total
= overlay_heads
.bytes
+ overlay_tails
.bytes
;
3170 if (total
> overlay_str_len
)
3171 overlay_str_buf
= xpalloc (overlay_str_buf
, &overlay_str_len
,
3172 total
- overlay_str_len
, -1, 1);
3174 p
= overlay_str_buf
;
3175 for (i
= overlay_tails
.used
; --i
>= 0;)
3178 tem
= overlay_tails
.buf
[i
].string
;
3179 nbytes
= copy_text (SDATA (tem
), p
,
3181 STRING_MULTIBYTE (tem
), multibyte
);
3184 for (i
= 0; i
< overlay_heads
.used
; ++i
)
3187 tem
= overlay_heads
.buf
[i
].string
;
3188 nbytes
= copy_text (SDATA (tem
), p
,
3190 STRING_MULTIBYTE (tem
), multibyte
);
3192 tem
= overlay_heads
.buf
[i
].string2
;
3195 nbytes
= copy_text (SDATA (tem
), p
,
3197 STRING_MULTIBYTE (tem
), multibyte
);
3201 if (p
!= overlay_str_buf
+ total
)
3204 *pstr
= overlay_str_buf
;
3210 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
3213 recenter_overlay_lists (struct buffer
*buf
, ptrdiff_t pos
)
3215 Lisp_Object overlay
, beg
, end
;
3216 struct Lisp_Overlay
*prev
, *tail
, *next
;
3218 /* See if anything in overlays_before should move to overlays_after. */
3220 /* We don't strictly need prev in this loop; it should always be nil.
3221 But we use it for symmetry and in case that should cease to be true
3222 with some future change. */
3224 for (tail
= buf
->overlays_before
; tail
; prev
= tail
, tail
= next
)
3227 XSETMISC (overlay
, tail
);
3228 eassert (OVERLAYP (overlay
));
3230 beg
= OVERLAY_START (overlay
);
3231 end
= OVERLAY_END (overlay
);
3233 if (OVERLAY_POSITION (end
) > pos
)
3235 /* OVERLAY needs to be moved. */
3236 ptrdiff_t where
= OVERLAY_POSITION (beg
);
3237 struct Lisp_Overlay
*other
, *other_prev
;
3239 /* Splice the cons cell TAIL out of overlays_before. */
3243 buf
->overlays_before
= next
;
3245 /* Search thru overlays_after for where to put it. */
3247 for (other
= buf
->overlays_after
; other
;
3248 other_prev
= other
, other
= other
->next
)
3250 Lisp_Object otherbeg
, otheroverlay
;
3252 XSETMISC (otheroverlay
, other
);
3253 eassert (OVERLAYP (otheroverlay
));
3255 otherbeg
= OVERLAY_START (otheroverlay
);
3256 if (OVERLAY_POSITION (otherbeg
) >= where
)
3260 /* Add TAIL to overlays_after before OTHER. */
3263 other_prev
->next
= tail
;
3265 buf
->overlays_after
= tail
;
3269 /* We've reached the things that should stay in overlays_before.
3270 All the rest of overlays_before must end even earlier,
3275 /* See if anything in overlays_after should be in overlays_before. */
3277 for (tail
= buf
->overlays_after
; tail
; prev
= tail
, tail
= next
)
3280 XSETMISC (overlay
, tail
);
3281 eassert (OVERLAYP (overlay
));
3283 beg
= OVERLAY_START (overlay
);
3284 end
= OVERLAY_END (overlay
);
3286 /* Stop looking, when we know that nothing further
3287 can possibly end before POS. */
3288 if (OVERLAY_POSITION (beg
) > pos
)
3291 if (OVERLAY_POSITION (end
) <= pos
)
3293 /* OVERLAY needs to be moved. */
3294 ptrdiff_t where
= OVERLAY_POSITION (end
);
3295 struct Lisp_Overlay
*other
, *other_prev
;
3297 /* Splice the cons cell TAIL out of overlays_after. */
3301 buf
->overlays_after
= next
;
3303 /* Search thru overlays_before for where to put it. */
3305 for (other
= buf
->overlays_before
; other
;
3306 other_prev
= other
, other
= other
->next
)
3308 Lisp_Object otherend
, otheroverlay
;
3310 XSETMISC (otheroverlay
, other
);
3311 eassert (OVERLAYP (otheroverlay
));
3313 otherend
= OVERLAY_END (otheroverlay
);
3314 if (OVERLAY_POSITION (otherend
) <= where
)
3318 /* Add TAIL to overlays_before before OTHER. */
3321 other_prev
->next
= tail
;
3323 buf
->overlays_before
= tail
;
3328 buf
->overlay_center
= pos
;
3332 adjust_overlays_for_insert (ptrdiff_t pos
, ptrdiff_t length
)
3334 /* After an insertion, the lists are still sorted properly,
3335 but we may need to update the value of the overlay center. */
3336 if (current_buffer
->overlay_center
>= pos
)
3337 current_buffer
->overlay_center
+= length
;
3341 adjust_overlays_for_delete (ptrdiff_t pos
, ptrdiff_t length
)
3343 if (current_buffer
->overlay_center
< pos
)
3344 /* The deletion was to our right. No change needed; the before- and
3345 after-lists are still consistent. */
3347 else if (current_buffer
->overlay_center
- pos
> length
)
3348 /* The deletion was to our left. We need to adjust the center value
3349 to account for the change in position, but the lists are consistent
3350 given the new value. */
3351 current_buffer
->overlay_center
-= length
;
3353 /* We're right in the middle. There might be things on the after-list
3354 that now belong on the before-list. Recentering will move them,
3355 and also update the center point. */
3356 recenter_overlay_lists (current_buffer
, pos
);
3359 /* Fix up overlays that were garbled as a result of permuting markers
3360 in the range START through END. Any overlay with at least one
3361 endpoint in this range will need to be unlinked from the overlay
3362 list and reinserted in its proper place.
3363 Such an overlay might even have negative size at this point.
3364 If so, we'll make the overlay empty. */
3366 fix_start_end_in_overlays (register ptrdiff_t start
, register ptrdiff_t end
)
3368 Lisp_Object overlay
;
3369 struct Lisp_Overlay
*before_list
IF_LINT (= NULL
);
3370 struct Lisp_Overlay
*after_list
IF_LINT (= NULL
);
3371 /* These are either nil, indicating that before_list or after_list
3372 should be assigned, or the cons cell the cdr of which should be
3374 struct Lisp_Overlay
*beforep
= NULL
, *afterp
= NULL
;
3375 /* 'Parent', likewise, indicates a cons cell or
3376 current_buffer->overlays_before or overlays_after, depending
3377 which loop we're in. */
3378 struct Lisp_Overlay
*tail
, *parent
;
3379 ptrdiff_t startpos
, endpos
;
3381 /* This algorithm shifts links around instead of consing and GCing.
3382 The loop invariant is that before_list (resp. after_list) is a
3383 well-formed list except that its last element, the CDR of beforep
3384 (resp. afterp) if beforep (afterp) isn't nil or before_list
3385 (after_list) if it is, is still uninitialized. So it's not a bug
3386 that before_list isn't initialized, although it may look
3388 for (parent
= NULL
, tail
= current_buffer
->overlays_before
; tail
;)
3390 XSETMISC (overlay
, tail
);
3392 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3393 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3395 /* If the overlay is backwards, make it empty. */
3396 if (endpos
< startpos
)
3399 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3407 || (startpos
>= start
&& startpos
< end
))
3409 /* Add it to the end of the wrong list. Later on,
3410 recenter_overlay_lists will move it to the right place. */
3411 if (endpos
< current_buffer
->overlay_center
)
3416 afterp
->next
= tail
;
3424 beforep
->next
= tail
;
3428 current_buffer
->overlays_before
= tail
->next
;
3430 parent
->next
= tail
->next
;
3434 parent
= tail
, tail
= parent
->next
;
3436 for (parent
= NULL
, tail
= current_buffer
->overlays_after
; tail
;)
3438 XSETMISC (overlay
, tail
);
3440 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3441 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3443 /* If the overlay is backwards, make it empty. */
3444 if (endpos
< startpos
)
3447 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3451 if (startpos
>= end
)
3454 if (startpos
>= start
3455 || (endpos
>= start
&& endpos
< end
))
3457 if (endpos
< current_buffer
->overlay_center
)
3462 afterp
->next
= tail
;
3470 beforep
->next
= tail
;
3474 current_buffer
->overlays_after
= tail
->next
;
3476 parent
->next
= tail
->next
;
3480 parent
= tail
, tail
= parent
->next
;
3483 /* Splice the constructed (wrong) lists into the buffer's lists,
3484 and let the recenter function make it sane again. */
3487 beforep
->next
= current_buffer
->overlays_before
;
3488 current_buffer
->overlays_before
= before_list
;
3490 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3494 afterp
->next
= current_buffer
->overlays_after
;
3495 current_buffer
->overlays_after
= after_list
;
3497 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3500 /* We have two types of overlay: the one whose ending marker is
3501 after-insertion-marker (this is the usual case) and the one whose
3502 ending marker is before-insertion-marker. When `overlays_before'
3503 contains overlays of the latter type and the former type in this
3504 order and both overlays end at inserting position, inserting a text
3505 increases only the ending marker of the latter type, which results
3506 in incorrect ordering of `overlays_before'.
3508 This function fixes ordering of overlays in the slot
3509 `overlays_before' of the buffer *BP. Before the insertion, `point'
3510 was at PREV, and now is at POS. */
3513 fix_overlays_before (struct buffer
*bp
, ptrdiff_t prev
, ptrdiff_t pos
)
3515 /* If parent is nil, replace overlays_before; otherwise, parent->next. */
3516 struct Lisp_Overlay
*tail
= bp
->overlays_before
, *parent
= NULL
, *right_pair
;
3518 ptrdiff_t end
IF_LINT (= 0);
3520 /* After the insertion, the several overlays may be in incorrect
3521 order. The possibility is that, in the list `overlays_before',
3522 an overlay which ends at POS appears after an overlay which ends
3523 at PREV. Since POS is greater than PREV, we must fix the
3524 ordering of these overlays, by moving overlays ends at POS before
3525 the overlays ends at PREV. */
3527 /* At first, find a place where disordered overlays should be linked
3528 in. It is where an overlay which end before POS exists. (i.e. an
3529 overlay whose ending marker is after-insertion-marker if disorder
3532 && (XSETMISC (tem
, tail
),
3533 (end
= OVERLAY_POSITION (OVERLAY_END (tem
))) >= pos
))
3539 /* If we don't find such an overlay,
3540 or the found one ends before PREV,
3541 or the found one is the last one in the list,
3542 we don't have to fix anything. */
3543 if (!tail
|| end
< prev
|| !tail
->next
)
3546 right_pair
= parent
;
3550 /* Now, end position of overlays in the list TAIL should be before
3551 or equal to PREV. In the loop, an overlay which ends at POS is
3552 moved ahead to the place indicated by the CDR of RIGHT_PAIR. If
3553 we found an overlay which ends before PREV, the remaining
3554 overlays are in correct order. */
3557 XSETMISC (tem
, tail
);
3558 end
= OVERLAY_POSITION (OVERLAY_END (tem
));
3561 { /* This overlay is disordered. */
3562 struct Lisp_Overlay
*found
= tail
;
3564 /* Unlink the found overlay. */
3566 parent
->next
= tail
;
3567 /* Move an overlay at RIGHT_PLACE to the next of the found one,
3568 and link it into the right place. */
3571 found
->next
= bp
->overlays_before
;
3572 bp
->overlays_before
= found
;
3576 found
->next
= right_pair
->next
;
3577 right_pair
->next
= found
;
3580 else if (end
== prev
)
3585 else /* No more disordered overlay. */
3590 DEFUN ("overlayp", Foverlayp
, Soverlayp
, 1, 1, 0,
3591 doc
: /* Return t if OBJECT is an overlay. */)
3592 (Lisp_Object object
)
3594 return (OVERLAYP (object
) ? Qt
: Qnil
);
3597 DEFUN ("make-overlay", Fmake_overlay
, Smake_overlay
, 2, 5, 0,
3598 doc
: /* Create a new overlay with range BEG to END in BUFFER.
3599 If omitted, BUFFER defaults to the current buffer.
3600 BEG and END may be integers or markers.
3601 The fourth arg FRONT-ADVANCE, if non-nil, makes the marker
3602 for the front of the overlay advance when text is inserted there
3603 \(which means the text *is not* included in the overlay).
3604 The fifth arg REAR-ADVANCE, if non-nil, makes the marker
3605 for the rear of the overlay advance when text is inserted there
3606 \(which means the text *is* included in the overlay). */)
3607 (Lisp_Object beg
, Lisp_Object end
, Lisp_Object buffer
, Lisp_Object front_advance
, Lisp_Object rear_advance
)
3609 Lisp_Object overlay
;
3613 XSETBUFFER (buffer
, current_buffer
);
3615 CHECK_BUFFER (buffer
);
3617 && ! EQ (Fmarker_buffer (beg
), buffer
))
3618 error ("Marker points into wrong buffer");
3620 && ! EQ (Fmarker_buffer (end
), buffer
))
3621 error ("Marker points into wrong buffer");
3623 CHECK_NUMBER_COERCE_MARKER (beg
);
3624 CHECK_NUMBER_COERCE_MARKER (end
);
3626 if (XINT (beg
) > XINT (end
))
3629 temp
= beg
; beg
= end
; end
= temp
;
3632 b
= XBUFFER (buffer
);
3634 beg
= Fset_marker (Fmake_marker (), beg
, buffer
);
3635 end
= Fset_marker (Fmake_marker (), end
, buffer
);
3637 if (!NILP (front_advance
))
3638 XMARKER (beg
)->insertion_type
= 1;
3639 if (!NILP (rear_advance
))
3640 XMARKER (end
)->insertion_type
= 1;
3642 overlay
= allocate_misc ();
3643 XMISCTYPE (overlay
) = Lisp_Misc_Overlay
;
3644 XOVERLAY (overlay
)->start
= beg
;
3645 XOVERLAY (overlay
)->end
= end
;
3646 XOVERLAY (overlay
)->plist
= Qnil
;
3647 XOVERLAY (overlay
)->next
= NULL
;
3649 /* Put the new overlay on the wrong list. */
3650 end
= OVERLAY_END (overlay
);
3651 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
3653 if (b
->overlays_after
)
3654 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3655 b
->overlays_after
= XOVERLAY (overlay
);
3659 if (b
->overlays_before
)
3660 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3661 b
->overlays_before
= XOVERLAY (overlay
);
3664 /* This puts it in the right list, and in the right order. */
3665 recenter_overlay_lists (b
, b
->overlay_center
);
3667 /* We don't need to redisplay the region covered by the overlay, because
3668 the overlay has no properties at the moment. */
3673 /* Mark a section of BUF as needing redisplay because of overlays changes. */
3676 modify_overlay (struct buffer
*buf
, ptrdiff_t start
, ptrdiff_t end
)
3680 ptrdiff_t temp
= start
;
3685 BUF_COMPUTE_UNCHANGED (buf
, start
, end
);
3687 /* If this is a buffer not in the selected window,
3688 we must do other windows. */
3689 if (buf
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
3690 windows_or_buffers_changed
= 1;
3691 /* If multiple windows show this buffer, we must do other windows. */
3692 else if (buffer_shared
> 1)
3693 windows_or_buffers_changed
= 1;
3694 /* If we modify an overlay at the end of the buffer, we cannot
3695 be sure that window end is still valid. */
3696 else if (end
>= ZV
&& start
<= ZV
)
3697 windows_or_buffers_changed
= 1;
3699 ++BUF_OVERLAY_MODIFF (buf
);
3702 /* Remove OVERLAY from LIST. */
3704 static struct Lisp_Overlay
*
3705 unchain_overlay (struct Lisp_Overlay
*list
, struct Lisp_Overlay
*overlay
)
3707 register struct Lisp_Overlay
*tail
, **prev
= &list
;
3709 for (tail
= list
; tail
; prev
= &tail
->next
, tail
= *prev
)
3710 if (tail
== overlay
)
3712 *prev
= overlay
->next
;
3713 overlay
->next
= NULL
;
3719 DEFUN ("move-overlay", Fmove_overlay
, Smove_overlay
, 3, 4, 0,
3720 doc
: /* Set the endpoints of OVERLAY to BEG and END in BUFFER.
3721 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.
3722 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current
3724 (Lisp_Object overlay
, Lisp_Object beg
, Lisp_Object end
, Lisp_Object buffer
)
3726 struct buffer
*b
, *ob
= 0;
3727 Lisp_Object obuffer
;
3728 ptrdiff_t count
= SPECPDL_INDEX ();
3729 ptrdiff_t n_beg
, n_end
, o_beg
IF_LINT (= 0), o_end
IF_LINT (= 0);
3731 CHECK_OVERLAY (overlay
);
3733 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3735 XSETBUFFER (buffer
, current_buffer
);
3736 CHECK_BUFFER (buffer
);
3738 if (NILP (Fbuffer_live_p (buffer
)))
3739 error ("Attempt to move overlay to a dead buffer");
3742 && ! EQ (Fmarker_buffer (beg
), buffer
))
3743 error ("Marker points into wrong buffer");
3745 && ! EQ (Fmarker_buffer (end
), buffer
))
3746 error ("Marker points into wrong buffer");
3748 CHECK_NUMBER_COERCE_MARKER (beg
);
3749 CHECK_NUMBER_COERCE_MARKER (end
);
3751 if (XINT (beg
) > XINT (end
))
3754 temp
= beg
; beg
= end
; end
= temp
;
3757 specbind (Qinhibit_quit
, Qt
);
3759 obuffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3760 b
= XBUFFER (buffer
);
3762 if (!NILP (obuffer
))
3764 ob
= XBUFFER (obuffer
);
3766 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3767 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3769 ob
->overlays_before
=
3770 unchain_overlay (ob
->overlays_before
, XOVERLAY (overlay
));
3771 ob
->overlays_after
=
3772 unchain_overlay (ob
->overlays_after
, XOVERLAY (overlay
));
3773 eassert (XOVERLAY (overlay
)->next
== NULL
);
3776 /* Set the overlay boundaries, which may clip them. */
3777 Fset_marker (OVERLAY_START (overlay
), beg
, buffer
);
3778 Fset_marker (OVERLAY_END (overlay
), end
, buffer
);
3780 n_beg
= marker_position (OVERLAY_START (overlay
));
3781 n_end
= marker_position (OVERLAY_END (overlay
));
3783 /* If the overlay has changed buffers, do a thorough redisplay. */
3784 if (!EQ (buffer
, obuffer
))
3786 /* Redisplay where the overlay was. */
3788 modify_overlay (ob
, o_beg
, o_end
);
3790 /* Redisplay where the overlay is going to be. */
3791 modify_overlay (b
, n_beg
, n_end
);
3794 /* Redisplay the area the overlay has just left, or just enclosed. */
3797 modify_overlay (b
, o_end
, n_end
);
3798 else if (o_end
== n_end
)
3799 modify_overlay (b
, o_beg
, n_beg
);
3801 modify_overlay (b
, min (o_beg
, n_beg
), max (o_end
, n_end
));
3804 /* Delete the overlay if it is empty after clipping and has the
3805 evaporate property. */
3806 if (n_beg
== n_end
&& !NILP (Foverlay_get (overlay
, Qevaporate
)))
3807 return unbind_to (count
, Fdelete_overlay (overlay
));
3809 /* Put the overlay into the new buffer's overlay lists, first on the
3811 if (n_end
< b
->overlay_center
)
3813 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3814 b
->overlays_after
= XOVERLAY (overlay
);
3818 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3819 b
->overlays_before
= XOVERLAY (overlay
);
3822 /* This puts it in the right list, and in the right order. */
3823 recenter_overlay_lists (b
, b
->overlay_center
);
3825 return unbind_to (count
, overlay
);
3828 DEFUN ("delete-overlay", Fdelete_overlay
, Sdelete_overlay
, 1, 1, 0,
3829 doc
: /* Delete the overlay OVERLAY from its buffer. */)
3830 (Lisp_Object overlay
)
3834 ptrdiff_t count
= SPECPDL_INDEX ();
3836 CHECK_OVERLAY (overlay
);
3838 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3842 b
= XBUFFER (buffer
);
3843 specbind (Qinhibit_quit
, Qt
);
3846 = unchain_overlay (b
->overlays_before
, XOVERLAY (overlay
));
3848 = unchain_overlay (b
->overlays_after
, XOVERLAY (overlay
));
3849 eassert (XOVERLAY (overlay
)->next
== NULL
);
3851 drop_overlay (b
, XOVERLAY (overlay
));
3853 /* When deleting an overlay with before or after strings, turn off
3854 display optimizations for the affected buffer, on the basis that
3855 these strings may contain newlines. This is easier to do than to
3856 check for that situation during redisplay. */
3857 if (!windows_or_buffers_changed
3858 && (!NILP (Foverlay_get (overlay
, Qbefore_string
))
3859 || !NILP (Foverlay_get (overlay
, Qafter_string
))))
3860 b
->prevent_redisplay_optimizations_p
= 1;
3862 return unbind_to (count
, Qnil
);
3865 /* Overlay dissection functions. */
3867 DEFUN ("overlay-start", Foverlay_start
, Soverlay_start
, 1, 1, 0,
3868 doc
: /* Return the position at which OVERLAY starts. */)
3869 (Lisp_Object overlay
)
3871 CHECK_OVERLAY (overlay
);
3873 return (Fmarker_position (OVERLAY_START (overlay
)));
3876 DEFUN ("overlay-end", Foverlay_end
, Soverlay_end
, 1, 1, 0,
3877 doc
: /* Return the position at which OVERLAY ends. */)
3878 (Lisp_Object overlay
)
3880 CHECK_OVERLAY (overlay
);
3882 return (Fmarker_position (OVERLAY_END (overlay
)));
3885 DEFUN ("overlay-buffer", Foverlay_buffer
, Soverlay_buffer
, 1, 1, 0,
3886 doc
: /* Return the buffer OVERLAY belongs to.
3887 Return nil if OVERLAY has been deleted. */)
3888 (Lisp_Object overlay
)
3890 CHECK_OVERLAY (overlay
);
3892 return Fmarker_buffer (OVERLAY_START (overlay
));
3895 DEFUN ("overlay-properties", Foverlay_properties
, Soverlay_properties
, 1, 1, 0,
3896 doc
: /* Return a list of the properties on OVERLAY.
3897 This is a copy of OVERLAY's plist; modifying its conses has no effect on
3899 (Lisp_Object overlay
)
3901 CHECK_OVERLAY (overlay
);
3903 return Fcopy_sequence (XOVERLAY (overlay
)->plist
);
3907 DEFUN ("overlays-at", Foverlays_at
, Soverlays_at
, 1, 1, 0,
3908 doc
: /* Return a list of the overlays that contain the character at POS. */)
3911 ptrdiff_t len
, noverlays
;
3912 Lisp_Object
*overlay_vec
;
3915 CHECK_NUMBER_COERCE_MARKER (pos
);
3918 /* We can't use alloca here because overlays_at can call xrealloc. */
3919 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
3921 /* Put all the overlays we want in a vector in overlay_vec.
3922 Store the length in len. */
3923 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
3926 /* Make a list of them all. */
3927 result
= Flist (noverlays
, overlay_vec
);
3929 xfree (overlay_vec
);
3933 DEFUN ("overlays-in", Foverlays_in
, Soverlays_in
, 2, 2, 0,
3934 doc
: /* Return a list of the overlays that overlap the region BEG ... END.
3935 Overlap means that at least one character is contained within the overlay
3936 and also contained within the specified region.
3937 Empty overlays are included in the result if they are located at BEG,
3938 between BEG and END, or at END provided END denotes the position at the
3939 end of the buffer. */)
3940 (Lisp_Object beg
, Lisp_Object end
)
3942 ptrdiff_t len
, noverlays
;
3943 Lisp_Object
*overlay_vec
;
3946 CHECK_NUMBER_COERCE_MARKER (beg
);
3947 CHECK_NUMBER_COERCE_MARKER (end
);
3950 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
3952 /* Put all the overlays we want in a vector in overlay_vec.
3953 Store the length in len. */
3954 noverlays
= overlays_in (XINT (beg
), XINT (end
), 1, &overlay_vec
, &len
,
3957 /* Make a list of them all. */
3958 result
= Flist (noverlays
, overlay_vec
);
3960 xfree (overlay_vec
);
3964 DEFUN ("next-overlay-change", Fnext_overlay_change
, Snext_overlay_change
,
3966 doc
: /* Return the next position after POS where an overlay starts or ends.
3967 If there are no overlay boundaries from POS to (point-max),
3968 the value is (point-max). */)
3971 ptrdiff_t i
, len
, noverlays
;
3973 Lisp_Object
*overlay_vec
;
3975 CHECK_NUMBER_COERCE_MARKER (pos
);
3978 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
3980 /* Put all the overlays we want in a vector in overlay_vec.
3981 Store the length in len.
3982 endpos gets the position where the next overlay starts. */
3983 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
3986 /* If any of these overlays ends before endpos,
3987 use its ending point instead. */
3988 for (i
= 0; i
< noverlays
; i
++)
3993 oend
= OVERLAY_END (overlay_vec
[i
]);
3994 oendpos
= OVERLAY_POSITION (oend
);
3995 if (oendpos
< endpos
)
3999 xfree (overlay_vec
);
4000 return make_number (endpos
);
4003 DEFUN ("previous-overlay-change", Fprevious_overlay_change
,
4004 Sprevious_overlay_change
, 1, 1, 0,
4005 doc
: /* Return the previous position before POS where an overlay starts or ends.
4006 If there are no overlay boundaries from (point-min) to POS,
4007 the value is (point-min). */)
4011 Lisp_Object
*overlay_vec
;
4014 CHECK_NUMBER_COERCE_MARKER (pos
);
4016 /* At beginning of buffer, we know the answer;
4017 avoid bug subtracting 1 below. */
4018 if (XINT (pos
) == BEGV
)
4022 overlay_vec
= xmalloc (len
* sizeof *overlay_vec
);
4024 /* Put all the overlays we want in a vector in overlay_vec.
4025 Store the length in len.
4026 prevpos gets the position of the previous change. */
4027 overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4030 xfree (overlay_vec
);
4031 return make_number (prevpos
);
4034 /* These functions are for debugging overlays. */
4036 DEFUN ("overlay-lists", Foverlay_lists
, Soverlay_lists
, 0, 0, 0,
4037 doc
: /* Return a pair of lists giving all the overlays of the current buffer.
4038 The car has all the overlays before the overlay center;
4039 the cdr has all the overlays after the overlay center.
4040 Recentering overlays moves overlays between these lists.
4041 The lists you get are copies, so that changing them has no effect.
4042 However, the overlays you get are the real objects that the buffer uses. */)
4045 struct Lisp_Overlay
*ol
;
4046 Lisp_Object before
= Qnil
, after
= Qnil
, tmp
;
4047 for (ol
= current_buffer
->overlays_before
; ol
; ol
= ol
->next
)
4050 before
= Fcons (tmp
, before
);
4052 for (ol
= current_buffer
->overlays_after
; ol
; ol
= ol
->next
)
4055 after
= Fcons (tmp
, after
);
4057 return Fcons (Fnreverse (before
), Fnreverse (after
));
4060 DEFUN ("overlay-recenter", Foverlay_recenter
, Soverlay_recenter
, 1, 1, 0,
4061 doc
: /* Recenter the overlays of the current buffer around position POS.
4062 That makes overlay lookup faster for positions near POS (but perhaps slower
4063 for positions far away from POS). */)
4067 CHECK_NUMBER_COERCE_MARKER (pos
);
4069 p
= clip_to_bounds (PTRDIFF_MIN
, XINT (pos
), PTRDIFF_MAX
);
4070 recenter_overlay_lists (current_buffer
, p
);
4074 DEFUN ("overlay-get", Foverlay_get
, Soverlay_get
, 2, 2, 0,
4075 doc
: /* Get the property of overlay OVERLAY with property name PROP. */)
4076 (Lisp_Object overlay
, Lisp_Object prop
)
4078 CHECK_OVERLAY (overlay
);
4079 return lookup_char_property (XOVERLAY (overlay
)->plist
, prop
, 0);
4082 DEFUN ("overlay-put", Foverlay_put
, Soverlay_put
, 3, 3, 0,
4083 doc
: /* Set one property of overlay OVERLAY: give property PROP value VALUE.
4084 VALUE will be returned.*/)
4085 (Lisp_Object overlay
, Lisp_Object prop
, Lisp_Object value
)
4087 Lisp_Object tail
, buffer
;
4090 CHECK_OVERLAY (overlay
);
4092 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4094 for (tail
= XOVERLAY (overlay
)->plist
;
4095 CONSP (tail
) && CONSP (XCDR (tail
));
4096 tail
= XCDR (XCDR (tail
)))
4097 if (EQ (XCAR (tail
), prop
))
4099 changed
= !EQ (XCAR (XCDR (tail
)), value
);
4100 XSETCAR (XCDR (tail
), value
);
4103 /* It wasn't in the list, so add it to the front. */
4104 changed
= !NILP (value
);
4105 XOVERLAY (overlay
)->plist
4106 = Fcons (prop
, Fcons (value
, XOVERLAY (overlay
)->plist
));
4108 if (! NILP (buffer
))
4111 modify_overlay (XBUFFER (buffer
),
4112 marker_position (OVERLAY_START (overlay
)),
4113 marker_position (OVERLAY_END (overlay
)));
4114 if (EQ (prop
, Qevaporate
) && ! NILP (value
)
4115 && (OVERLAY_POSITION (OVERLAY_START (overlay
))
4116 == OVERLAY_POSITION (OVERLAY_END (overlay
))))
4117 Fdelete_overlay (overlay
);
4123 /* Subroutine of report_overlay_modification. */
4125 /* Lisp vector holding overlay hook functions to call.
4126 Vector elements come in pairs.
4127 Each even-index element is a list of hook functions.
4128 The following odd-index element is the overlay they came from.
4130 Before the buffer change, we fill in this vector
4131 as we call overlay hook functions.
4132 After the buffer change, we get the functions to call from this vector.
4133 This way we always call the same functions before and after the change. */
4134 static Lisp_Object last_overlay_modification_hooks
;
4136 /* Number of elements actually used in last_overlay_modification_hooks. */
4137 static ptrdiff_t last_overlay_modification_hooks_used
;
4139 /* Add one functionlist/overlay pair
4140 to the end of last_overlay_modification_hooks. */
4143 add_overlay_mod_hooklist (Lisp_Object functionlist
, Lisp_Object overlay
)
4145 ptrdiff_t oldsize
= ASIZE (last_overlay_modification_hooks
);
4147 if (oldsize
- 1 <= last_overlay_modification_hooks_used
)
4148 last_overlay_modification_hooks
=
4149 larger_vector (last_overlay_modification_hooks
, 2, -1);
4150 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4151 functionlist
); last_overlay_modification_hooks_used
++;
4152 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4153 overlay
); last_overlay_modification_hooks_used
++;
4156 /* Run the modification-hooks of overlays that include
4157 any part of the text in START to END.
4158 If this change is an insertion, also
4159 run the insert-before-hooks of overlay starting at END,
4160 and the insert-after-hooks of overlay ending at START.
4162 This is called both before and after the modification.
4163 AFTER is nonzero when we call after the modification.
4165 ARG1, ARG2, ARG3 are arguments to pass to the hook functions.
4166 When AFTER is nonzero, they are the start position,
4167 the position after the inserted new text,
4168 and the length of deleted or replaced old text. */
4171 report_overlay_modification (Lisp_Object start
, Lisp_Object end
, int after
,
4172 Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
)
4174 Lisp_Object prop
, overlay
;
4175 struct Lisp_Overlay
*tail
;
4176 /* 1 if this change is an insertion. */
4177 int insertion
= (after
? XFASTINT (arg3
) == 0 : EQ (start
, end
));
4178 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4183 /* We used to run the functions as soon as we found them and only register
4184 them in last_overlay_modification_hooks for the purpose of the `after'
4185 case. But running elisp code as we traverse the list of overlays is
4186 painful because the list can be modified by the elisp code so we had to
4187 copy at several places. We now simply do a read-only traversal that
4188 only collects the functions to run and we run them afterwards. It's
4189 simpler, especially since all the code was already there. -stef */
4193 /* We are being called before a change.
4194 Scan the overlays to find the functions to call. */
4195 last_overlay_modification_hooks_used
= 0;
4196 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4198 ptrdiff_t startpos
, endpos
;
4199 Lisp_Object ostart
, oend
;
4201 XSETMISC (overlay
, tail
);
4203 ostart
= OVERLAY_START (overlay
);
4204 oend
= OVERLAY_END (overlay
);
4205 endpos
= OVERLAY_POSITION (oend
);
4206 if (XFASTINT (start
) > endpos
)
4208 startpos
= OVERLAY_POSITION (ostart
);
4209 if (insertion
&& (XFASTINT (start
) == startpos
4210 || XFASTINT (end
) == startpos
))
4212 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4214 add_overlay_mod_hooklist (prop
, overlay
);
4216 if (insertion
&& (XFASTINT (start
) == endpos
4217 || XFASTINT (end
) == endpos
))
4219 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4221 add_overlay_mod_hooklist (prop
, overlay
);
4223 /* Test for intersecting intervals. This does the right thing
4224 for both insertion and deletion. */
4225 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4227 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4229 add_overlay_mod_hooklist (prop
, overlay
);
4233 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4235 ptrdiff_t startpos
, endpos
;
4236 Lisp_Object ostart
, oend
;
4238 XSETMISC (overlay
, tail
);
4240 ostart
= OVERLAY_START (overlay
);
4241 oend
= OVERLAY_END (overlay
);
4242 startpos
= OVERLAY_POSITION (ostart
);
4243 endpos
= OVERLAY_POSITION (oend
);
4244 if (XFASTINT (end
) < startpos
)
4246 if (insertion
&& (XFASTINT (start
) == startpos
4247 || XFASTINT (end
) == startpos
))
4249 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4251 add_overlay_mod_hooklist (prop
, overlay
);
4253 if (insertion
&& (XFASTINT (start
) == endpos
4254 || XFASTINT (end
) == endpos
))
4256 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4258 add_overlay_mod_hooklist (prop
, overlay
);
4260 /* Test for intersecting intervals. This does the right thing
4261 for both insertion and deletion. */
4262 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4264 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4266 add_overlay_mod_hooklist (prop
, overlay
);
4271 GCPRO4 (overlay
, arg1
, arg2
, arg3
);
4273 /* Call the functions recorded in last_overlay_modification_hooks.
4274 First copy the vector contents, in case some of these hooks
4275 do subsequent modification of the buffer. */
4276 ptrdiff_t size
= last_overlay_modification_hooks_used
;
4277 Lisp_Object
*copy
= alloca (size
* sizeof *copy
);
4280 memcpy (copy
, XVECTOR (last_overlay_modification_hooks
)->contents
,
4281 size
* sizeof (Lisp_Object
));
4283 gcpro1
.nvars
= size
;
4285 for (i
= 0; i
< size
;)
4287 Lisp_Object prop_i
, overlay_i
;
4289 overlay_i
= copy
[i
++];
4290 call_overlay_mod_hooks (prop_i
, overlay_i
, after
, arg1
, arg2
, arg3
);
4297 call_overlay_mod_hooks (Lisp_Object list
, Lisp_Object overlay
, int after
,
4298 Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
)
4300 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4302 GCPRO4 (list
, arg1
, arg2
, arg3
);
4304 while (CONSP (list
))
4307 call4 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
);
4309 call5 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
, arg3
);
4315 /* Delete any zero-sized overlays at position POS, if the `evaporate'
4318 evaporate_overlays (ptrdiff_t pos
)
4320 Lisp_Object overlay
, hit_list
;
4321 struct Lisp_Overlay
*tail
;
4324 if (pos
<= current_buffer
->overlay_center
)
4325 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4328 XSETMISC (overlay
, tail
);
4329 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4332 if (endpos
== pos
&& OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
4333 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4334 hit_list
= Fcons (overlay
, hit_list
);
4337 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4340 XSETMISC (overlay
, tail
);
4341 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4344 if (startpos
== pos
&& OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
4345 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4346 hit_list
= Fcons (overlay
, hit_list
);
4348 for (; CONSP (hit_list
); hit_list
= XCDR (hit_list
))
4349 Fdelete_overlay (XCAR (hit_list
));
4352 /* Somebody has tried to store a value with an unacceptable type
4353 in the slot with offset OFFSET. */
4356 buffer_slot_type_mismatch (Lisp_Object newval
, int type
)
4358 Lisp_Object predicate
;
4362 case_Lisp_Int
: predicate
= Qintegerp
; break;
4363 case Lisp_String
: predicate
= Qstringp
; break;
4364 case Lisp_Symbol
: predicate
= Qsymbolp
; break;
4368 wrong_type_argument (predicate
, newval
);
4372 /***********************************************************************
4373 Allocation with mmap
4374 ***********************************************************************/
4376 #ifdef USE_MMAP_FOR_BUFFERS
4378 #include <sys/types.h>
4379 #include <sys/mman.h>
4382 #ifdef MAP_ANONYMOUS
4383 #define MAP_ANON MAP_ANONYMOUS
4390 #define MAP_FAILED ((void *) -1)
4402 /* Memory is allocated in regions which are mapped using mmap(2).
4403 The current implementation lets the system select mapped
4404 addresses; we're not using MAP_FIXED in general, except when
4405 trying to enlarge regions.
4407 Each mapped region starts with a mmap_region structure, the user
4408 area starts after that structure, aligned to MEM_ALIGN.
4410 +-----------------------+
4411 | struct mmap_info + |
4413 +-----------------------+
4417 +-----------------------+ */
4421 /* User-specified size. */
4422 size_t nbytes_specified
;
4424 /* Number of bytes mapped */
4425 size_t nbytes_mapped
;
4427 /* Pointer to the location holding the address of the memory
4428 allocated with the mmap'd block. The variable actually points
4429 after this structure. */
4432 /* Next and previous in list of all mmap'd regions. */
4433 struct mmap_region
*next
, *prev
;
4436 /* Doubly-linked list of mmap'd regions. */
4438 static struct mmap_region
*mmap_regions
;
4440 /* File descriptor for mmap. If we don't have anonymous mapping,
4441 /dev/zero will be opened on it. */
4445 /* Temporary storage for mmap_set_vars, see there. */
4447 static struct mmap_region
*mmap_regions_1
;
4448 static int mmap_fd_1
;
4450 /* Page size on this system. */
4452 static int mmap_page_size
;
4454 /* 1 means mmap has been initialized. */
4456 static int mmap_initialized_p
;
4458 /* Value is X rounded up to the next multiple of N. */
4460 #define ROUND(X, N) (((X) + (N) - 1) / (N) * (N))
4462 /* Size of mmap_region structure plus padding. */
4464 #define MMAP_REGION_STRUCT_SIZE \
4465 ROUND (sizeof (struct mmap_region), MEM_ALIGN)
4467 /* Given a pointer P to the start of the user-visible part of a mapped
4468 region, return a pointer to the start of the region. */
4470 #define MMAP_REGION(P) \
4471 ((struct mmap_region *) ((char *) (P) - MMAP_REGION_STRUCT_SIZE))
4473 /* Given a pointer P to the start of a mapped region, return a pointer
4474 to the start of the user-visible part of the region. */
4476 #define MMAP_USER_AREA(P) \
4477 ((void *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
4479 #define MEM_ALIGN sizeof (double)
4481 /* Predicate returning true if part of the address range [START .. END]
4482 is currently mapped. Used to prevent overwriting an existing
4485 Default is to conservatively assume the address range is occupied by
4486 something else. This can be overridden by system configuration
4487 files if system-specific means to determine this exists. */
4489 #ifndef MMAP_ALLOCATED_P
4490 #define MMAP_ALLOCATED_P(start, end) 1
4493 /* Perform necessary initializations for the use of mmap. */
4499 /* The value of mmap_fd is initially 0 in temacs, and -1
4500 in a dumped Emacs. */
4503 /* No anonymous mmap -- we need the file descriptor. */
4504 mmap_fd
= open ("/dev/zero", O_RDONLY
);
4506 fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno
));
4508 #endif /* MAP_ANON == 0 */
4510 if (mmap_initialized_p
)
4512 mmap_initialized_p
= 1;
4518 mmap_page_size
= getpagesize ();
4521 /* Return a region overlapping address range START...END, or null if
4522 none. END is not including, i.e. the last byte in the range
4525 static struct mmap_region
*
4526 mmap_find (void *start
, void *end
)
4528 struct mmap_region
*r
;
4529 char *s
= (char *) start
, *e
= (char *) end
;
4531 for (r
= mmap_regions
; r
; r
= r
->next
)
4533 char *rstart
= (char *) r
;
4534 char *rend
= rstart
+ r
->nbytes_mapped
;
4536 if (/* First byte of range, i.e. START, in this region? */
4537 (s
>= rstart
&& s
< rend
)
4538 /* Last byte of range, i.e. END - 1, in this region? */
4539 || (e
> rstart
&& e
<= rend
)
4540 /* First byte of this region in the range? */
4541 || (rstart
>= s
&& rstart
< e
)
4542 /* Last byte of this region in the range? */
4543 || (rend
> s
&& rend
<= e
))
4551 /* Unmap a region. P is a pointer to the start of the user-araa of
4552 the region. Value is non-zero if successful. */
4555 mmap_free_1 (struct mmap_region
*r
)
4558 r
->next
->prev
= r
->prev
;
4560 r
->prev
->next
= r
->next
;
4562 mmap_regions
= r
->next
;
4564 if (munmap (r
, r
->nbytes_mapped
) == -1)
4566 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4574 /* Enlarge region R by NPAGES pages. NPAGES < 0 means shrink R.
4575 Value is non-zero if successful. */
4578 mmap_enlarge (struct mmap_region
*r
, int npages
)
4580 char *region_end
= (char *) r
+ r
->nbytes_mapped
;
4586 /* Unmap pages at the end of the region. */
4587 nbytes
= - npages
* mmap_page_size
;
4588 if (munmap (region_end
- nbytes
, nbytes
) == -1)
4589 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4592 r
->nbytes_mapped
-= nbytes
;
4596 else if (npages
> 0)
4598 nbytes
= npages
* mmap_page_size
;
4600 /* Try to map additional pages at the end of the region. We
4601 cannot do this if the address range is already occupied by
4602 something else because mmap deletes any previous mapping.
4603 I'm not sure this is worth doing, let's see. */
4604 if (!MMAP_ALLOCATED_P (region_end
, region_end
+ nbytes
))
4608 p
= mmap (region_end
, nbytes
, PROT_READ
| PROT_WRITE
,
4609 MAP_ANON
| MAP_PRIVATE
| MAP_FIXED
, mmap_fd
, 0);
4610 if (p
== MAP_FAILED
)
4611 ; /* fprintf (stderr, "mmap: %s\n", emacs_strerror (errno)); */
4612 else if (p
!= region_end
)
4614 /* Kernels are free to choose a different address. In
4615 that case, unmap what we've mapped above; we have
4617 if (munmap (p
, nbytes
) == -1)
4618 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4622 r
->nbytes_mapped
+= nbytes
;
4632 /* Set or reset variables holding references to mapped regions. If
4633 RESTORE_P is zero, set all variables to null. If RESTORE_P is
4634 non-zero, set all variables to the start of the user-areas
4637 This function is called from Fdump_emacs to ensure that the dumped
4638 Emacs doesn't contain references to memory that won't be mapped
4639 when Emacs starts. */
4642 mmap_set_vars (int restore_p
)
4644 struct mmap_region
*r
;
4648 mmap_regions
= mmap_regions_1
;
4649 mmap_fd
= mmap_fd_1
;
4650 for (r
= mmap_regions
; r
; r
= r
->next
)
4651 *r
->var
= MMAP_USER_AREA (r
);
4655 for (r
= mmap_regions
; r
; r
= r
->next
)
4657 mmap_regions_1
= mmap_regions
;
4658 mmap_regions
= NULL
;
4659 mmap_fd_1
= mmap_fd
;
4665 /* Allocate a block of storage large enough to hold NBYTES bytes of
4666 data. A pointer to the data is returned in *VAR. VAR is thus the
4667 address of some variable which will use the data area.
4669 The allocation of 0 bytes is valid.
4671 If we can't allocate the necessary memory, set *VAR to null, and
4675 mmap_alloc (void **var
, size_t nbytes
)
4682 map
= ROUND (nbytes
+ MMAP_REGION_STRUCT_SIZE
, mmap_page_size
);
4683 p
= mmap (NULL
, map
, PROT_READ
| PROT_WRITE
, MAP_ANON
| MAP_PRIVATE
,
4686 if (p
== MAP_FAILED
)
4688 if (errno
!= ENOMEM
)
4689 fprintf (stderr
, "mmap: %s\n", emacs_strerror (errno
));
4694 struct mmap_region
*r
= (struct mmap_region
*) p
;
4696 r
->nbytes_specified
= nbytes
;
4697 r
->nbytes_mapped
= map
;
4700 r
->next
= mmap_regions
;
4705 p
= MMAP_USER_AREA (p
);
4712 /* Free a block of relocatable storage whose data is pointed to by
4713 PTR. Store 0 in *PTR to show there's no block allocated. */
4716 mmap_free (void **var
)
4722 mmap_free_1 (MMAP_REGION (*var
));
4728 /* Given a pointer at address VAR to data allocated with mmap_alloc,
4729 resize it to size NBYTES. Change *VAR to reflect the new block,
4730 and return this value. If more memory cannot be allocated, then
4731 leave *VAR unchanged, and return null. */
4734 mmap_realloc (void **var
, size_t nbytes
)
4741 result
= mmap_alloc (var
, nbytes
);
4742 else if (nbytes
== 0)
4745 result
= mmap_alloc (var
, nbytes
);
4749 struct mmap_region
*r
= MMAP_REGION (*var
);
4750 size_t room
= r
->nbytes_mapped
- MMAP_REGION_STRUCT_SIZE
;
4755 void *old_ptr
= *var
;
4757 /* Try to map additional pages at the end of the region.
4758 If that fails, allocate a new region, copy data
4759 from the old region, then free it. */
4760 if (mmap_enlarge (r
, (ROUND (nbytes
- room
, mmap_page_size
)
4763 r
->nbytes_specified
= nbytes
;
4764 *var
= result
= old_ptr
;
4766 else if (mmap_alloc (var
, nbytes
))
4768 memcpy (*var
, old_ptr
, r
->nbytes_specified
);
4769 mmap_free_1 (MMAP_REGION (old_ptr
));
4771 r
= MMAP_REGION (result
);
4772 r
->nbytes_specified
= nbytes
;
4780 else if (room
- nbytes
>= mmap_page_size
)
4782 /* Shrinking by at least a page. Let's give some
4783 memory back to the system.
4785 The extra parens are to make the division happens first,
4786 on positive values, so we know it will round towards
4788 mmap_enlarge (r
, - ((room
- nbytes
) / mmap_page_size
));
4790 r
->nbytes_specified
= nbytes
;
4794 /* Leave it alone. */
4796 r
->nbytes_specified
= nbytes
;
4804 #endif /* USE_MMAP_FOR_BUFFERS */
4808 /***********************************************************************
4809 Buffer-text Allocation
4810 ***********************************************************************/
4812 /* Allocate NBYTES bytes for buffer B's text buffer. */
4815 alloc_buffer_text (struct buffer
*b
, ptrdiff_t nbytes
)
4820 #if defined USE_MMAP_FOR_BUFFERS
4821 p
= mmap_alloc ((void **) &b
->text
->beg
, nbytes
);
4822 #elif defined REL_ALLOC
4823 p
= r_alloc ((void **) &b
->text
->beg
, nbytes
);
4825 p
= xmalloc (nbytes
);
4831 memory_full (nbytes
);
4834 b
->text
->beg
= (unsigned char *) p
;
4838 /* Enlarge buffer B's text buffer by DELTA bytes. DELTA < 0 means
4842 enlarge_buffer_text (struct buffer
*b
, ptrdiff_t delta
)
4845 ptrdiff_t nbytes
= (BUF_Z_BYTE (b
) - BUF_BEG_BYTE (b
) + BUF_GAP_SIZE (b
) + 1
4848 #if defined USE_MMAP_FOR_BUFFERS
4849 p
= mmap_realloc ((void **) &b
->text
->beg
, nbytes
);
4850 #elif defined REL_ALLOC
4851 p
= r_re_alloc ((void **) &b
->text
->beg
, nbytes
);
4853 p
= xrealloc (b
->text
->beg
, nbytes
);
4859 memory_full (nbytes
);
4862 BUF_BEG_ADDR (b
) = (unsigned char *) p
;
4867 /* Free buffer B's text buffer. */
4870 free_buffer_text (struct buffer
*b
)
4874 #if defined USE_MMAP_FOR_BUFFERS
4875 mmap_free ((void **) &b
->text
->beg
);
4876 #elif defined REL_ALLOC
4877 r_alloc_free ((void **) &b
->text
->beg
);
4879 xfree (b
->text
->beg
);
4882 BUF_BEG_ADDR (b
) = NULL
;
4888 /***********************************************************************
4890 ***********************************************************************/
4893 init_buffer_once (void)
4896 /* If you add, remove, or reorder Lisp_Objects in a struct buffer, make
4897 sure that this is still correct. Otherwise, mark_vectorlike may not
4898 trace all Lisp_Objects in buffer_defaults and buffer_local_symbols. */
4900 = (offsetof (struct buffer
, own_text
) - sizeof (struct vectorlike_header
))
4901 / sizeof (Lisp_Object
);
4903 memset (buffer_permanent_local_flags
, 0, sizeof buffer_permanent_local_flags
);
4905 /* Make sure all markable slots in buffer_defaults
4906 are initialized reasonably, so mark_buffer won't choke. */
4907 reset_buffer (&buffer_defaults
);
4908 eassert (EQ (BVAR (&buffer_defaults
, name
), make_number (0)));
4909 reset_buffer_local_variables (&buffer_defaults
, 1);
4910 eassert (EQ (BVAR (&buffer_local_symbols
, name
), make_number (0)));
4911 reset_buffer (&buffer_local_symbols
);
4912 reset_buffer_local_variables (&buffer_local_symbols
, 1);
4913 /* Prevent GC from getting confused. */
4914 buffer_defaults
.text
= &buffer_defaults
.own_text
;
4915 buffer_local_symbols
.text
= &buffer_local_symbols
.own_text
;
4916 BUF_INTERVALS (&buffer_defaults
) = 0;
4917 BUF_INTERVALS (&buffer_local_symbols
) = 0;
4918 XSETPVECTYPESIZE (&buffer_defaults
, PVEC_BUFFER
, pvecsize
);
4919 XSETBUFFER (Vbuffer_defaults
, &buffer_defaults
);
4920 XSETPVECTYPESIZE (&buffer_local_symbols
, PVEC_BUFFER
, pvecsize
);
4921 XSETBUFFER (Vbuffer_local_symbols
, &buffer_local_symbols
);
4923 /* Set up the default values of various buffer slots. */
4924 /* Must do these before making the first buffer! */
4926 /* real setup is done in bindings.el */
4927 BVAR (&buffer_defaults
, mode_line_format
) = build_pure_c_string ("%-");
4928 BVAR (&buffer_defaults
, header_line_format
) = Qnil
;
4929 BVAR (&buffer_defaults
, abbrev_mode
) = Qnil
;
4930 BVAR (&buffer_defaults
, overwrite_mode
) = Qnil
;
4931 BVAR (&buffer_defaults
, case_fold_search
) = Qt
;
4932 BVAR (&buffer_defaults
, auto_fill_function
) = Qnil
;
4933 BVAR (&buffer_defaults
, selective_display
) = Qnil
;
4934 BVAR (&buffer_defaults
, selective_display_ellipses
) = Qt
;
4935 BVAR (&buffer_defaults
, abbrev_table
) = Qnil
;
4936 BVAR (&buffer_defaults
, display_table
) = Qnil
;
4937 BVAR (&buffer_defaults
, undo_list
) = Qnil
;
4938 BVAR (&buffer_defaults
, mark_active
) = Qnil
;
4939 BVAR (&buffer_defaults
, file_format
) = Qnil
;
4940 BVAR (&buffer_defaults
, auto_save_file_format
) = Qt
;
4941 buffer_defaults
.overlays_before
= NULL
;
4942 buffer_defaults
.overlays_after
= NULL
;
4943 buffer_defaults
.overlay_center
= BEG
;
4945 XSETFASTINT (BVAR (&buffer_defaults
, tab_width
), 8);
4946 BVAR (&buffer_defaults
, truncate_lines
) = Qnil
;
4947 BVAR (&buffer_defaults
, word_wrap
) = Qnil
;
4948 BVAR (&buffer_defaults
, ctl_arrow
) = Qt
;
4949 BVAR (&buffer_defaults
, bidi_display_reordering
) = Qt
;
4950 BVAR (&buffer_defaults
, bidi_paragraph_direction
) = Qnil
;
4951 BVAR (&buffer_defaults
, cursor_type
) = Qt
;
4952 BVAR (&buffer_defaults
, extra_line_spacing
) = Qnil
;
4953 BVAR (&buffer_defaults
, cursor_in_non_selected_windows
) = Qt
;
4955 BVAR (&buffer_defaults
, enable_multibyte_characters
) = Qt
;
4956 BVAR (&buffer_defaults
, buffer_file_coding_system
) = Qnil
;
4957 XSETFASTINT (BVAR (&buffer_defaults
, fill_column
), 70);
4958 XSETFASTINT (BVAR (&buffer_defaults
, left_margin
), 0);
4959 BVAR (&buffer_defaults
, cache_long_line_scans
) = Qnil
;
4960 BVAR (&buffer_defaults
, file_truename
) = Qnil
;
4961 XSETFASTINT (BVAR (&buffer_defaults
, display_count
), 0);
4962 XSETFASTINT (BVAR (&buffer_defaults
, left_margin_cols
), 0);
4963 XSETFASTINT (BVAR (&buffer_defaults
, right_margin_cols
), 0);
4964 BVAR (&buffer_defaults
, left_fringe_width
) = Qnil
;
4965 BVAR (&buffer_defaults
, right_fringe_width
) = Qnil
;
4966 BVAR (&buffer_defaults
, fringes_outside_margins
) = Qnil
;
4967 BVAR (&buffer_defaults
, scroll_bar_width
) = Qnil
;
4968 BVAR (&buffer_defaults
, vertical_scroll_bar_type
) = Qt
;
4969 BVAR (&buffer_defaults
, indicate_empty_lines
) = Qnil
;
4970 BVAR (&buffer_defaults
, indicate_buffer_boundaries
) = Qnil
;
4971 BVAR (&buffer_defaults
, fringe_indicator_alist
) = Qnil
;
4972 BVAR (&buffer_defaults
, fringe_cursor_alist
) = Qnil
;
4973 BVAR (&buffer_defaults
, scroll_up_aggressively
) = Qnil
;
4974 BVAR (&buffer_defaults
, scroll_down_aggressively
) = Qnil
;
4975 BVAR (&buffer_defaults
, display_time
) = Qnil
;
4977 /* Assign the local-flags to the slots that have default values.
4978 The local flag is a bit that is used in the buffer
4979 to say that it has its own local value for the slot.
4980 The local flag bits are in the local_var_flags slot of the buffer. */
4982 /* Nothing can work if this isn't true */
4983 { verify (sizeof (EMACS_INT
) == sizeof (Lisp_Object
)); }
4985 /* 0 means not a lisp var, -1 means always local, else mask */
4986 memset (&buffer_local_flags
, 0, sizeof buffer_local_flags
);
4987 XSETINT (BVAR (&buffer_local_flags
, filename
), -1);
4988 XSETINT (BVAR (&buffer_local_flags
, directory
), -1);
4989 XSETINT (BVAR (&buffer_local_flags
, backed_up
), -1);
4990 XSETINT (BVAR (&buffer_local_flags
, save_length
), -1);
4991 XSETINT (BVAR (&buffer_local_flags
, auto_save_file_name
), -1);
4992 XSETINT (BVAR (&buffer_local_flags
, read_only
), -1);
4993 XSETINT (BVAR (&buffer_local_flags
, major_mode
), -1);
4994 XSETINT (BVAR (&buffer_local_flags
, mode_name
), -1);
4995 XSETINT (BVAR (&buffer_local_flags
, undo_list
), -1);
4996 XSETINT (BVAR (&buffer_local_flags
, mark_active
), -1);
4997 XSETINT (BVAR (&buffer_local_flags
, point_before_scroll
), -1);
4998 XSETINT (BVAR (&buffer_local_flags
, file_truename
), -1);
4999 XSETINT (BVAR (&buffer_local_flags
, invisibility_spec
), -1);
5000 XSETINT (BVAR (&buffer_local_flags
, file_format
), -1);
5001 XSETINT (BVAR (&buffer_local_flags
, auto_save_file_format
), -1);
5002 XSETINT (BVAR (&buffer_local_flags
, display_count
), -1);
5003 XSETINT (BVAR (&buffer_local_flags
, display_time
), -1);
5004 XSETINT (BVAR (&buffer_local_flags
, enable_multibyte_characters
), -1);
5007 XSETFASTINT (BVAR (&buffer_local_flags
, mode_line_format
), idx
); ++idx
;
5008 XSETFASTINT (BVAR (&buffer_local_flags
, abbrev_mode
), idx
); ++idx
;
5009 XSETFASTINT (BVAR (&buffer_local_flags
, overwrite_mode
), idx
); ++idx
;
5010 XSETFASTINT (BVAR (&buffer_local_flags
, case_fold_search
), idx
); ++idx
;
5011 XSETFASTINT (BVAR (&buffer_local_flags
, auto_fill_function
), idx
); ++idx
;
5012 XSETFASTINT (BVAR (&buffer_local_flags
, selective_display
), idx
); ++idx
;
5013 XSETFASTINT (BVAR (&buffer_local_flags
, selective_display_ellipses
), idx
); ++idx
;
5014 XSETFASTINT (BVAR (&buffer_local_flags
, tab_width
), idx
); ++idx
;
5015 XSETFASTINT (BVAR (&buffer_local_flags
, truncate_lines
), idx
); ++idx
;
5016 XSETFASTINT (BVAR (&buffer_local_flags
, word_wrap
), idx
); ++idx
;
5017 XSETFASTINT (BVAR (&buffer_local_flags
, ctl_arrow
), idx
); ++idx
;
5018 XSETFASTINT (BVAR (&buffer_local_flags
, fill_column
), idx
); ++idx
;
5019 XSETFASTINT (BVAR (&buffer_local_flags
, left_margin
), idx
); ++idx
;
5020 XSETFASTINT (BVAR (&buffer_local_flags
, abbrev_table
), idx
); ++idx
;
5021 XSETFASTINT (BVAR (&buffer_local_flags
, display_table
), idx
); ++idx
;
5022 XSETFASTINT (BVAR (&buffer_local_flags
, syntax_table
), idx
); ++idx
;
5023 XSETFASTINT (BVAR (&buffer_local_flags
, cache_long_line_scans
), idx
); ++idx
;
5024 XSETFASTINT (BVAR (&buffer_local_flags
, category_table
), idx
); ++idx
;
5025 XSETFASTINT (BVAR (&buffer_local_flags
, bidi_display_reordering
), idx
); ++idx
;
5026 XSETFASTINT (BVAR (&buffer_local_flags
, bidi_paragraph_direction
), idx
); ++idx
;
5027 XSETFASTINT (BVAR (&buffer_local_flags
, buffer_file_coding_system
), idx
);
5028 /* Make this one a permanent local. */
5029 buffer_permanent_local_flags
[idx
++] = 1;
5030 XSETFASTINT (BVAR (&buffer_local_flags
, left_margin_cols
), idx
); ++idx
;
5031 XSETFASTINT (BVAR (&buffer_local_flags
, right_margin_cols
), idx
); ++idx
;
5032 XSETFASTINT (BVAR (&buffer_local_flags
, left_fringe_width
), idx
); ++idx
;
5033 XSETFASTINT (BVAR (&buffer_local_flags
, right_fringe_width
), idx
); ++idx
;
5034 XSETFASTINT (BVAR (&buffer_local_flags
, fringes_outside_margins
), idx
); ++idx
;
5035 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_bar_width
), idx
); ++idx
;
5036 XSETFASTINT (BVAR (&buffer_local_flags
, vertical_scroll_bar_type
), idx
); ++idx
;
5037 XSETFASTINT (BVAR (&buffer_local_flags
, indicate_empty_lines
), idx
); ++idx
;
5038 XSETFASTINT (BVAR (&buffer_local_flags
, indicate_buffer_boundaries
), idx
); ++idx
;
5039 XSETFASTINT (BVAR (&buffer_local_flags
, fringe_indicator_alist
), idx
); ++idx
;
5040 XSETFASTINT (BVAR (&buffer_local_flags
, fringe_cursor_alist
), idx
); ++idx
;
5041 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_up_aggressively
), idx
); ++idx
;
5042 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_down_aggressively
), idx
); ++idx
;
5043 XSETFASTINT (BVAR (&buffer_local_flags
, header_line_format
), idx
); ++idx
;
5044 XSETFASTINT (BVAR (&buffer_local_flags
, cursor_type
), idx
); ++idx
;
5045 XSETFASTINT (BVAR (&buffer_local_flags
, extra_line_spacing
), idx
); ++idx
;
5046 XSETFASTINT (BVAR (&buffer_local_flags
, cursor_in_non_selected_windows
), idx
); ++idx
;
5048 /* Need more room? */
5049 if (idx
>= MAX_PER_BUFFER_VARS
)
5051 last_per_buffer_idx
= idx
;
5053 Vbuffer_alist
= Qnil
;
5057 QSFundamental
= build_pure_c_string ("Fundamental");
5059 Qfundamental_mode
= intern_c_string ("fundamental-mode");
5060 BVAR (&buffer_defaults
, major_mode
) = Qfundamental_mode
;
5062 Qmode_class
= intern_c_string ("mode-class");
5064 Qprotected_field
= intern_c_string ("protected-field");
5066 Qpermanent_local
= intern_c_string ("permanent-local");
5068 Qkill_buffer_hook
= intern_c_string ("kill-buffer-hook");
5069 Fput (Qkill_buffer_hook
, Qpermanent_local
, Qt
);
5071 /* super-magic invisible buffer */
5072 Vprin1_to_string_buffer
= Fget_buffer_create (build_pure_c_string (" prin1"));
5073 Vbuffer_alist
= Qnil
;
5075 Fset_buffer (Fget_buffer_create (build_pure_c_string ("*scratch*")));
5077 inhibit_modification_hooks
= 0;
5087 #ifdef USE_MMAP_FOR_BUFFERS
5089 /* When using the ralloc implementation based on mmap(2), buffer
5090 text pointers will have been set to null in the dumped Emacs.
5095 if (b
->text
->beg
== NULL
)
5096 enlarge_buffer_text (b
, 0);
5098 #endif /* USE_MMAP_FOR_BUFFERS */
5100 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
5101 if (NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
)))
5102 Fset_buffer_multibyte (Qnil
);
5104 pwd
= get_current_dir_name ();
5107 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5109 /* Maybe this should really use some standard subroutine
5110 whose definition is filename syntax dependent. */
5112 if (!(IS_DIRECTORY_SEP (pwd
[len
- 1])))
5114 /* Grow buffer to add directory separator and '\0'. */
5115 pwd
= realloc (pwd
, len
+ 2);
5117 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5118 pwd
[len
] = DIRECTORY_SEP
;
5119 pwd
[len
+ 1] = '\0';
5123 BVAR (current_buffer
, directory
) = make_unibyte_string (pwd
, len
);
5124 if (! NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
)))
5125 /* At this moment, we still don't know how to decode the
5126 directory name. So, we keep the bytes in multibyte form so
5127 that ENCODE_FILE correctly gets the original bytes. */
5128 BVAR (current_buffer
, directory
)
5129 = string_to_multibyte (BVAR (current_buffer
, directory
));
5131 /* Add /: to the front of the name
5132 if it would otherwise be treated as magic. */
5133 temp
= Ffind_file_name_handler (BVAR (current_buffer
, directory
), Qt
);
5135 /* If the default dir is just /, TEMP is non-nil
5136 because of the ange-ftp completion handler.
5137 However, it is not necessary to turn / into /:/.
5138 So avoid doing that. */
5139 && strcmp ("/", SSDATA (BVAR (current_buffer
, directory
))))
5140 BVAR (current_buffer
, directory
)
5141 = concat2 (build_string ("/:"), BVAR (current_buffer
, directory
));
5143 temp
= get_minibuffer (0);
5144 BVAR (XBUFFER (temp
), directory
) = BVAR (current_buffer
, directory
);
5149 /* Similar to defvar_lisp but define a variable whose value is the Lisp
5150 Object stored in the current buffer. address is the address of the slot
5151 in the buffer that is current now. */
5153 /* TYPE is nil for a general Lisp variable.
5154 An integer specifies a type; then only Lisp values
5155 with that type code are allowed (except that nil is allowed too).
5156 LNAME is the Lisp-level variable name.
5157 VNAME is the name of the buffer slot.
5158 DOC is a dummy where you write the doc string as a comment. */
5159 #define DEFVAR_PER_BUFFER(lname, vname, type, doc) \
5161 static struct Lisp_Buffer_Objfwd bo_fwd; \
5162 defvar_per_buffer (&bo_fwd, lname, vname, type); \
5166 defvar_per_buffer (struct Lisp_Buffer_Objfwd
*bo_fwd
, const char *namestring
,
5167 Lisp_Object
*address
, Lisp_Object type
)
5169 struct Lisp_Symbol
*sym
;
5172 sym
= XSYMBOL (intern (namestring
));
5173 offset
= (char *)address
- (char *)current_buffer
;
5175 bo_fwd
->type
= Lisp_Fwd_Buffer_Obj
;
5176 bo_fwd
->offset
= offset
;
5177 bo_fwd
->slottype
= type
;
5178 sym
->declared_special
= 1;
5179 sym
->redirect
= SYMBOL_FORWARDED
;
5181 /* I tried to do the job without a cast, but it seems impossible.
5182 union Lisp_Fwd *fwd; &(fwd->u_buffer_objfwd) = bo_fwd; */
5183 SET_SYMBOL_FWD (sym
, (union Lisp_Fwd
*)bo_fwd
);
5185 XSETSYMBOL (PER_BUFFER_SYMBOL (offset
), sym
);
5187 if (PER_BUFFER_IDX (offset
) == 0)
5188 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
5189 slot of buffer_local_flags */
5194 /* initialize the buffer routines */
5196 syms_of_buffer (void)
5198 staticpro (&last_overlay_modification_hooks
);
5199 last_overlay_modification_hooks
5200 = Fmake_vector (make_number (10), Qnil
);
5202 staticpro (&Vbuffer_defaults
);
5203 staticpro (&Vbuffer_local_symbols
);
5204 staticpro (&Qfundamental_mode
);
5205 staticpro (&Qmode_class
);
5206 staticpro (&QSFundamental
);
5207 staticpro (&Vbuffer_alist
);
5208 staticpro (&Qprotected_field
);
5209 staticpro (&Qpermanent_local
);
5210 staticpro (&Qkill_buffer_hook
);
5212 DEFSYM (Qpermanent_local_hook
, "permanent-local-hook");
5213 DEFSYM (Qoverlayp
, "overlayp");
5214 DEFSYM (Qevaporate
, "evaporate");
5215 DEFSYM (Qmodification_hooks
, "modification-hooks");
5216 DEFSYM (Qinsert_in_front_hooks
, "insert-in-front-hooks");
5217 DEFSYM (Qinsert_behind_hooks
, "insert-behind-hooks");
5218 DEFSYM (Qget_file_buffer
, "get-file-buffer");
5219 DEFSYM (Qpriority
, "priority");
5220 DEFSYM (Qbefore_string
, "before-string");
5221 DEFSYM (Qafter_string
, "after-string");
5222 DEFSYM (Qfirst_change_hook
, "first-change-hook");
5223 DEFSYM (Qbefore_change_functions
, "before-change-functions");
5224 DEFSYM (Qafter_change_functions
, "after-change-functions");
5225 DEFSYM (Qkill_buffer_query_functions
, "kill-buffer-query-functions");
5227 Fput (Qprotected_field
, Qerror_conditions
,
5228 pure_cons (Qprotected_field
, pure_cons (Qerror
, Qnil
)));
5229 Fput (Qprotected_field
, Qerror_message
,
5230 build_pure_c_string ("Attempt to modify a protected field"));
5232 DEFVAR_BUFFER_DEFAULTS ("default-mode-line-format",
5234 doc
: /* Default value of `mode-line-format' for buffers that don't override it.
5235 This is the same as (default-value 'mode-line-format). */);
5237 DEFVAR_BUFFER_DEFAULTS ("default-header-line-format",
5239 doc
: /* Default value of `header-line-format' for buffers that don't override it.
5240 This is the same as (default-value 'header-line-format). */);
5242 DEFVAR_BUFFER_DEFAULTS ("default-cursor-type", cursor_type
,
5243 doc
: /* Default value of `cursor-type' for buffers that don't override it.
5244 This is the same as (default-value 'cursor-type). */);
5246 DEFVAR_BUFFER_DEFAULTS ("default-line-spacing",
5248 doc
: /* Default value of `line-spacing' for buffers that don't override it.
5249 This is the same as (default-value 'line-spacing). */);
5251 DEFVAR_BUFFER_DEFAULTS ("default-cursor-in-non-selected-windows",
5252 cursor_in_non_selected_windows
,
5253 doc
: /* Default value of `cursor-in-non-selected-windows'.
5254 This is the same as (default-value 'cursor-in-non-selected-windows). */);
5256 DEFVAR_BUFFER_DEFAULTS ("default-abbrev-mode",
5258 doc
: /* Default value of `abbrev-mode' for buffers that do not override it.
5259 This is the same as (default-value 'abbrev-mode). */);
5261 DEFVAR_BUFFER_DEFAULTS ("default-ctl-arrow",
5263 doc
: /* Default value of `ctl-arrow' for buffers that do not override it.
5264 This is the same as (default-value 'ctl-arrow). */);
5266 DEFVAR_BUFFER_DEFAULTS ("default-enable-multibyte-characters",
5267 enable_multibyte_characters
,
5268 doc
: /* Default value of `enable-multibyte-characters' for buffers not overriding it.
5269 This is the same as (default-value 'enable-multibyte-characters). */);
5271 DEFVAR_BUFFER_DEFAULTS ("default-buffer-file-coding-system",
5272 buffer_file_coding_system
,
5273 doc
: /* Default value of `buffer-file-coding-system' for buffers not overriding it.
5274 This is the same as (default-value 'buffer-file-coding-system). */);
5276 DEFVAR_BUFFER_DEFAULTS ("default-truncate-lines",
5278 doc
: /* Default value of `truncate-lines' for buffers that do not override it.
5279 This is the same as (default-value 'truncate-lines). */);
5281 DEFVAR_BUFFER_DEFAULTS ("default-fill-column",
5283 doc
: /* Default value of `fill-column' for buffers that do not override it.
5284 This is the same as (default-value 'fill-column). */);
5286 DEFVAR_BUFFER_DEFAULTS ("default-left-margin",
5288 doc
: /* Default value of `left-margin' for buffers that do not override it.
5289 This is the same as (default-value 'left-margin). */);
5291 DEFVAR_BUFFER_DEFAULTS ("default-tab-width",
5293 doc
: /* Default value of `tab-width' for buffers that do not override it.
5294 This is the same as (default-value 'tab-width). */);
5296 DEFVAR_BUFFER_DEFAULTS ("default-case-fold-search",
5298 doc
: /* Default value of `case-fold-search' for buffers that don't override it.
5299 This is the same as (default-value 'case-fold-search). */);
5301 DEFVAR_BUFFER_DEFAULTS ("default-left-margin-width",
5303 doc
: /* Default value of `left-margin-width' for buffers that don't override it.
5304 This is the same as (default-value 'left-margin-width). */);
5306 DEFVAR_BUFFER_DEFAULTS ("default-right-margin-width",
5308 doc
: /* Default value of `right-margin-width' for buffers that don't override it.
5309 This is the same as (default-value 'right-margin-width). */);
5311 DEFVAR_BUFFER_DEFAULTS ("default-left-fringe-width",
5313 doc
: /* Default value of `left-fringe-width' for buffers that don't override it.
5314 This is the same as (default-value 'left-fringe-width). */);
5316 DEFVAR_BUFFER_DEFAULTS ("default-right-fringe-width",
5318 doc
: /* Default value of `right-fringe-width' for buffers that don't override it.
5319 This is the same as (default-value 'right-fringe-width). */);
5321 DEFVAR_BUFFER_DEFAULTS ("default-fringes-outside-margins",
5322 fringes_outside_margins
,
5323 doc
: /* Default value of `fringes-outside-margins' for buffers that don't override it.
5324 This is the same as (default-value 'fringes-outside-margins). */);
5326 DEFVAR_BUFFER_DEFAULTS ("default-scroll-bar-width",
5328 doc
: /* Default value of `scroll-bar-width' for buffers that don't override it.
5329 This is the same as (default-value 'scroll-bar-width). */);
5331 DEFVAR_BUFFER_DEFAULTS ("default-vertical-scroll-bar",
5332 vertical_scroll_bar_type
,
5333 doc
: /* Default value of `vertical-scroll-bar' for buffers that don't override it.
5334 This is the same as (default-value 'vertical-scroll-bar). */);
5336 DEFVAR_BUFFER_DEFAULTS ("default-indicate-empty-lines",
5337 indicate_empty_lines
,
5338 doc
: /* Default value of `indicate-empty-lines' for buffers that don't override it.
5339 This is the same as (default-value 'indicate-empty-lines). */);
5341 DEFVAR_BUFFER_DEFAULTS ("default-indicate-buffer-boundaries",
5342 indicate_buffer_boundaries
,
5343 doc
: /* Default value of `indicate-buffer-boundaries' for buffers that don't override it.
5344 This is the same as (default-value 'indicate-buffer-boundaries). */);
5346 DEFVAR_BUFFER_DEFAULTS ("default-fringe-indicator-alist",
5347 fringe_indicator_alist
,
5348 doc
: /* Default value of `fringe-indicator-alist' for buffers that don't override it.
5349 This is the same as (default-value 'fringe-indicator-alist'). */);
5351 DEFVAR_BUFFER_DEFAULTS ("default-fringe-cursor-alist",
5352 fringe_cursor_alist
,
5353 doc
: /* Default value of `fringe-cursor-alist' for buffers that don't override it.
5354 This is the same as (default-value 'fringe-cursor-alist'). */);
5356 DEFVAR_BUFFER_DEFAULTS ("default-scroll-up-aggressively",
5357 scroll_up_aggressively
,
5358 doc
: /* Default value of `scroll-up-aggressively'.
5359 This value applies in buffers that don't have their own local values.
5360 This is the same as (default-value 'scroll-up-aggressively). */);
5362 DEFVAR_BUFFER_DEFAULTS ("default-scroll-down-aggressively",
5363 scroll_down_aggressively
,
5364 doc
: /* Default value of `scroll-down-aggressively'.
5365 This value applies in buffers that don't have their own local values.
5366 This is the same as (default-value 'scroll-down-aggressively). */);
5368 DEFVAR_PER_BUFFER ("header-line-format",
5369 &BVAR (current_buffer
, header_line_format
),
5371 doc
: /* Analogous to `mode-line-format', but controls the header line.
5372 The header line appears, optionally, at the top of a window;
5373 the mode line appears at the bottom. */);
5375 DEFVAR_PER_BUFFER ("mode-line-format", &BVAR (current_buffer
, mode_line_format
),
5377 doc
: /* Template for displaying mode line for current buffer.
5379 The value may be nil, a string, a symbol or a list.
5381 A value of nil means don't display a mode line.
5383 For any symbol other than t or nil, the symbol's value is processed as
5384 a mode line construct. As a special exception, if that value is a
5385 string, the string is processed verbatim, without handling any
5386 %-constructs (see below). Also, unless the symbol has a non-nil
5387 `risky-local-variable' property, all properties in any strings, as
5388 well as all :eval and :propertize forms in the value, are ignored.
5390 A list whose car is a string or list is processed by processing each
5391 of the list elements recursively, as separate mode line constructs,
5392 and concatenating the results.
5394 A list of the form `(:eval FORM)' is processed by evaluating FORM and
5395 using the result as a mode line construct. Be careful--FORM should
5396 not load any files, because that can cause an infinite recursion.
5398 A list of the form `(:propertize ELT PROPS...)' is processed by
5399 processing ELT as the mode line construct, and adding the text
5400 properties PROPS to the result.
5402 A list whose car is a symbol is processed by examining the symbol's
5403 value, and, if that value is non-nil, processing the cadr of the list
5404 recursively; and if that value is nil, processing the caddr of the
5407 A list whose car is an integer is processed by processing the cadr of
5408 the list, and padding (if the number is positive) or truncating (if
5409 negative) to the width specified by that number.
5411 A string is printed verbatim in the mode line except for %-constructs:
5412 %b -- print buffer name. %f -- print visited file name.
5413 %F -- print frame name.
5414 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
5415 %& is like %*, but ignore read-only-ness.
5416 % means buffer is read-only and * means it is modified.
5417 For a modified read-only buffer, %* gives % and %+ gives *.
5418 %s -- print process status. %l -- print the current line number.
5419 %c -- print the current column number (this makes editing slower).
5420 To make the column number update correctly in all cases,
5421 `column-number-mode' must be non-nil.
5422 %i -- print the size of the buffer.
5423 %I -- like %i, but use k, M, G, etc., to abbreviate.
5424 %p -- print percent of buffer above top of window, or Top, Bot or All.
5425 %P -- print percent of buffer above bottom of window, perhaps plus Top,
5426 or print Bottom or All.
5427 %n -- print Narrow if appropriate.
5428 %t -- visited file is text or binary (if OS supports this distinction).
5429 %z -- print mnemonics of keyboard, terminal, and buffer coding systems.
5430 %Z -- like %z, but including the end-of-line format.
5431 %e -- print error message about full memory.
5432 %@ -- print @ or hyphen. @ means that default-directory is on a
5434 %[ -- print one [ for each recursive editing level. %] similar.
5435 %% -- print %. %- -- print infinitely many dashes.
5436 Decimal digits after the % specify field width to which to pad. */);
5438 DEFVAR_BUFFER_DEFAULTS ("default-major-mode", major_mode
,
5439 doc
: /* Value of `major-mode' for new buffers. */);
5441 DEFVAR_PER_BUFFER ("major-mode", &BVAR (current_buffer
, major_mode
),
5442 make_number (Lisp_Symbol
),
5443 doc
: /* Symbol for current buffer's major mode.
5444 The default value (normally `fundamental-mode') affects new buffers.
5445 A value of nil means to use the current buffer's major mode, provided
5446 it is not marked as "special".
5448 When a mode is used by default, `find-file' switches to it before it
5449 reads the contents into the buffer and before it finishes setting up
5450 the buffer. Thus, the mode and its hooks should not expect certain
5451 variables such as `buffer-read-only' and `buffer-file-coding-system'
5454 DEFVAR_PER_BUFFER ("mode-name", &BVAR (current_buffer
, mode_name
),
5456 doc
: /* Pretty name of current buffer's major mode.
5457 Usually a string, but can use any of the constructs for `mode-line-format',
5459 Format with `format-mode-line' to produce a string value. */);
5461 DEFVAR_PER_BUFFER ("local-abbrev-table", &BVAR (current_buffer
, abbrev_table
), Qnil
,
5462 doc
: /* Local (mode-specific) abbrev table of current buffer. */);
5464 DEFVAR_PER_BUFFER ("abbrev-mode", &BVAR (current_buffer
, abbrev_mode
), Qnil
,
5465 doc
: /* Non-nil if Abbrev mode is enabled.
5466 Use the command `abbrev-mode' to change this variable. */);
5468 DEFVAR_PER_BUFFER ("case-fold-search", &BVAR (current_buffer
, case_fold_search
),
5470 doc
: /* Non-nil if searches and matches should ignore case. */);
5472 DEFVAR_PER_BUFFER ("fill-column", &BVAR (current_buffer
, fill_column
),
5473 make_number (LISP_INT_TAG
),
5474 doc
: /* Column beyond which automatic line-wrapping should happen.
5475 Interactively, you can set the buffer local value using \\[set-fill-column]. */);
5477 DEFVAR_PER_BUFFER ("left-margin", &BVAR (current_buffer
, left_margin
),
5478 make_number (LISP_INT_TAG
),
5479 doc
: /* Column for the default `indent-line-function' to indent to.
5480 Linefeed indents to this column in Fundamental mode. */);
5482 DEFVAR_PER_BUFFER ("tab-width", &BVAR (current_buffer
, tab_width
),
5483 make_number (LISP_INT_TAG
),
5484 doc
: /* Distance between tab stops (for display of tab characters), in columns.
5485 This should be an integer greater than zero. */);
5487 DEFVAR_PER_BUFFER ("ctl-arrow", &BVAR (current_buffer
, ctl_arrow
), Qnil
,
5488 doc
: /* Non-nil means display control chars with uparrow.
5489 A value of nil means use backslash and octal digits.
5490 This variable does not apply to characters whose display is specified
5491 in the current display table (if there is one). */);
5493 DEFVAR_PER_BUFFER ("enable-multibyte-characters",
5494 &BVAR (current_buffer
, enable_multibyte_characters
),
5496 doc
: /* Non-nil means the buffer contents are regarded as multi-byte characters.
5497 Otherwise they are regarded as unibyte. This affects the display,
5498 file I/O and the behavior of various editing commands.
5500 This variable is buffer-local but you cannot set it directly;
5501 use the function `set-buffer-multibyte' to change a buffer's representation.
5502 See also Info node `(elisp)Text Representations'. */);
5503 XSYMBOL (intern_c_string ("enable-multibyte-characters"))->constant
= 1;
5505 DEFVAR_PER_BUFFER ("buffer-file-coding-system",
5506 &BVAR (current_buffer
, buffer_file_coding_system
), Qnil
,
5507 doc
: /* Coding system to be used for encoding the buffer contents on saving.
5508 This variable applies to saving the buffer, and also to `write-region'
5509 and other functions that use `write-region'.
5510 It does not apply to sending output to subprocesses, however.
5512 If this is nil, the buffer is saved without any code conversion
5513 unless some coding system is specified in `file-coding-system-alist'
5514 for the buffer file.
5516 If the text to be saved cannot be encoded as specified by this variable,
5517 an alternative encoding is selected by `select-safe-coding-system', which see.
5519 The variable `coding-system-for-write', if non-nil, overrides this variable.
5521 This variable is never applied to a way of decoding a file while reading it. */);
5523 DEFVAR_PER_BUFFER ("bidi-display-reordering",
5524 &BVAR (current_buffer
, bidi_display_reordering
), Qnil
,
5525 doc
: /* Non-nil means reorder bidirectional text for display in the visual order. */);
5527 DEFVAR_PER_BUFFER ("bidi-paragraph-direction",
5528 &BVAR (current_buffer
, bidi_paragraph_direction
), Qnil
,
5529 doc
: /* If non-nil, forces directionality of text paragraphs in the buffer.
5531 If this is nil (the default), the direction of each paragraph is
5532 determined by the first strong directional character of its text.
5533 The values of `right-to-left' and `left-to-right' override that.
5534 Any other value is treated as nil.
5536 This variable has no effect unless the buffer's value of
5537 \`bidi-display-reordering' is non-nil. */);
5539 DEFVAR_PER_BUFFER ("truncate-lines", &BVAR (current_buffer
, truncate_lines
), Qnil
,
5540 doc
: /* Non-nil means do not display continuation lines.
5541 Instead, give each line of text just one screen line.
5543 Note that this is overridden by the variable
5544 `truncate-partial-width-windows' if that variable is non-nil
5545 and this buffer is not full-frame width.
5547 Minibuffers set this variable to nil. */);
5549 DEFVAR_PER_BUFFER ("word-wrap", &BVAR (current_buffer
, word_wrap
), Qnil
,
5550 doc
: /* Non-nil means to use word-wrapping for continuation lines.
5551 When word-wrapping is on, continuation lines are wrapped at the space
5552 or tab character nearest to the right window edge.
5553 If nil, continuation lines are wrapped at the right screen edge.
5555 This variable has no effect if long lines are truncated (see
5556 `truncate-lines' and `truncate-partial-width-windows'). If you use
5557 word-wrapping, you might want to reduce the value of
5558 `truncate-partial-width-windows', since wrapping can make text readable
5559 in narrower windows.
5561 Instead of setting this variable directly, most users should use
5562 Visual Line mode . Visual Line mode, when enabled, sets `word-wrap'
5563 to t, and additionally redefines simple editing commands to act on
5564 visual lines rather than logical lines. See the documentation of
5565 `visual-line-mode'. */);
5567 DEFVAR_PER_BUFFER ("default-directory", &BVAR (current_buffer
, directory
),
5568 make_number (Lisp_String
),
5569 doc
: /* Name of default directory of current buffer. Should end with slash.
5570 To interactively change the default directory, use command `cd'. */);
5572 DEFVAR_PER_BUFFER ("auto-fill-function", &BVAR (current_buffer
, auto_fill_function
),
5574 doc
: /* Function called (if non-nil) to perform auto-fill.
5575 It is called after self-inserting any character specified in
5576 the `auto-fill-chars' table.
5577 NOTE: This variable is not a hook;
5578 its value may not be a list of functions. */);
5580 DEFVAR_PER_BUFFER ("buffer-file-name", &BVAR (current_buffer
, filename
),
5581 make_number (Lisp_String
),
5582 doc
: /* Name of file visited in current buffer, or nil if not visiting a file. */);
5584 DEFVAR_PER_BUFFER ("buffer-file-truename", &BVAR (current_buffer
, file_truename
),
5585 make_number (Lisp_String
),
5586 doc
: /* Abbreviated truename of file visited in current buffer, or nil if none.
5587 The truename of a file is calculated by `file-truename'
5588 and then abbreviated with `abbreviate-file-name'. */);
5590 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
5591 &BVAR (current_buffer
, auto_save_file_name
),
5592 make_number (Lisp_String
),
5593 doc
: /* Name of file for auto-saving current buffer.
5594 If it is nil, that means don't auto-save this buffer. */);
5596 DEFVAR_PER_BUFFER ("buffer-read-only", &BVAR (current_buffer
, read_only
), Qnil
,
5597 doc
: /* Non-nil if this buffer is read-only. */);
5599 DEFVAR_PER_BUFFER ("buffer-backed-up", &BVAR (current_buffer
, backed_up
), Qnil
,
5600 doc
: /* Non-nil if this buffer's file has been backed up.
5601 Backing up is done before the first time the file is saved. */);
5603 DEFVAR_PER_BUFFER ("buffer-saved-size", &BVAR (current_buffer
, save_length
),
5604 make_number (LISP_INT_TAG
),
5605 doc
: /* Length of current buffer when last read in, saved or auto-saved.
5607 -1 means auto-saving turned off until next real save.
5609 If you set this to -2, that means don't turn off auto-saving in this buffer
5610 if its text size shrinks. If you use `buffer-swap-text' on a buffer,
5611 you probably should set this to -2 in that buffer. */);
5613 DEFVAR_PER_BUFFER ("selective-display", &BVAR (current_buffer
, selective_display
),
5615 doc
: /* Non-nil enables selective display.
5616 An integer N as value means display only lines
5617 that start with less than N columns of space.
5618 A value of t means that the character ^M makes itself and
5619 all the rest of the line invisible; also, when saving the buffer
5620 in a file, save the ^M as a newline. */);
5622 DEFVAR_PER_BUFFER ("selective-display-ellipses",
5623 &BVAR (current_buffer
, selective_display_ellipses
),
5625 doc
: /* Non-nil means display ... on previous line when a line is invisible. */);
5627 DEFVAR_PER_BUFFER ("overwrite-mode", &BVAR (current_buffer
, overwrite_mode
), Qnil
,
5628 doc
: /* Non-nil if self-insertion should replace existing text.
5629 The value should be one of `overwrite-mode-textual',
5630 `overwrite-mode-binary', or nil.
5631 If it is `overwrite-mode-textual', self-insertion still
5632 inserts at the end of a line, and inserts when point is before a tab,
5633 until the tab is filled in.
5634 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too. */);
5636 DEFVAR_PER_BUFFER ("buffer-display-table", &BVAR (current_buffer
, display_table
),
5638 doc
: /* Display table that controls display of the contents of current buffer.
5640 If this variable is nil, the value of `standard-display-table' is used.
5641 Each window can have its own, overriding display table, see
5642 `set-window-display-table' and `window-display-table'.
5644 The display table is a char-table created with `make-display-table'.
5645 A char-table is an array indexed by character codes. Normal array
5646 primitives `aref' and `aset' can be used to access elements of a char-table.
5648 Each of the char-table elements control how to display the corresponding
5649 text character: the element at index C in the table says how to display
5650 the character whose code is C. Each element should be a vector of
5651 characters or nil. The value nil means display the character in the
5652 default fashion; otherwise, the characters from the vector are delivered
5653 to the screen instead of the original character.
5655 For example, (aset buffer-display-table ?X [?Y]) tells Emacs
5656 to display a capital Y instead of each X character.
5658 In addition, a char-table has six extra slots to control the display of:
5660 the end of a truncated screen line (extra-slot 0, a single character);
5661 the end of a continued line (extra-slot 1, a single character);
5662 the escape character used to display character codes in octal
5663 (extra-slot 2, a single character);
5664 the character used as an arrow for control characters (extra-slot 3,
5665 a single character);
5666 the decoration indicating the presence of invisible lines (extra-slot 4,
5667 a vector of characters);
5668 the character used to draw the border between side-by-side windows
5669 (extra-slot 5, a single character).
5671 See also the functions `display-table-slot' and `set-display-table-slot'. */);
5673 DEFVAR_PER_BUFFER ("left-margin-width", &BVAR (current_buffer
, left_margin_cols
),
5675 doc
: /* Width of left marginal area for display of a buffer.
5676 A value of nil means no marginal area. */);
5678 DEFVAR_PER_BUFFER ("right-margin-width", &BVAR (current_buffer
, right_margin_cols
),
5680 doc
: /* Width of right marginal area for display of a buffer.
5681 A value of nil means no marginal area. */);
5683 DEFVAR_PER_BUFFER ("left-fringe-width", &BVAR (current_buffer
, left_fringe_width
),
5685 doc
: /* Width of this buffer's left fringe (in pixels).
5686 A value of 0 means no left fringe is shown in this buffer's window.
5687 A value of nil means to use the left fringe width from the window's frame. */);
5689 DEFVAR_PER_BUFFER ("right-fringe-width", &BVAR (current_buffer
, right_fringe_width
),
5691 doc
: /* Width of this buffer's right fringe (in pixels).
5692 A value of 0 means no right fringe is shown in this buffer's window.
5693 A value of nil means to use the right fringe width from the window's frame. */);
5695 DEFVAR_PER_BUFFER ("fringes-outside-margins", &BVAR (current_buffer
, fringes_outside_margins
),
5697 doc
: /* Non-nil means to display fringes outside display margins.
5698 A value of nil means to display fringes between margins and buffer text. */);
5700 DEFVAR_PER_BUFFER ("scroll-bar-width", &BVAR (current_buffer
, scroll_bar_width
),
5702 doc
: /* Width of this buffer's scroll bars in pixels.
5703 A value of nil means to use the scroll bar width from the window's frame. */);
5705 DEFVAR_PER_BUFFER ("vertical-scroll-bar", &BVAR (current_buffer
, vertical_scroll_bar_type
),
5707 doc
: /* Position of this buffer's vertical scroll bar.
5708 The value takes effect whenever you tell a window to display this buffer;
5709 for instance, with `set-window-buffer' or when `display-buffer' displays it.
5711 A value of `left' or `right' means put the vertical scroll bar at that side
5712 of the window; a value of nil means don't show any vertical scroll bars.
5713 A value of t (the default) means do whatever the window's frame specifies. */);
5715 DEFVAR_PER_BUFFER ("indicate-empty-lines",
5716 &BVAR (current_buffer
, indicate_empty_lines
), Qnil
,
5717 doc
: /* Visually indicate empty lines after the buffer end.
5718 If non-nil, a bitmap is displayed in the left fringe of a window on
5719 window-systems. */);
5721 DEFVAR_PER_BUFFER ("indicate-buffer-boundaries",
5722 &BVAR (current_buffer
, indicate_buffer_boundaries
), Qnil
,
5723 doc
: /* Visually indicate buffer boundaries and scrolling.
5724 If non-nil, the first and last line of the buffer are marked in the fringe
5725 of a window on window-systems with angle bitmaps, or if the window can be
5726 scrolled, the top and bottom line of the window are marked with up and down
5729 If value is a symbol `left' or `right', both angle and arrow bitmaps
5730 are displayed in the left or right fringe, resp. Any other value
5731 that doesn't look like an alist means display the angle bitmaps in
5732 the left fringe but no arrows.
5734 You can exercise more precise control by using an alist as the
5735 value. Each alist element (INDICATOR . POSITION) specifies
5736 where to show one of the indicators. INDICATOR is one of `top',
5737 `bottom', `up', `down', or t, which specifies the default position,
5738 and POSITION is one of `left', `right', or nil, meaning do not show
5741 For example, ((top . left) (t . right)) places the top angle bitmap in
5742 left fringe, the bottom angle bitmap in right fringe, and both arrow
5743 bitmaps in right fringe. To show just the angle bitmaps in the left
5744 fringe, but no arrow bitmaps, use ((top . left) (bottom . left)). */);
5746 DEFVAR_PER_BUFFER ("fringe-indicator-alist",
5747 &BVAR (current_buffer
, fringe_indicator_alist
), Qnil
,
5748 doc
: /* Mapping from logical to physical fringe indicator bitmaps.
5749 The value is an alist where each element (INDICATOR . BITMAPS)
5750 specifies the fringe bitmaps used to display a specific logical
5753 INDICATOR specifies the logical indicator type which is one of the
5754 following symbols: `truncation' , `continuation', `overlay-arrow',
5755 `top', `bottom', `top-bottom', `up', `down', empty-line', or `unknown'.
5757 BITMAPS is a list of symbols (LEFT RIGHT [LEFT1 RIGHT1]) which specifies
5758 the actual bitmap shown in the left or right fringe for the logical
5759 indicator. LEFT and RIGHT are the bitmaps shown in the left and/or
5760 right fringe for the specific indicator. The LEFT1 or RIGHT1 bitmaps
5761 are used only for the `bottom' and `top-bottom' indicators when the
5762 last (only) line has no final newline. BITMAPS may also be a single
5763 symbol which is used in both left and right fringes. */);
5765 DEFVAR_PER_BUFFER ("fringe-cursor-alist",
5766 &BVAR (current_buffer
, fringe_cursor_alist
), Qnil
,
5767 doc
: /* Mapping from logical to physical fringe cursor bitmaps.
5768 The value is an alist where each element (CURSOR . BITMAP)
5769 specifies the fringe bitmaps used to display a specific logical
5770 cursor type in the fringe.
5772 CURSOR specifies the logical cursor type which is one of the following
5773 symbols: `box' , `hollow', `bar', `hbar', or `hollow-small'. The last
5774 one is used to show a hollow cursor on narrow lines display lines
5775 where the normal hollow cursor will not fit.
5777 BITMAP is the corresponding fringe bitmap shown for the logical
5780 DEFVAR_PER_BUFFER ("scroll-up-aggressively",
5781 &BVAR (current_buffer
, scroll_up_aggressively
), Qnil
,
5782 doc
: /* How far to scroll windows upward.
5783 If you move point off the bottom, the window scrolls automatically.
5784 This variable controls how far it scrolls. The value nil, the default,
5785 means scroll to center point. A fraction means scroll to put point
5786 that fraction of the window's height from the bottom of the window.
5787 When the value is 0.0, point goes at the bottom line, which in the
5788 simple case that you moved off with C-f means scrolling just one line.
5789 1.0 means point goes at the top, so that in that simple case, the
5790 window scrolls by a full window height. Meaningful values are
5791 between 0.0 and 1.0, inclusive. */);
5793 DEFVAR_PER_BUFFER ("scroll-down-aggressively",
5794 &BVAR (current_buffer
, scroll_down_aggressively
), Qnil
,
5795 doc
: /* How far to scroll windows downward.
5796 If you move point off the top, the window scrolls automatically.
5797 This variable controls how far it scrolls. The value nil, the default,
5798 means scroll to center point. A fraction means scroll to put point
5799 that fraction of the window's height from the top of the window.
5800 When the value is 0.0, point goes at the top line, which in the
5801 simple case that you moved off with C-b means scrolling just one line.
5802 1.0 means point goes at the bottom, so that in that simple case, the
5803 window scrolls by a full window height. Meaningful values are
5804 between 0.0 and 1.0, inclusive. */);
5806 /*DEFVAR_LISP ("debug-check-symbol", &Vcheck_symbol,
5810 DEFVAR_LISP ("before-change-functions", Vbefore_change_functions
,
5811 doc
: /* List of functions to call before each text change.
5812 Two arguments are passed to each function: the positions of
5813 the beginning and end of the range of old text to be changed.
5814 \(For an insertion, the beginning and end are at the same place.)
5815 No information is given about the length of the text after the change.
5817 Buffer changes made while executing the `before-change-functions'
5818 don't call any before-change or after-change functions.
5819 That's because `inhibit-modification-hooks' is temporarily set non-nil.
5821 If an unhandled error happens in running these functions,
5822 the variable's value remains nil. That prevents the error
5823 from happening repeatedly and making Emacs nonfunctional. */);
5824 Vbefore_change_functions
= Qnil
;
5826 DEFVAR_LISP ("after-change-functions", Vafter_change_functions
,
5827 doc
: /* List of functions to call after each text change.
5828 Three arguments are passed to each function: the positions of
5829 the beginning and end of the range of changed text,
5830 and the length in bytes of the pre-change text replaced by that range.
5831 \(For an insertion, the pre-change length is zero;
5832 for a deletion, that length is the number of bytes deleted,
5833 and the post-change beginning and end are at the same place.)
5835 Buffer changes made while executing the `after-change-functions'
5836 don't call any before-change or after-change functions.
5837 That's because `inhibit-modification-hooks' is temporarily set non-nil.
5839 If an unhandled error happens in running these functions,
5840 the variable's value remains nil. That prevents the error
5841 from happening repeatedly and making Emacs nonfunctional. */);
5842 Vafter_change_functions
= Qnil
;
5844 DEFVAR_LISP ("first-change-hook", Vfirst_change_hook
,
5845 doc
: /* A list of functions to call before changing a buffer which is unmodified.
5846 The functions are run using the `run-hooks' function. */);
5847 Vfirst_change_hook
= Qnil
;
5849 DEFVAR_PER_BUFFER ("buffer-undo-list", &BVAR (current_buffer
, undo_list
), Qnil
,
5850 doc
: /* List of undo entries in current buffer.
5851 Recent changes come first; older changes follow newer.
5853 An entry (BEG . END) represents an insertion which begins at
5854 position BEG and ends at position END.
5856 An entry (TEXT . POSITION) represents the deletion of the string TEXT
5857 from (abs POSITION). If POSITION is positive, point was at the front
5858 of the text being deleted; if negative, point was at the end.
5860 An entry (t HIGH LOW USEC PSEC) indicates that the buffer was previously
5861 unmodified; (HIGH LOW USEC PSEC) is in the same style as (current-time)
5862 and is the visited file's modification time, as of that time. If the
5863 modification time of the most recent save is different, this entry is
5866 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
5867 was modified between BEG and END. PROPERTY is the property name,
5868 and VALUE is the old value.
5870 An entry (apply FUN-NAME . ARGS) means undo the change with
5871 \(apply FUN-NAME ARGS).
5873 An entry (apply DELTA BEG END FUN-NAME . ARGS) supports selective undo
5874 in the active region. BEG and END is the range affected by this entry
5875 and DELTA is the number of bytes added or deleted in that range by
5878 An entry (MARKER . DISTANCE) indicates that the marker MARKER
5879 was adjusted in position by the offset DISTANCE (an integer).
5881 An entry of the form POSITION indicates that point was at the buffer
5882 location given by the integer. Undoing an entry of this form places
5885 Entries with value `nil' mark undo boundaries. The undo command treats
5886 the changes between two undo boundaries as a single step to be undone.
5888 If the value of the variable is t, undo information is not recorded. */);
5890 DEFVAR_PER_BUFFER ("mark-active", &BVAR (current_buffer
, mark_active
), Qnil
,
5891 doc
: /* Non-nil means the mark and region are currently active in this buffer. */);
5893 DEFVAR_PER_BUFFER ("cache-long-line-scans", &BVAR (current_buffer
, cache_long_line_scans
), Qnil
,
5894 doc
: /* Non-nil means that Emacs should use caches to handle long lines more quickly.
5896 Normally, the line-motion functions work by scanning the buffer for
5897 newlines. Columnar operations (like `move-to-column' and
5898 `compute-motion') also work by scanning the buffer, summing character
5899 widths as they go. This works well for ordinary text, but if the
5900 buffer's lines are very long (say, more than 500 characters), these
5901 motion functions will take longer to execute. Emacs may also take
5902 longer to update the display.
5904 If `cache-long-line-scans' is non-nil, these motion functions cache the
5905 results of their scans, and consult the cache to avoid rescanning
5906 regions of the buffer until the text is modified. The caches are most
5907 beneficial when they prevent the most searching---that is, when the
5908 buffer contains long lines and large regions of characters with the
5909 same, fixed screen width.
5911 When `cache-long-line-scans' is non-nil, processing short lines will
5912 become slightly slower (because of the overhead of consulting the
5913 cache), and the caches will use memory roughly proportional to the
5914 number of newlines and characters whose screen width varies.
5916 The caches require no explicit maintenance; their accuracy is
5917 maintained internally by the Emacs primitives. Enabling or disabling
5918 the cache should not affect the behavior of any of the motion
5919 functions; it should only affect their performance. */);
5921 DEFVAR_PER_BUFFER ("point-before-scroll", &BVAR (current_buffer
, point_before_scroll
), Qnil
,
5922 doc
: /* Value of point before the last series of scroll operations, or nil. */);
5924 DEFVAR_PER_BUFFER ("buffer-file-format", &BVAR (current_buffer
, file_format
), Qnil
,
5925 doc
: /* List of formats to use when saving this buffer.
5926 Formats are defined by `format-alist'. This variable is
5927 set when a file is visited. */);
5929 DEFVAR_PER_BUFFER ("buffer-auto-save-file-format",
5930 &BVAR (current_buffer
, auto_save_file_format
), Qnil
,
5931 doc
: /* Format in which to write auto-save files.
5932 Should be a list of symbols naming formats that are defined in `format-alist'.
5933 If it is t, which is the default, auto-save files are written in the
5934 same format as a regular save would use. */);
5936 DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
5937 &BVAR (current_buffer
, invisibility_spec
), Qnil
,
5938 doc
: /* Invisibility spec of this buffer.
5939 The default is t, which means that text is invisible
5940 if it has a non-nil `invisible' property.
5941 If the value is a list, a text character is invisible if its `invisible'
5942 property is an element in that list (or is a list with members in common).
5943 If an element is a cons cell of the form (PROP . ELLIPSIS),
5944 then characters with property value PROP are invisible,
5945 and they have an ellipsis as well if ELLIPSIS is non-nil. */);
5947 DEFVAR_PER_BUFFER ("buffer-display-count",
5948 &BVAR (current_buffer
, display_count
), Qnil
,
5949 doc
: /* A number incremented each time this buffer is displayed in a window.
5950 The function `set-window-buffer' increments it. */);
5952 DEFVAR_PER_BUFFER ("buffer-display-time",
5953 &BVAR (current_buffer
, display_time
), Qnil
,
5954 doc
: /* Time stamp updated each time this buffer is displayed in a window.
5955 The function `set-window-buffer' updates this variable
5956 to the value obtained by calling `current-time'.
5957 If the buffer has never been shown in a window, the value is nil. */);
5959 DEFVAR_LISP ("transient-mark-mode", Vtransient_mark_mode
,
5960 doc
: /* Non-nil if Transient Mark mode is enabled.
5961 See the command `transient-mark-mode' for a description of this minor mode.
5963 Non-nil also enables highlighting of the region whenever the mark is active.
5964 The variable `highlight-nonselected-windows' controls whether to highlight
5965 all windows or just the selected window.
5967 Lisp programs may give this variable certain special values:
5969 - A value of `lambda' enables Transient Mark mode temporarily.
5970 It is disabled again after any subsequent action that would
5971 normally deactivate the mark (e.g. buffer modification).
5973 - A value of (only . OLDVAL) enables Transient Mark mode
5974 temporarily. After any subsequent point motion command that is
5975 not shift-translated, or any other action that would normally
5976 deactivate the mark (e.g. buffer modification), the value of
5977 `transient-mark-mode' is set to OLDVAL. */);
5978 Vtransient_mark_mode
= Qnil
;
5980 DEFVAR_LISP ("inhibit-read-only", Vinhibit_read_only
,
5981 doc
: /* Non-nil means disregard read-only status of buffers or characters.
5982 If the value is t, disregard `buffer-read-only' and all `read-only'
5983 text properties. If the value is a list, disregard `buffer-read-only'
5984 and disregard a `read-only' text property if the property value
5985 is a member of the list. */);
5986 Vinhibit_read_only
= Qnil
;
5988 DEFVAR_PER_BUFFER ("cursor-type", &BVAR (current_buffer
, cursor_type
), Qnil
,
5989 doc
: /* Cursor to use when this buffer is in the selected window.
5990 Values are interpreted as follows:
5992 t use the cursor specified for the frame
5993 nil don't display a cursor
5994 box display a filled box cursor
5995 hollow display a hollow box cursor
5996 bar display a vertical bar cursor with default width
5997 (bar . WIDTH) display a vertical bar cursor with width WIDTH
5998 hbar display a horizontal bar cursor with default height
5999 (hbar . HEIGHT) display a horizontal bar cursor with height HEIGHT
6000 ANYTHING ELSE display a hollow box cursor
6002 When the buffer is displayed in a non-selected window, the
6003 cursor's appearance is instead controlled by the variable
6004 `cursor-in-non-selected-windows'. */);
6006 DEFVAR_PER_BUFFER ("line-spacing",
6007 &BVAR (current_buffer
, extra_line_spacing
), Qnil
,
6008 doc
: /* Additional space to put between lines when displaying a buffer.
6009 The space is measured in pixels, and put below lines on graphic displays,
6010 see `display-graphic-p'.
6011 If value is a floating point number, it specifies the spacing relative
6012 to the default frame line height. A value of nil means add no extra space. */);
6014 DEFVAR_PER_BUFFER ("cursor-in-non-selected-windows",
6015 &BVAR (current_buffer
, cursor_in_non_selected_windows
), Qnil
,
6016 doc
: /* Non-nil means show a cursor in non-selected windows.
6017 If nil, only shows a cursor in the selected window.
6018 If t, displays a cursor related to the usual cursor type
6019 \(a solid box becomes hollow, a bar becomes a narrower bar).
6020 You can also specify the cursor type as in the `cursor-type' variable.
6021 Use Custom to set this variable and update the display." */);
6023 DEFVAR_LISP ("kill-buffer-query-functions", Vkill_buffer_query_functions
,
6024 doc
: /* List of functions called with no args to query before killing a buffer.
6025 The buffer being killed will be current while the functions are running.
6027 If any of them returns nil, the buffer is not killed. Functions run by
6028 this hook are supposed to not change the current buffer. */);
6029 Vkill_buffer_query_functions
= Qnil
;
6031 DEFVAR_LISP ("change-major-mode-hook", Vchange_major_mode_hook
,
6032 doc
: /* Normal hook run before changing the major mode of a buffer.
6033 The function `kill-all-local-variables' runs this before doing anything else. */);
6034 Vchange_major_mode_hook
= Qnil
;
6035 DEFSYM (Qchange_major_mode_hook
, "change-major-mode-hook");
6037 DEFVAR_LISP ("buffer-list-update-hook", Vbuffer_list_update_hook
,
6038 doc
: /* Hook run when the buffer list changes.
6039 Functions running this hook are `get-buffer-create',
6040 `make-indirect-buffer', `rename-buffer', `kill-buffer',
6041 and `bury-buffer-internal'. */);
6042 Vbuffer_list_update_hook
= Qnil
;
6043 DEFSYM (Qbuffer_list_update_hook
, "buffer-list-update-hook");
6045 defsubr (&Sbuffer_live_p
);
6046 defsubr (&Sbuffer_list
);
6047 defsubr (&Sget_buffer
);
6048 defsubr (&Sget_file_buffer
);
6049 defsubr (&Sget_buffer_create
);
6050 defsubr (&Smake_indirect_buffer
);
6051 defsubr (&Sgenerate_new_buffer_name
);
6052 defsubr (&Sbuffer_name
);
6053 defsubr (&Sbuffer_file_name
);
6054 defsubr (&Sbuffer_base_buffer
);
6055 defsubr (&Sbuffer_local_value
);
6056 defsubr (&Sbuffer_local_variables
);
6057 defsubr (&Sbuffer_modified_p
);
6058 defsubr (&Sset_buffer_modified_p
);
6059 defsubr (&Sbuffer_modified_tick
);
6060 defsubr (&Sbuffer_chars_modified_tick
);
6061 defsubr (&Srename_buffer
);
6062 defsubr (&Sother_buffer
);
6063 defsubr (&Sbuffer_enable_undo
);
6064 defsubr (&Skill_buffer
);
6065 defsubr (&Sbury_buffer_internal
);
6066 defsubr (&Sset_buffer_major_mode
);
6067 defsubr (&Scurrent_buffer
);
6068 defsubr (&Sset_buffer
);
6069 defsubr (&Sbarf_if_buffer_read_only
);
6070 defsubr (&Serase_buffer
);
6071 defsubr (&Sbuffer_swap_text
);
6072 defsubr (&Sset_buffer_multibyte
);
6073 defsubr (&Skill_all_local_variables
);
6075 defsubr (&Soverlayp
);
6076 defsubr (&Smake_overlay
);
6077 defsubr (&Sdelete_overlay
);
6078 defsubr (&Smove_overlay
);
6079 defsubr (&Soverlay_start
);
6080 defsubr (&Soverlay_end
);
6081 defsubr (&Soverlay_buffer
);
6082 defsubr (&Soverlay_properties
);
6083 defsubr (&Soverlays_at
);
6084 defsubr (&Soverlays_in
);
6085 defsubr (&Snext_overlay_change
);
6086 defsubr (&Sprevious_overlay_change
);
6087 defsubr (&Soverlay_recenter
);
6088 defsubr (&Soverlay_lists
);
6089 defsubr (&Soverlay_get
);
6090 defsubr (&Soverlay_put
);
6091 defsubr (&Srestore_buffer_modified_p
);
6095 keys_of_buffer (void)
6097 initial_define_key (control_x_map
, 'b', "switch-to-buffer");
6098 initial_define_key (control_x_map
, 'k', "kill-buffer");
6100 /* This must not be in syms_of_buffer, because Qdisabled is not
6101 initialized when that function gets called. */
6102 Fput (intern_c_string ("erase-buffer"), Qdisabled
, Qt
);