1 /* Buffer manipulation primitives for GNU Emacs.
3 Copyright (C) 1985-1989, 1993-1995, 1997-2011 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>
31 #include "intervals.h"
35 #include "character.h"
36 #include "region-cache.h"
38 #include "blockinput.h"
43 struct buffer
*current_buffer
; /* the current buffer */
45 /* First buffer in chain of all buffers (in reverse order of creation).
46 Threaded through ->header.next.buffer. */
48 struct buffer
*all_buffers
;
50 /* This structure holds the default values of the buffer-local variables
51 defined with DEFVAR_PER_BUFFER, that have special slots in each buffer.
52 The default value occupies the same slot in this structure
53 as an individual buffer's value occupies in that buffer.
54 Setting the default value also goes through the alist of buffers
55 and stores into each buffer that does not say it has a local value. */
57 DECL_ALIGN (struct buffer
, buffer_defaults
);
59 /* A Lisp_Object pointer to the above, used for staticpro */
61 static Lisp_Object Vbuffer_defaults
;
63 /* This structure marks which slots in a buffer have corresponding
64 default values in buffer_defaults.
65 Each such slot has a nonzero value in this structure.
66 The value has only one nonzero bit.
68 When a buffer has its own local value for a slot,
69 the entry for that slot (found in the same slot in this structure)
70 is turned on in the buffer's local_flags array.
72 If a slot in this structure is -1, then even though there may
73 be a DEFVAR_PER_BUFFER for the slot, there is no default value for it;
74 and the corresponding slot in buffer_defaults is not used.
76 If a slot in this structure corresponding to a DEFVAR_PER_BUFFER is
77 zero, that is a bug */
79 struct buffer buffer_local_flags
;
81 /* This structure holds the names of symbols whose values may be
82 buffer-local. It is indexed and accessed in the same way as the above. */
84 DECL_ALIGN (struct buffer
, buffer_local_symbols
);
86 /* A Lisp_Object pointer to the above, used for staticpro */
87 static Lisp_Object Vbuffer_local_symbols
;
89 /* Return the symbol of the per-buffer variable at offset OFFSET in
90 the buffer structure. */
92 #define PER_BUFFER_SYMBOL(OFFSET) \
93 (*(Lisp_Object *)((OFFSET) + (char *) &buffer_local_symbols))
95 /* Flags indicating which built-in buffer-local variables
96 are permanent locals. */
97 static char buffer_permanent_local_flags
[MAX_PER_BUFFER_VARS
];
99 /* Number of per-buffer variables used. */
101 int last_per_buffer_idx
;
103 static Lisp_Object
Fset_buffer_major_mode (Lisp_Object
);
104 static Lisp_Object
Fdelete_overlay (Lisp_Object
);
105 static void call_overlay_mod_hooks (Lisp_Object list
, Lisp_Object overlay
,
106 int after
, Lisp_Object arg1
,
107 Lisp_Object arg2
, Lisp_Object arg3
);
108 static void swap_out_buffer_local_variables (struct buffer
*b
);
109 static void reset_buffer_local_variables (struct buffer
*b
, int permanent_too
);
111 /* Alist of all buffer names vs the buffers. */
112 /* This used to be a variable, but is no longer,
113 to prevent lossage due to user rplac'ing this alist or its elements. */
114 Lisp_Object Vbuffer_alist
;
116 static Lisp_Object Qkill_buffer_query_functions
;
118 /* Hook run before changing a major mode. */
119 static Lisp_Object Qchange_major_mode_hook
;
121 Lisp_Object Qfirst_change_hook
;
122 Lisp_Object Qbefore_change_functions
;
123 Lisp_Object Qafter_change_functions
;
124 static Lisp_Object Qucs_set_table_for_input
;
126 static Lisp_Object Qfundamental_mode
, Qmode_class
, Qpermanent_local
;
127 static Lisp_Object Qpermanent_local_hook
;
129 static Lisp_Object Qprotected_field
;
131 static Lisp_Object QSFundamental
; /* A string "Fundamental" */
133 static Lisp_Object Qkill_buffer_hook
;
134 static Lisp_Object Qbuffer_list_update_hook
;
136 static Lisp_Object Qget_file_buffer
;
138 static Lisp_Object Qoverlayp
;
140 Lisp_Object Qpriority
, Qbefore_string
, Qafter_string
;
142 static Lisp_Object Qclone_number
, Qevaporate
;
144 Lisp_Object Qmodification_hooks
;
145 Lisp_Object Qinsert_in_front_hooks
;
146 Lisp_Object Qinsert_behind_hooks
;
148 static void alloc_buffer_text (struct buffer
*, size_t);
149 static void free_buffer_text (struct buffer
*b
);
150 static struct Lisp_Overlay
* copy_overlays (struct buffer
*, struct Lisp_Overlay
*);
151 static void modify_overlay (struct buffer
*, EMACS_INT
, EMACS_INT
);
152 static Lisp_Object
buffer_lisp_local_variables (struct buffer
*);
154 /* For debugging; temporary. See set_buffer_internal. */
155 /* Lisp_Object Qlisp_mode, Vcheck_symbol; */
158 nsberror (Lisp_Object spec
)
161 error ("No buffer named %s", SDATA (spec
));
162 error ("Invalid buffer argument");
165 DEFUN ("buffer-live-p", Fbuffer_live_p
, Sbuffer_live_p
, 1, 1, 0,
166 doc
: /* Return non-nil if OBJECT is a buffer which has not been killed.
167 Value is nil if OBJECT is not a buffer or if it has been killed. */)
170 return ((BUFFERP (object
) && ! NILP (BVAR (XBUFFER (object
), name
)))
174 DEFUN ("buffer-list", Fbuffer_list
, Sbuffer_list
, 0, 1, 0,
175 doc
: /* Return a list of all existing live buffers.
176 If the optional arg FRAME is a frame, we return the buffer list in the
177 proper order for that frame: the buffers show in FRAME come first,
178 followed by the rest of the buffers. */)
182 general
= Fmapcar (Qcdr
, Vbuffer_alist
);
186 Lisp_Object framelist
, prevlist
, tail
;
190 framelist
= Fcopy_sequence (XFRAME (frame
)->buffer_list
);
191 prevlist
= Fnreverse (Fcopy_sequence
192 (XFRAME (frame
)->buried_buffer_list
));
194 /* Remove from GENERAL any buffer that duplicates one in
195 FRAMELIST or PREVLIST. */
199 general
= Fdelq (XCAR (tail
), general
);
205 general
= Fdelq (XCAR (tail
), general
);
212 return Fnconc (3, args
);
218 /* Like Fassoc, but use Fstring_equal to compare
219 (which ignores text properties),
220 and don't ever QUIT. */
223 assoc_ignore_text_properties (register Lisp_Object key
, Lisp_Object list
)
225 register Lisp_Object tail
;
226 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
228 register Lisp_Object elt
, tem
;
230 tem
= Fstring_equal (Fcar (elt
), key
);
237 DEFUN ("get-buffer", Fget_buffer
, Sget_buffer
, 1, 1, 0,
238 doc
: /* Return the buffer named BUFFER-OR-NAME.
239 BUFFER-OR-NAME must be either a string or a buffer. If BUFFER-OR-NAME
240 is a string and there is no buffer with that name, return nil. If
241 BUFFER-OR-NAME is a buffer, return it as given. */)
242 (register Lisp_Object buffer_or_name
)
244 if (BUFFERP (buffer_or_name
))
245 return buffer_or_name
;
246 CHECK_STRING (buffer_or_name
);
248 return Fcdr (assoc_ignore_text_properties (buffer_or_name
, Vbuffer_alist
));
251 DEFUN ("get-file-buffer", Fget_file_buffer
, Sget_file_buffer
, 1, 1, 0,
252 doc
: /* Return the buffer visiting file FILENAME (a string).
253 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
254 If there is no such live buffer, return nil.
255 See also `find-buffer-visiting'. */)
256 (register Lisp_Object filename
)
258 register Lisp_Object tail
, buf
, tem
;
261 CHECK_STRING (filename
);
262 filename
= Fexpand_file_name (filename
, Qnil
);
264 /* If the file name has special constructs in it,
265 call the corresponding file handler. */
266 handler
= Ffind_file_name_handler (filename
, Qget_file_buffer
);
268 return call2 (handler
, Qget_file_buffer
, filename
);
270 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
272 buf
= Fcdr (XCAR (tail
));
273 if (!BUFFERP (buf
)) continue;
274 if (!STRINGP (BVAR (XBUFFER (buf
), filename
))) continue;
275 tem
= Fstring_equal (BVAR (XBUFFER (buf
), filename
), filename
);
283 get_truename_buffer (register Lisp_Object filename
)
285 register Lisp_Object tail
, buf
, tem
;
287 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
289 buf
= Fcdr (XCAR (tail
));
290 if (!BUFFERP (buf
)) continue;
291 if (!STRINGP (BVAR (XBUFFER (buf
), file_truename
))) continue;
292 tem
= Fstring_equal (BVAR (XBUFFER (buf
), file_truename
), filename
);
299 DEFUN ("get-buffer-create", Fget_buffer_create
, Sget_buffer_create
, 1, 1, 0,
300 doc
: /* Return the buffer specified by BUFFER-OR-NAME, creating a new one if needed.
301 If BUFFER-OR-NAME is a string and a live buffer with that name exists,
302 return that buffer. If no such buffer exists, create a new buffer with
303 that name and return it. If BUFFER-OR-NAME starts with a space, the new
304 buffer does not keep undo information.
306 If BUFFER-OR-NAME is a buffer instead of a string, return it as given,
307 even if it is dead. The return value is never nil. */)
308 (register Lisp_Object buffer_or_name
)
310 register Lisp_Object buffer
, name
;
311 register struct buffer
*b
;
313 buffer
= Fget_buffer (buffer_or_name
);
317 if (SCHARS (buffer_or_name
) == 0)
318 error ("Empty string for buffer name is not allowed");
320 b
= allocate_buffer ();
322 /* An ordinary buffer uses its own struct buffer_text. */
323 b
->text
= &b
->own_text
;
326 BUF_GAP_SIZE (b
) = 20;
328 /* We allocate extra 1-byte at the tail and keep it always '\0' for
329 anchoring a search. */
330 alloc_buffer_text (b
, BUF_GAP_SIZE (b
) + 1);
332 if (! BUF_BEG_ADDR (b
))
333 buffer_memory_full (BUF_GAP_SIZE (b
) + 1);
338 b
->pt_byte
= BEG_BYTE
;
339 b
->begv_byte
= BEG_BYTE
;
340 b
->zv_byte
= BEG_BYTE
;
343 BUF_GPT_BYTE (b
) = BEG_BYTE
;
346 BUF_Z_BYTE (b
) = BEG_BYTE
;
348 BUF_CHARS_MODIFF (b
) = 1;
349 BUF_OVERLAY_MODIFF (b
) = 1;
350 BUF_SAVE_MODIFF (b
) = 1;
351 BUF_INTERVALS (b
) = 0;
352 BUF_UNCHANGED_MODIFIED (b
) = 1;
353 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = 1;
354 BUF_END_UNCHANGED (b
) = 0;
355 BUF_BEG_UNCHANGED (b
) = 0;
356 *(BUF_GPT_ADDR (b
)) = *(BUF_Z_ADDR (b
)) = 0; /* Put an anchor '\0'. */
358 b
->newline_cache
= 0;
359 b
->width_run_cache
= 0;
360 BVAR (b
, width_table
) = Qnil
;
361 b
->prevent_redisplay_optimizations_p
= 1;
363 /* Put this on the chain of all buffers including killed ones. */
364 b
->header
.next
.buffer
= all_buffers
;
367 /* An ordinary buffer normally doesn't need markers
368 to handle BEGV and ZV. */
369 BVAR (b
, pt_marker
) = Qnil
;
370 BVAR (b
, begv_marker
) = Qnil
;
371 BVAR (b
, zv_marker
) = Qnil
;
373 name
= Fcopy_sequence (buffer_or_name
);
374 STRING_SET_INTERVALS (name
, NULL_INTERVAL
);
375 BVAR (b
, name
) = name
;
377 BVAR (b
, undo_list
) = (SREF (name
, 0) != ' ') ? Qnil
: Qt
;
380 reset_buffer_local_variables (b
, 1);
382 BVAR (b
, mark
) = Fmake_marker ();
383 BUF_MARKERS (b
) = NULL
;
384 BVAR (b
, name
) = name
;
386 /* Put this in the alist of all live buffers. */
387 XSETBUFFER (buffer
, b
);
388 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buffer
), Qnil
));
389 /* And run buffer-list-update-hook. */
390 if (!NILP (Vrun_hooks
))
391 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
393 /* An error in calling the function here (should someone redefine it)
394 can lead to infinite regress until you run out of stack. rms
395 says that's not worth protecting against. */
396 if (!NILP (Ffboundp (Qucs_set_table_for_input
)))
397 /* buffer is on buffer-alist, so no gcpro. */
398 call1 (Qucs_set_table_for_input
, buffer
);
404 /* Return a list of overlays which is a copy of the overlay list
405 LIST, but for buffer B. */
407 static struct Lisp_Overlay
*
408 copy_overlays (struct buffer
*b
, struct Lisp_Overlay
*list
)
411 struct Lisp_Overlay
*result
= NULL
, *tail
= NULL
;
413 XSETBUFFER (buffer
, b
);
415 for (; list
; list
= list
->next
)
417 Lisp_Object overlay
, start
, end
, old_overlay
;
420 XSETMISC (old_overlay
, list
);
421 charpos
= marker_position (OVERLAY_START (old_overlay
));
422 start
= Fmake_marker ();
423 Fset_marker (start
, make_number (charpos
), buffer
);
424 XMARKER (start
)->insertion_type
425 = XMARKER (OVERLAY_START (old_overlay
))->insertion_type
;
427 charpos
= marker_position (OVERLAY_END (old_overlay
));
428 end
= Fmake_marker ();
429 Fset_marker (end
, make_number (charpos
), buffer
);
430 XMARKER (end
)->insertion_type
431 = XMARKER (OVERLAY_END (old_overlay
))->insertion_type
;
433 overlay
= allocate_misc ();
434 XMISCTYPE (overlay
) = Lisp_Misc_Overlay
;
435 OVERLAY_START (overlay
) = start
;
436 OVERLAY_END (overlay
) = end
;
437 OVERLAY_PLIST (overlay
) = Fcopy_sequence (OVERLAY_PLIST (old_overlay
));
438 XOVERLAY (overlay
)->next
= NULL
;
441 tail
= tail
->next
= XOVERLAY (overlay
);
443 result
= tail
= XOVERLAY (overlay
);
450 /* Clone per-buffer values of buffer FROM.
452 Buffer TO gets the same per-buffer values as FROM, with the
453 following exceptions: (1) TO's name is left untouched, (2) markers
454 are copied and made to refer to TO, and (3) overlay lists are
458 clone_per_buffer_values (struct buffer
*from
, struct buffer
*to
)
460 Lisp_Object to_buffer
;
463 XSETBUFFER (to_buffer
, to
);
465 /* buffer-local Lisp variables start at `undo_list',
466 tho only the ones from `name' on are GC'd normally. */
467 for (offset
= PER_BUFFER_VAR_OFFSET (undo_list
);
469 offset
+= sizeof (Lisp_Object
))
473 /* Don't touch the `name' which should be unique for every buffer. */
474 if (offset
== PER_BUFFER_VAR_OFFSET (name
))
477 obj
= PER_BUFFER_VALUE (from
, offset
);
478 if (MARKERP (obj
) && XMARKER (obj
)->buffer
== from
)
480 struct Lisp_Marker
*m
= XMARKER (obj
);
481 obj
= Fmake_marker ();
482 XMARKER (obj
)->insertion_type
= m
->insertion_type
;
483 set_marker_both (obj
, to_buffer
, m
->charpos
, m
->bytepos
);
486 PER_BUFFER_VALUE (to
, offset
) = obj
;
489 memcpy (to
->local_flags
, from
->local_flags
, sizeof to
->local_flags
);
491 to
->overlays_before
= copy_overlays (to
, from
->overlays_before
);
492 to
->overlays_after
= copy_overlays (to
, from
->overlays_after
);
494 /* Get (a copy of) the alist of Lisp-level local variables of FROM
495 and install that in TO. */
496 BVAR (to
, local_var_alist
) = buffer_lisp_local_variables (from
);
500 /* If buffer B has markers to record PT, BEGV and ZV when it is not
501 current, update these markers. */
504 record_buffer_markers (struct buffer
*b
)
506 if (! NILP (BVAR (b
, pt_marker
)))
510 eassert (!NILP (BVAR (b
, begv_marker
)));
511 eassert (!NILP (BVAR (b
, zv_marker
)));
513 XSETBUFFER (buffer
, b
);
514 set_marker_both (BVAR (b
, pt_marker
), buffer
, b
->pt
, b
->pt_byte
);
515 set_marker_both (BVAR (b
, begv_marker
), buffer
, b
->begv
, b
->begv_byte
);
516 set_marker_both (BVAR (b
, zv_marker
), buffer
, b
->zv
, b
->zv_byte
);
521 /* If buffer B has markers to record PT, BEGV and ZV when it is not
522 current, fetch these values into B->begv etc. */
525 fetch_buffer_markers (struct buffer
*b
)
527 if (! NILP (BVAR (b
, pt_marker
)))
531 eassert (!NILP (BVAR (b
, begv_marker
)));
532 eassert (!NILP (BVAR (b
, zv_marker
)));
534 m
= BVAR (b
, pt_marker
);
535 SET_BUF_PT_BOTH (b
, marker_position (m
), marker_byte_position (m
));
537 m
= BVAR (b
, begv_marker
);
538 SET_BUF_BEGV_BOTH (b
, marker_position (m
), marker_byte_position (m
));
540 m
= BVAR (b
, zv_marker
);
541 SET_BUF_ZV_BOTH (b
, marker_position (m
), marker_byte_position (m
));
546 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer
, Smake_indirect_buffer
,
548 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ",
549 doc
: /* Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.
550 BASE-BUFFER should be a live buffer, or the name of an existing buffer.
551 NAME should be a string which is not the name of an existing buffer.
552 Optional argument CLONE non-nil means preserve BASE-BUFFER's state,
553 such as major and minor modes, in the indirect buffer.
554 CLONE nil means the indirect buffer's state is reset to default values. */)
555 (Lisp_Object base_buffer
, Lisp_Object name
, Lisp_Object clone
)
557 Lisp_Object buf
, tem
;
561 buf
= Fget_buffer (name
);
563 error ("Buffer name `%s' is in use", SDATA (name
));
566 base_buffer
= Fget_buffer (base_buffer
);
567 if (NILP (base_buffer
))
568 error ("No such buffer: `%s'", SDATA (tem
));
569 if (NILP (BVAR (XBUFFER (base_buffer
), name
)))
570 error ("Base buffer has been killed");
572 if (SCHARS (name
) == 0)
573 error ("Empty string for buffer name is not allowed");
575 b
= allocate_buffer ();
577 b
->base_buffer
= (XBUFFER (base_buffer
)->base_buffer
578 ? XBUFFER (base_buffer
)->base_buffer
579 : XBUFFER (base_buffer
));
581 /* Use the base buffer's text object. */
582 b
->text
= b
->base_buffer
->text
;
584 b
->pt
= b
->base_buffer
->pt
;
585 b
->begv
= b
->base_buffer
->begv
;
586 b
->zv
= b
->base_buffer
->zv
;
587 b
->pt_byte
= b
->base_buffer
->pt_byte
;
588 b
->begv_byte
= b
->base_buffer
->begv_byte
;
589 b
->zv_byte
= b
->base_buffer
->zv_byte
;
591 b
->newline_cache
= 0;
592 b
->width_run_cache
= 0;
593 BVAR (b
, width_table
) = Qnil
;
595 /* Put this on the chain of all buffers including killed ones. */
596 b
->header
.next
.buffer
= all_buffers
;
599 name
= Fcopy_sequence (name
);
600 STRING_SET_INTERVALS (name
, NULL_INTERVAL
);
601 BVAR (b
, name
) = name
;
604 reset_buffer_local_variables (b
, 1);
606 /* Put this in the alist of all live buffers. */
608 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buf
), Qnil
));
610 BVAR (b
, mark
) = Fmake_marker ();
611 BVAR (b
, name
) = name
;
613 /* The multibyte status belongs to the base buffer. */
614 BVAR (b
, enable_multibyte_characters
) = BVAR (b
->base_buffer
, enable_multibyte_characters
);
616 /* Make sure the base buffer has markers for its narrowing. */
617 if (NILP (BVAR (b
->base_buffer
, pt_marker
)))
619 eassert (NILP (BVAR (b
->base_buffer
, begv_marker
)));
620 eassert (NILP (BVAR (b
->base_buffer
, zv_marker
)));
622 BVAR (b
->base_buffer
, pt_marker
) = Fmake_marker ();
623 set_marker_both (BVAR (b
->base_buffer
, pt_marker
), base_buffer
,
625 b
->base_buffer
->pt_byte
);
627 BVAR (b
->base_buffer
, begv_marker
) = Fmake_marker ();
628 set_marker_both (BVAR (b
->base_buffer
, begv_marker
), base_buffer
,
629 b
->base_buffer
->begv
,
630 b
->base_buffer
->begv_byte
);
632 BVAR (b
->base_buffer
, zv_marker
) = Fmake_marker ();
633 set_marker_both (BVAR (b
->base_buffer
, zv_marker
), base_buffer
,
635 b
->base_buffer
->zv_byte
);
636 XMARKER (BVAR (b
->base_buffer
, zv_marker
))->insertion_type
= 1;
641 /* Give the indirect buffer markers for its narrowing. */
642 BVAR (b
, pt_marker
) = Fmake_marker ();
643 set_marker_both (BVAR (b
, pt_marker
), buf
, b
->pt
, b
->pt_byte
);
644 BVAR (b
, begv_marker
) = Fmake_marker ();
645 set_marker_both (BVAR (b
, begv_marker
), buf
, b
->begv
, b
->begv_byte
);
646 BVAR (b
, zv_marker
) = Fmake_marker ();
647 set_marker_both (BVAR (b
, zv_marker
), buf
, b
->zv
, b
->zv_byte
);
648 XMARKER (BVAR (b
, zv_marker
))->insertion_type
= 1;
652 struct buffer
*old_b
= current_buffer
;
654 clone_per_buffer_values (b
->base_buffer
, b
);
655 BVAR (b
, filename
) = Qnil
;
656 BVAR (b
, file_truename
) = Qnil
;
657 BVAR (b
, display_count
) = make_number (0);
658 BVAR (b
, backed_up
) = Qnil
;
659 BVAR (b
, auto_save_file_name
) = Qnil
;
660 set_buffer_internal_1 (b
);
661 Fset (intern ("buffer-save-without-query"), Qnil
);
662 Fset (intern ("buffer-file-number"), Qnil
);
663 Fset (intern ("buffer-stale-function"), Qnil
);
664 set_buffer_internal_1 (old_b
);
667 /* Run buffer-list-update-hook. */
668 if (!NILP (Vrun_hooks
))
669 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
675 delete_all_overlays (struct buffer
*b
)
679 /* `reset_buffer' blindly sets the list of overlays to NULL, so we
680 have to empty the list, otherwise we end up with overlays that
681 think they belong to this buffer while the buffer doesn't know about
683 while (b
->overlays_before
)
685 XSETMISC (overlay
, b
->overlays_before
);
686 Fdelete_overlay (overlay
);
688 while (b
->overlays_after
)
690 XSETMISC (overlay
, b
->overlays_after
);
691 Fdelete_overlay (overlay
);
693 eassert (b
->overlays_before
== NULL
);
694 eassert (b
->overlays_after
== NULL
);
697 /* Reinitialize everything about a buffer except its name and contents
699 If called on an already-initialized buffer, the list of overlays
700 should be deleted before calling this function, otherwise we end up
701 with overlays that claim to belong to the buffer but the buffer
702 claims it doesn't belong to it. */
705 reset_buffer (register struct buffer
*b
)
707 BVAR (b
, filename
) = Qnil
;
708 BVAR (b
, file_truename
) = Qnil
;
709 BVAR (b
, directory
) = (current_buffer
) ? BVAR (current_buffer
, directory
) : Qnil
;
711 b
->modtime_size
= -1;
712 XSETFASTINT (BVAR (b
, save_length
), 0);
713 b
->last_window_start
= 1;
714 /* It is more conservative to start out "changed" than "unchanged". */
716 b
->prevent_redisplay_optimizations_p
= 1;
717 BVAR (b
, backed_up
) = Qnil
;
718 BUF_AUTOSAVE_MODIFF (b
) = 0;
719 b
->auto_save_failure_time
= -1;
720 BVAR (b
, auto_save_file_name
) = Qnil
;
721 BVAR (b
, read_only
) = Qnil
;
722 b
->overlays_before
= NULL
;
723 b
->overlays_after
= NULL
;
724 b
->overlay_center
= BEG
;
725 BVAR (b
, mark_active
) = Qnil
;
726 BVAR (b
, point_before_scroll
) = Qnil
;
727 BVAR (b
, file_format
) = Qnil
;
728 BVAR (b
, auto_save_file_format
) = Qt
;
729 BVAR (b
, last_selected_window
) = Qnil
;
730 XSETINT (BVAR (b
, display_count
), 0);
731 BVAR (b
, display_time
) = Qnil
;
732 BVAR (b
, enable_multibyte_characters
) = BVAR (&buffer_defaults
, enable_multibyte_characters
);
733 BVAR (b
, cursor_type
) = BVAR (&buffer_defaults
, cursor_type
);
734 BVAR (b
, extra_line_spacing
) = BVAR (&buffer_defaults
, extra_line_spacing
);
736 b
->display_error_modiff
= 0;
739 /* Reset buffer B's local variables info.
740 Don't use this on a buffer that has already been in use;
741 it does not treat permanent locals consistently.
742 Instead, use Fkill_all_local_variables.
744 If PERMANENT_TOO is 1, then we reset permanent
745 buffer-local variables. If PERMANENT_TOO is 0,
746 we preserve those. */
749 reset_buffer_local_variables (register struct buffer
*b
, int permanent_too
)
754 /* Reset the major mode to Fundamental, together with all the
755 things that depend on the major mode.
756 default-major-mode is handled at a higher level.
757 We ignore it here. */
758 BVAR (b
, major_mode
) = Qfundamental_mode
;
759 BVAR (b
, keymap
) = Qnil
;
760 BVAR (b
, mode_name
) = QSFundamental
;
761 BVAR (b
, minor_modes
) = Qnil
;
763 /* If the standard case table has been altered and invalidated,
764 fix up its insides first. */
765 if (! (CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[0])
766 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[1])
767 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[2])))
768 Fset_standard_case_table (Vascii_downcase_table
);
770 BVAR (b
, downcase_table
) = Vascii_downcase_table
;
771 BVAR (b
, upcase_table
) = XCHAR_TABLE (Vascii_downcase_table
)->extras
[0];
772 BVAR (b
, case_canon_table
) = XCHAR_TABLE (Vascii_downcase_table
)->extras
[1];
773 BVAR (b
, case_eqv_table
) = XCHAR_TABLE (Vascii_downcase_table
)->extras
[2];
774 BVAR (b
, invisibility_spec
) = Qt
;
776 /* Reset all (or most) per-buffer variables to their defaults. */
778 BVAR (b
, local_var_alist
) = Qnil
;
781 Lisp_Object tmp
, prop
, last
= Qnil
;
782 for (tmp
= BVAR (b
, local_var_alist
); CONSP (tmp
); tmp
= XCDR (tmp
))
783 if (!NILP (prop
= Fget (XCAR (XCAR (tmp
)), Qpermanent_local
)))
785 /* If permanent-local, keep it. */
787 if (EQ (prop
, Qpermanent_local_hook
))
789 /* This is a partially permanent hook variable.
790 Preserve only the elements that want to be preserved. */
791 Lisp_Object list
, newlist
;
792 list
= XCDR (XCAR (tmp
));
796 for (newlist
= Qnil
; CONSP (list
); list
= XCDR (list
))
798 Lisp_Object elt
= XCAR (list
);
799 /* Preserve element ELT if it's t,
800 if it is a function with a `permanent-local-hook' property,
801 or if it's not a symbol. */
804 || !NILP (Fget (elt
, Qpermanent_local_hook
)))
805 newlist
= Fcons (elt
, newlist
);
807 XSETCDR (XCAR (tmp
), Fnreverse (newlist
));
810 /* Delete this local variable. */
811 else if (NILP (last
))
812 BVAR (b
, local_var_alist
) = XCDR (tmp
);
814 XSETCDR (last
, XCDR (tmp
));
817 for (i
= 0; i
< last_per_buffer_idx
; ++i
)
818 if (permanent_too
|| buffer_permanent_local_flags
[i
] == 0)
819 SET_PER_BUFFER_VALUE_P (b
, i
, 0);
821 /* For each slot that has a default value,
822 copy that into the slot. */
824 /* buffer-local Lisp variables start at `undo_list',
825 tho only the ones from `name' on are GC'd normally. */
826 for (offset
= PER_BUFFER_VAR_OFFSET (undo_list
);
828 offset
+= sizeof (Lisp_Object
))
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. */)
850 (register Lisp_Object name
, Lisp_Object ignore
)
852 register Lisp_Object gentemp
, tem
;
858 tem
= Fstring_equal (name
, ignore
);
861 tem
= Fget_buffer (name
);
868 sprintf (number
, "<%d>", ++count
);
869 gentemp
= concat2 (name
, build_string (number
));
870 tem
= Fstring_equal (gentemp
, ignore
);
873 tem
= Fget_buffer (gentemp
);
880 DEFUN ("buffer-name", Fbuffer_name
, Sbuffer_name
, 0, 1, 0,
881 doc
: /* Return the name of BUFFER, as a string.
882 BUFFER defaults to the current buffer.
883 Return nil if BUFFER has been killed. */)
884 (register Lisp_Object buffer
)
887 return BVAR (current_buffer
, name
);
888 CHECK_BUFFER (buffer
);
889 return BVAR (XBUFFER (buffer
), name
);
892 DEFUN ("buffer-file-name", Fbuffer_file_name
, Sbuffer_file_name
, 0, 1, 0,
893 doc
: /* Return name of file BUFFER is visiting, or nil if none.
894 No argument or nil as argument means use the current buffer. */)
895 (register Lisp_Object buffer
)
898 return BVAR (current_buffer
, filename
);
899 CHECK_BUFFER (buffer
);
900 return BVAR (XBUFFER (buffer
), filename
);
903 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer
, Sbuffer_base_buffer
,
905 doc
: /* Return the base buffer of indirect buffer BUFFER.
906 If BUFFER is not indirect, return nil.
907 BUFFER defaults to the current buffer. */)
908 (register Lisp_Object buffer
)
911 Lisp_Object base_buffer
;
914 base
= current_buffer
->base_buffer
;
917 CHECK_BUFFER (buffer
);
918 base
= XBUFFER (buffer
)->base_buffer
;
923 XSETBUFFER (base_buffer
, base
);
927 DEFUN ("buffer-local-value", Fbuffer_local_value
,
928 Sbuffer_local_value
, 2, 2, 0,
929 doc
: /* Return the value of VARIABLE in BUFFER.
930 If VARIABLE does not have a buffer-local binding in BUFFER, the value
931 is the default binding of the variable. */)
932 (register Lisp_Object variable
, register Lisp_Object buffer
)
934 register struct buffer
*buf
;
935 register Lisp_Object result
;
936 struct Lisp_Symbol
*sym
;
938 CHECK_SYMBOL (variable
);
939 CHECK_BUFFER (buffer
);
940 buf
= XBUFFER (buffer
);
941 sym
= XSYMBOL (variable
);
944 switch (sym
->redirect
)
946 case SYMBOL_VARALIAS
: sym
= indirect_variable (sym
); goto start
;
947 case SYMBOL_PLAINVAL
: result
= SYMBOL_VAL (sym
); break;
948 case SYMBOL_LOCALIZED
:
949 { /* Look in local_var_alist. */
950 struct Lisp_Buffer_Local_Value
*blv
= SYMBOL_BLV (sym
);
951 XSETSYMBOL (variable
, sym
); /* Update In case of aliasing. */
952 result
= Fassoc (variable
, BVAR (buf
, local_var_alist
));
956 { /* What binding is loaded right now? */
957 Lisp_Object current_alist_element
= blv
->valcell
;
959 /* The value of the currently loaded binding is not
960 stored in it, but rather in the realvalue slot.
961 Store that value into the binding it belongs to
962 in case that is the one we are about to use. */
964 XSETCDR (current_alist_element
,
965 do_symval_forwarding (blv
->fwd
));
967 /* Now get the (perhaps updated) value out of the binding. */
968 result
= XCDR (result
);
971 result
= Fdefault_value (variable
);
974 case SYMBOL_FORWARDED
:
976 union Lisp_Fwd
*fwd
= SYMBOL_FWD (sym
);
977 if (BUFFER_OBJFWDP (fwd
))
978 result
= PER_BUFFER_VALUE (buf
, XBUFFER_OBJFWD (fwd
)->offset
);
980 result
= Fdefault_value (variable
);
986 if (!EQ (result
, Qunbound
))
989 xsignal1 (Qvoid_variable
, variable
);
992 /* Return an alist of the Lisp-level buffer-local bindings of
993 buffer BUF. That is, don't include the variables maintained
994 in special slots in the buffer object. */
997 buffer_lisp_local_variables (struct buffer
*buf
)
999 Lisp_Object result
= Qnil
;
1000 register Lisp_Object tail
;
1001 for (tail
= BVAR (buf
, local_var_alist
); CONSP (tail
); tail
= XCDR (tail
))
1003 Lisp_Object val
, elt
;
1007 /* Reference each variable in the alist in buf.
1008 If inquiring about the current buffer, this gets the current values,
1009 so store them into the alist so the alist is up to date.
1010 If inquiring about some other buffer, this swaps out any values
1011 for that buffer, making the alist up to date automatically. */
1012 val
= find_symbol_value (XCAR (elt
));
1013 /* Use the current buffer value only if buf is the current buffer. */
1014 if (buf
!= current_buffer
)
1017 result
= Fcons (Fcons (XCAR (elt
), val
), result
);
1023 DEFUN ("buffer-local-variables", Fbuffer_local_variables
,
1024 Sbuffer_local_variables
, 0, 1, 0,
1025 doc
: /* Return an alist of variables that are buffer-local in BUFFER.
1026 Most elements look like (SYMBOL . VALUE), describing one variable.
1027 For a symbol that is locally unbound, just the symbol appears in the value.
1028 Note that storing new VALUEs in these elements doesn't change the variables.
1029 No argument or nil as argument means use current buffer as BUFFER. */)
1030 (register Lisp_Object buffer
)
1032 register struct buffer
*buf
;
1033 register Lisp_Object result
;
1036 buf
= current_buffer
;
1039 CHECK_BUFFER (buffer
);
1040 buf
= XBUFFER (buffer
);
1043 result
= buffer_lisp_local_variables (buf
);
1045 /* Add on all the variables stored in special slots. */
1049 /* buffer-local Lisp variables start at `undo_list',
1050 tho only the ones from `name' on are GC'd normally. */
1051 for (offset
= PER_BUFFER_VAR_OFFSET (undo_list
);
1052 offset
< sizeof (struct buffer
);
1053 /* sizeof EMACS_INT == sizeof Lisp_Object */
1054 offset
+= (sizeof (EMACS_INT
)))
1056 idx
= PER_BUFFER_IDX (offset
);
1057 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
1058 && SYMBOLP (PER_BUFFER_SYMBOL (offset
)))
1059 result
= Fcons (Fcons (PER_BUFFER_SYMBOL (offset
),
1060 PER_BUFFER_VALUE (buf
, offset
)),
1068 DEFUN ("buffer-modified-p", Fbuffer_modified_p
, Sbuffer_modified_p
,
1070 doc
: /* Return t if BUFFER was modified since its file was last read or saved.
1071 No argument or nil as argument means use current buffer as BUFFER. */)
1072 (register Lisp_Object buffer
)
1074 register struct buffer
*buf
;
1076 buf
= current_buffer
;
1079 CHECK_BUFFER (buffer
);
1080 buf
= XBUFFER (buffer
);
1083 return BUF_SAVE_MODIFF (buf
) < BUF_MODIFF (buf
) ? Qt
: Qnil
;
1086 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p
, Sset_buffer_modified_p
,
1088 doc
: /* Mark current buffer as modified or unmodified according to FLAG.
1089 A non-nil FLAG means mark the buffer modified. */)
1090 (register Lisp_Object flag
)
1092 register int already
;
1093 register Lisp_Object fn
;
1094 Lisp_Object buffer
, window
;
1096 #ifdef CLASH_DETECTION
1097 /* If buffer becoming modified, lock the file.
1098 If buffer becoming unmodified, unlock the file. */
1100 fn
= BVAR (current_buffer
, file_truename
);
1101 /* Test buffer-file-name so that binding it to nil is effective. */
1102 if (!NILP (fn
) && ! NILP (BVAR (current_buffer
, filename
)))
1104 already
= SAVE_MODIFF
< MODIFF
;
1105 if (!already
&& !NILP (flag
))
1107 else if (already
&& NILP (flag
))
1110 #endif /* CLASH_DETECTION */
1112 /* Here we have a problem. SAVE_MODIFF is used here to encode
1113 buffer-modified-p (as SAVE_MODIFF<MODIFF) as well as
1114 recent-auto-save-p (as SAVE_MODIFF<auto_save_modified). So if we
1115 modify SAVE_MODIFF to affect one, we may affect the other
1117 E.g. if FLAG is nil we need to set SAVE_MODIFF to MODIFF, but
1118 if SAVE_MODIFF<auto_save_modified that means we risk changing
1119 recent-auto-save-p from t to nil.
1120 Vice versa, if FLAG is non-nil and SAVE_MODIFF>=auto_save_modified
1121 we risk changing recent-auto-save-p from nil to t. */
1122 SAVE_MODIFF
= (NILP (flag
)
1123 /* FIXME: This unavoidably sets recent-auto-save-p to nil. */
1125 /* Let's try to preserve recent-auto-save-p. */
1126 : SAVE_MODIFF
< MODIFF
? SAVE_MODIFF
1127 /* If SAVE_MODIFF == auto_save_modified == MODIFF,
1128 we can either decrease SAVE_MODIFF and auto_save_modified
1129 or increase MODIFF. */
1132 /* Set update_mode_lines only if buffer is displayed in some window.
1133 Packages like jit-lock or lazy-lock preserve a buffer's modified
1134 state by recording/restoring the state around blocks of code.
1135 Setting update_mode_lines makes redisplay consider all windows
1136 (on all frames). Stealth fontification of buffers not displayed
1137 would incur additional redisplay costs if we'd set
1138 update_modes_lines unconditionally.
1140 Ideally, I think there should be another mechanism for fontifying
1141 buffers without "modifying" buffers, or redisplay should be
1142 smarter about updating the `*' in mode lines. --gerd */
1143 XSETBUFFER (buffer
, current_buffer
);
1144 window
= Fget_buffer_window (buffer
, Qt
);
1145 if (WINDOWP (window
))
1147 ++update_mode_lines
;
1148 current_buffer
->prevent_redisplay_optimizations_p
= 1;
1154 DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p
,
1155 Srestore_buffer_modified_p
, 1, 1, 0,
1156 doc
: /* Like `set-buffer-modified-p', with a difference concerning redisplay.
1157 It is not ensured that mode lines will be updated to show the modified
1158 state of the current buffer. Use with care. */)
1161 #ifdef CLASH_DETECTION
1164 /* If buffer becoming modified, lock the file.
1165 If buffer becoming unmodified, unlock the file. */
1167 fn
= BVAR (current_buffer
, file_truename
);
1168 /* Test buffer-file-name so that binding it to nil is effective. */
1169 if (!NILP (fn
) && ! NILP (BVAR (current_buffer
, filename
)))
1171 int already
= SAVE_MODIFF
< MODIFF
;
1172 if (!already
&& !NILP (flag
))
1174 else if (already
&& NILP (flag
))
1177 #endif /* CLASH_DETECTION */
1179 SAVE_MODIFF
= NILP (flag
) ? MODIFF
: 0;
1183 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick
, Sbuffer_modified_tick
,
1185 doc
: /* Return BUFFER's tick counter, incremented for each change in text.
1186 Each buffer has a tick counter which is incremented each time the
1187 text in that buffer is changed. It wraps around occasionally.
1188 No argument or nil as argument means use current buffer as BUFFER. */)
1189 (register Lisp_Object buffer
)
1191 register struct buffer
*buf
;
1193 buf
= current_buffer
;
1196 CHECK_BUFFER (buffer
);
1197 buf
= XBUFFER (buffer
);
1200 return make_number (BUF_MODIFF (buf
));
1203 DEFUN ("buffer-chars-modified-tick", Fbuffer_chars_modified_tick
,
1204 Sbuffer_chars_modified_tick
, 0, 1, 0,
1205 doc
: /* Return BUFFER's character-change tick counter.
1206 Each buffer has a character-change tick counter, which is set to the
1207 value of the buffer's tick counter \(see `buffer-modified-tick'), each
1208 time text in that buffer is inserted or deleted. By comparing the
1209 values returned by two individual calls of `buffer-chars-modified-tick',
1210 you can tell whether a character change occurred in that buffer in
1211 between these calls. No argument or nil as argument means use current
1212 buffer as BUFFER. */)
1213 (register Lisp_Object buffer
)
1215 register struct buffer
*buf
;
1217 buf
= current_buffer
;
1220 CHECK_BUFFER (buffer
);
1221 buf
= XBUFFER (buffer
);
1224 return make_number (BUF_CHARS_MODIFF (buf
));
1227 DEFUN ("rename-buffer", Frename_buffer
, Srename_buffer
, 1, 2,
1228 "(list (read-string \"Rename buffer (to new name): \" \
1229 nil 'buffer-name-history (buffer-name (current-buffer))) \
1230 current-prefix-arg)",
1231 doc
: /* Change current buffer's name to NEWNAME (a string).
1232 If second arg UNIQUE is nil or omitted, it is an error if a
1233 buffer named NEWNAME already exists.
1234 If UNIQUE is non-nil, come up with a new name using
1235 `generate-new-buffer-name'.
1236 Interactively, you can set UNIQUE with a prefix argument.
1237 We return the name we actually gave the buffer.
1238 This does not change the name of the visited file (if any). */)
1239 (register Lisp_Object newname
, Lisp_Object unique
)
1241 register Lisp_Object tem
, buf
;
1243 CHECK_STRING (newname
);
1245 if (SCHARS (newname
) == 0)
1246 error ("Empty string is invalid as a buffer name");
1248 tem
= Fget_buffer (newname
);
1251 /* Don't short-circuit if UNIQUE is t. That is a useful way to
1252 rename the buffer automatically so you can create another
1253 with the original name. It makes UNIQUE equivalent to
1254 (rename-buffer (generate-new-buffer-name NEWNAME)). */
1255 if (NILP (unique
) && XBUFFER (tem
) == current_buffer
)
1256 return BVAR (current_buffer
, name
);
1258 newname
= Fgenerate_new_buffer_name (newname
, BVAR (current_buffer
, name
));
1260 error ("Buffer name `%s' is in use", SDATA (newname
));
1263 BVAR (current_buffer
, name
) = newname
;
1265 /* Catch redisplay's attention. Unless we do this, the mode lines for
1266 any windows displaying current_buffer will stay unchanged. */
1267 update_mode_lines
++;
1269 XSETBUFFER (buf
, current_buffer
);
1270 Fsetcar (Frassq (buf
, Vbuffer_alist
), newname
);
1271 if (NILP (BVAR (current_buffer
, filename
))
1272 && !NILP (BVAR (current_buffer
, auto_save_file_name
)))
1273 call0 (intern ("rename-auto-save-file"));
1275 /* Run buffer-list-update-hook. */
1276 if (!NILP (Vrun_hooks
))
1277 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1279 /* Refetch since that last call may have done GC. */
1280 return BVAR (current_buffer
, name
);
1283 DEFUN ("other-buffer", Fother_buffer
, Sother_buffer
, 0, 3, 0,
1284 doc
: /* Return most recently selected buffer other than BUFFER.
1285 Buffers not visible in windows are preferred to visible buffers, unless
1286 optional second argument VISIBLE-OK is non-nil. Ignore the argument
1287 BUFFER unless it denotes a live buffer. If the optional third argument
1288 FRAME is non-nil, use that frame's buffer list instead of the selected
1289 frame's buffer list.
1291 The buffer is found by scanning the selected or specified frame's buffer
1292 list first, followed by the list of all buffers. If no other buffer
1293 exists, return the buffer `*scratch*' (creating it if necessary). */)
1294 (register Lisp_Object buffer
, Lisp_Object visible_ok
, Lisp_Object frame
)
1296 Lisp_Object
Fset_buffer_major_mode (Lisp_Object buffer
);
1297 Lisp_Object tail
, buf
, pred
;
1298 Lisp_Object notsogood
= Qnil
;
1301 frame
= selected_frame
;
1303 CHECK_FRAME (frame
);
1305 pred
= frame_buffer_predicate (frame
);
1306 /* Consider buffers that have been seen in the frame first. */
1307 tail
= XFRAME (frame
)->buffer_list
;
1308 for (; CONSP (tail
); tail
= XCDR (tail
))
1311 if (BUFFERP (buf
) && !EQ (buf
, buffer
)
1312 && !NILP (BVAR (XBUFFER (buf
), name
))
1313 && (SREF (BVAR (XBUFFER (buf
), name
), 0) != ' ')
1314 /* If the frame has a buffer_predicate, disregard buffers that
1315 don't fit the predicate. */
1316 && (NILP (pred
) || !NILP (call1 (pred
, buf
))))
1318 if (!NILP (visible_ok
)
1319 || NILP (Fget_buffer_window (buf
, Qvisible
)))
1321 else if (NILP (notsogood
))
1326 /* Consider alist of all buffers next. */
1327 tail
= Vbuffer_alist
;
1328 for (; CONSP (tail
); tail
= XCDR (tail
))
1330 buf
= Fcdr (XCAR (tail
));
1331 if (BUFFERP (buf
) && !EQ (buf
, buffer
)
1332 && !NILP (BVAR (XBUFFER (buf
), name
))
1333 && (SREF (BVAR (XBUFFER (buf
), name
), 0) != ' ')
1334 /* If the frame has a buffer_predicate, disregard buffers that
1335 don't fit the predicate. */
1336 && (NILP (pred
) || !NILP (call1 (pred
, buf
))))
1338 if (!NILP (visible_ok
)
1339 || NILP (Fget_buffer_window (buf
, Qvisible
)))
1341 else if (NILP (notsogood
))
1346 if (!NILP (notsogood
))
1350 buf
= Fget_buffer (build_string ("*scratch*"));
1353 buf
= Fget_buffer_create (build_string ("*scratch*"));
1354 Fset_buffer_major_mode (buf
);
1360 /* The following function is a safe variant of Fother_buffer: It doesn't
1361 pay attention to any frame-local buffer lists, doesn't care about
1362 visibility of buffers, and doesn't evaluate any frame predicates. */
1365 other_buffer_safely (Lisp_Object buffer
)
1367 Lisp_Object
Fset_buffer_major_mode (Lisp_Object buffer
);
1368 Lisp_Object tail
, buf
;
1370 tail
= Vbuffer_alist
;
1371 for (; CONSP (tail
); tail
= XCDR (tail
))
1373 buf
= Fcdr (XCAR (tail
));
1374 if (BUFFERP (buf
) && !EQ (buf
, buffer
)
1375 && !NILP (BVAR (XBUFFER (buf
), name
))
1376 && (SREF (BVAR (XBUFFER (buf
), name
), 0) != ' '))
1380 buf
= Fget_buffer (build_string ("*scratch*"));
1383 buf
= Fget_buffer_create (build_string ("*scratch*"));
1384 Fset_buffer_major_mode (buf
);
1390 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo
, Sbuffer_enable_undo
,
1392 doc
: /* Start keeping undo information for buffer BUFFER.
1393 No argument or nil as argument means do this for the current buffer. */)
1394 (register Lisp_Object buffer
)
1396 Lisp_Object real_buffer
;
1399 XSETBUFFER (real_buffer
, current_buffer
);
1402 real_buffer
= Fget_buffer (buffer
);
1403 if (NILP (real_buffer
))
1407 if (EQ (BVAR (XBUFFER (real_buffer
), undo_list
), Qt
))
1408 BVAR (XBUFFER (real_buffer
), undo_list
) = Qnil
;
1414 DEFVAR_LISP ("kill-buffer-hook", ..., "\
1415 Hook to be run (by `run-hooks', which see) when a buffer is killed.\n\
1416 The buffer being killed will be current while the hook is running.\n\
1419 DEFUN ("kill-buffer", Fkill_buffer
, Skill_buffer
, 0, 1, "bKill buffer: ",
1420 doc
: /* Kill buffer BUFFER-OR-NAME.
1421 The argument may be a buffer or the name of an existing buffer.
1422 Argument nil or omitted means kill the current buffer. Return t if the
1423 buffer is actually killed, nil otherwise.
1425 This function calls `replace-buffer-in-windows' for cleaning up all
1426 windows currently displaying the buffer to be killed. The functions in
1427 `kill-buffer-query-functions' are called with the buffer to be killed as
1428 the current buffer. If any of them returns nil, the buffer is not
1429 killed. The hook `kill-buffer-hook' is run before the buffer is
1430 actually killed. The buffer being killed will be current while the hook
1433 Any processes that have this buffer as the `process-buffer' are killed
1435 (Lisp_Object buffer_or_name
)
1438 register struct buffer
*b
;
1439 register Lisp_Object tem
;
1440 register struct Lisp_Marker
*m
;
1441 struct gcpro gcpro1
;
1443 if (NILP (buffer_or_name
))
1444 buffer
= Fcurrent_buffer ();
1446 buffer
= Fget_buffer (buffer_or_name
);
1448 nsberror (buffer_or_name
);
1450 b
= XBUFFER (buffer
);
1452 /* Avoid trouble for buffer already dead. */
1453 if (NILP (BVAR (b
, name
)))
1456 /* Query if the buffer is still modified. */
1457 if (INTERACTIVE
&& !NILP (BVAR (b
, filename
))
1458 && BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
1461 tem
= do_yes_or_no_p (format2 ("Buffer %s modified; kill anyway? ",
1462 BVAR (b
, name
), make_number (0)));
1468 /* Run hooks with the buffer to be killed the current buffer. */
1470 int count
= SPECPDL_INDEX ();
1471 Lisp_Object arglist
[1];
1473 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1474 set_buffer_internal (b
);
1476 /* First run the query functions; if any query is answered no,
1477 don't kill the buffer. */
1478 arglist
[0] = Qkill_buffer_query_functions
;
1479 tem
= Frun_hook_with_args_until_failure (1, arglist
);
1481 return unbind_to (count
, Qnil
);
1483 /* Then run the hooks. */
1484 Frun_hooks (1, &Qkill_buffer_hook
);
1485 unbind_to (count
, Qnil
);
1488 /* We have no more questions to ask. Verify that it is valid
1489 to kill the buffer. This must be done after the questions
1490 since anything can happen within do_yes_or_no_p. */
1492 /* Don't kill the minibuffer now current. */
1493 if (EQ (buffer
, XWINDOW (minibuf_window
)->buffer
))
1496 if (NILP (BVAR (b
, name
)))
1499 /* When we kill a base buffer, kill all its indirect buffers.
1500 We do it at this stage so nothing terrible happens if they
1501 ask questions or their hooks get errors. */
1502 if (! b
->base_buffer
)
1504 struct buffer
*other
;
1508 for (other
= all_buffers
; other
; other
= other
->header
.next
.buffer
)
1509 /* all_buffers contains dead buffers too;
1510 don't re-kill them. */
1511 if (other
->base_buffer
== b
&& !NILP (BVAR (other
, name
)))
1514 XSETBUFFER (buf
, other
);
1521 /* Make this buffer not be current.
1522 In the process, notice if this is the sole visible buffer
1523 and give up if so. */
1524 if (b
== current_buffer
)
1526 tem
= Fother_buffer (buffer
, Qnil
, Qnil
);
1528 if (b
== current_buffer
)
1532 /* Notice if the buffer to kill is the sole visible buffer
1533 when we're currently in the mini-buffer, and give up if so. */
1534 XSETBUFFER (tem
, current_buffer
);
1535 if (EQ (tem
, XWINDOW (minibuf_window
)->buffer
))
1537 tem
= Fother_buffer (buffer
, Qnil
, Qnil
);
1538 if (EQ (buffer
, tem
))
1542 /* Now there is no question: we can kill the buffer. */
1544 #ifdef CLASH_DETECTION
1545 /* Unlock this buffer's file, if it is locked. */
1547 #endif /* CLASH_DETECTION */
1550 kill_buffer_processes (buffer
);
1553 /* Killing buffer processes may run sentinels which may
1554 have called kill-buffer. */
1556 if (NILP (BVAR (b
, name
)))
1559 /* These may run Lisp code and into infinite loops (if someone
1560 insisted on circular lists) so allow quitting here. */
1561 replace_buffer_in_windows (buffer
);
1562 frames_discard_buffer (buffer
);
1564 clear_charpos_cache (b
);
1566 tem
= Vinhibit_quit
;
1568 /* Remove the buffer from the list of all buffers. */
1569 Vbuffer_alist
= Fdelq (Frassq (buffer
, Vbuffer_alist
), Vbuffer_alist
);
1570 /* If replace_buffer_in_windows didn't do its job correctly fix that
1572 replace_buffer_in_windows_safely (buffer
);
1573 Vinhibit_quit
= tem
;
1575 /* Delete any auto-save file, if we saved it in this session.
1576 But not if the buffer is modified. */
1577 if (STRINGP (BVAR (b
, auto_save_file_name
))
1578 && BUF_AUTOSAVE_MODIFF (b
) != 0
1579 && BUF_SAVE_MODIFF (b
) < BUF_AUTOSAVE_MODIFF (b
)
1580 && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
)
1581 && NILP (Fsymbol_value (intern ("auto-save-visited-file-name"))))
1584 delete = Fsymbol_value (intern ("delete-auto-save-files"));
1585 if (! NILP (delete))
1586 internal_delete_file (BVAR (b
, auto_save_file_name
));
1591 /* Unchain all markers that belong to this indirect buffer.
1592 Don't unchain the markers that belong to the base buffer
1593 or its other indirect buffers. */
1594 for (m
= BUF_MARKERS (b
); m
; )
1596 struct Lisp_Marker
*next
= m
->next
;
1604 /* Unchain all markers of this buffer and its indirect buffers.
1605 and leave them pointing nowhere. */
1606 for (m
= BUF_MARKERS (b
); m
; )
1608 struct Lisp_Marker
*next
= m
->next
;
1613 BUF_MARKERS (b
) = NULL
;
1614 BUF_INTERVALS (b
) = NULL_INTERVAL
;
1616 /* Perhaps we should explicitly free the interval tree here... */
1619 /* Reset the local variables, so that this buffer's local values
1620 won't be protected from GC. They would be protected
1621 if they happened to remain encached in their symbols.
1622 This gets rid of them for certain. */
1623 swap_out_buffer_local_variables (b
);
1624 reset_buffer_local_variables (b
, 1);
1626 BVAR (b
, name
) = Qnil
;
1629 if (! b
->base_buffer
)
1630 free_buffer_text (b
);
1632 if (b
->newline_cache
)
1634 free_region_cache (b
->newline_cache
);
1635 b
->newline_cache
= 0;
1637 if (b
->width_run_cache
)
1639 free_region_cache (b
->width_run_cache
);
1640 b
->width_run_cache
= 0;
1642 BVAR (b
, width_table
) = Qnil
;
1644 BVAR (b
, undo_list
) = Qnil
;
1646 /* Run buffer-list-update-hook. */
1647 if (!NILP (Vrun_hooks
))
1648 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1653 /* Move association for BUFFER to the front of buffer (a)lists. Since
1654 we do this each time BUFFER is selected visibly, the more recently
1655 selected buffers are always closer to the front of those lists. This
1656 means that other_buffer is more likely to choose a relevant buffer.
1658 Note that this moves BUFFER to the front of the buffer lists of the
1659 selected frame even if BUFFER is not shown there. If BUFFER is not
1660 shown in the selected frame, consider the present behavior a feature.
1661 `select-window' gets this right since it shows BUFFER in the selected
1662 window when calling us. */
1665 record_buffer (Lisp_Object buffer
)
1667 Lisp_Object aelt
, link
, tem
;
1668 register struct frame
*f
= XFRAME (selected_frame
);
1669 register struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
1671 CHECK_BUFFER (buffer
);
1673 /* Update Vbuffer_alist (we know that it has an entry for BUFFER).
1674 Don't allow quitting since this might leave the buffer list in an
1675 inconsistent state. */
1676 tem
= Vinhibit_quit
;
1678 aelt
= Frassq (buffer
, Vbuffer_alist
);
1679 link
= Fmemq (aelt
, Vbuffer_alist
);
1680 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
1681 XSETCDR (link
, Vbuffer_alist
);
1682 Vbuffer_alist
= link
;
1683 Vinhibit_quit
= tem
;
1685 /* Update buffer list of selected frame. */
1686 f
->buffer_list
= Fcons (buffer
, Fdelq (buffer
, f
->buffer_list
));
1687 f
->buried_buffer_list
= Fdelq (buffer
, f
->buried_buffer_list
);
1689 /* Run buffer-list-update-hook. */
1690 if (!NILP (Vrun_hooks
))
1691 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1694 DEFUN ("record-buffer", Frecord_buffer
, Srecord_buffer
, 1, 1, 0,
1695 doc
: /* Move BUFFER to the front of the buffer list.
1697 (Lisp_Object buffer
)
1699 CHECK_BUFFER (buffer
);
1701 record_buffer (buffer
);
1706 /* Move BUFFER to the end of the buffer (a)lists. Do nothing if the
1707 buffer is killed. For the selected frame's buffer list this moves
1708 BUFFER to its end even if it was never shown in that frame. If
1709 this happens we have a feature, hence `unrecord-buffer' should be
1710 called only when BUFFER was shown in the selected frame. */
1712 DEFUN ("unrecord-buffer", Funrecord_buffer
, Sunrecord_buffer
, 1, 1, 0,
1713 doc
: /* Move BUFFER to the end of the buffer list.
1715 (Lisp_Object buffer
)
1717 Lisp_Object aelt
, link
, tem
;
1718 register struct frame
*f
= XFRAME (selected_frame
);
1720 CHECK_BUFFER (buffer
);
1722 /* Update Vbuffer_alist (we know that it has an entry for BUFFER).
1723 Don't allow quitting since this might leave the buffer list in an
1724 inconsistent state. */
1725 tem
= Vinhibit_quit
;
1727 aelt
= Frassq (buffer
, Vbuffer_alist
);
1728 link
= Fmemq (aelt
, Vbuffer_alist
);
1729 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
1730 XSETCDR (link
, Qnil
);
1731 Vbuffer_alist
= nconc2 (Vbuffer_alist
, link
);
1732 Vinhibit_quit
= tem
;
1734 /* Update buffer lists of selected frame. */
1735 f
->buffer_list
= Fdelq (buffer
, f
->buffer_list
);
1736 f
->buried_buffer_list
= Fcons (buffer
, Fdelq (buffer
, f
->buried_buffer_list
));
1738 /* Run buffer-list-update-hook. */
1739 if (!NILP (Vrun_hooks
))
1740 call1 (Vrun_hooks
, Qbuffer_list_update_hook
);
1745 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode
, Sset_buffer_major_mode
, 1, 1, 0,
1746 doc
: /* Set an appropriate major mode for BUFFER.
1747 For the *scratch* buffer, use `initial-major-mode', otherwise choose a mode
1748 according to `default-major-mode'.
1749 Use this function before selecting the buffer, since it may need to inspect
1750 the current buffer's major mode. */)
1751 (Lisp_Object buffer
)
1754 Lisp_Object function
;
1756 CHECK_BUFFER (buffer
);
1758 if (STRINGP (BVAR (XBUFFER (buffer
), name
))
1759 && strcmp (SSDATA (BVAR (XBUFFER (buffer
), name
)), "*scratch*") == 0)
1760 function
= find_symbol_value (intern ("initial-major-mode"));
1763 function
= BVAR (&buffer_defaults
, major_mode
);
1765 && NILP (Fget (BVAR (current_buffer
, major_mode
), Qmode_class
)))
1766 function
= BVAR (current_buffer
, major_mode
);
1769 if (NILP (function
) || EQ (function
, Qfundamental_mode
))
1772 count
= SPECPDL_INDEX ();
1774 /* To select a nonfundamental mode,
1775 select the buffer temporarily and then call the mode function. */
1777 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1779 Fset_buffer (buffer
);
1782 return unbind_to (count
, Qnil
);
1785 DEFUN ("current-buffer", Fcurrent_buffer
, Scurrent_buffer
, 0, 0, 0,
1786 doc
: /* Return the current buffer as a Lisp object. */)
1789 register Lisp_Object buf
;
1790 XSETBUFFER (buf
, current_buffer
);
1794 /* Set the current buffer to B.
1796 We previously set windows_or_buffers_changed here to invalidate
1797 global unchanged information in beg_unchanged and end_unchanged.
1798 This is no longer necessary because we now compute unchanged
1799 information on a buffer-basis. Every action affecting other
1800 windows than the selected one requires a select_window at some
1801 time, and that increments windows_or_buffers_changed. */
1804 set_buffer_internal (register struct buffer
*b
)
1806 if (current_buffer
!= b
)
1807 set_buffer_internal_1 (b
);
1810 /* Set the current buffer to B, and do not set windows_or_buffers_changed.
1811 This is used by redisplay. */
1814 set_buffer_internal_1 (register struct buffer
*b
)
1816 register struct buffer
*old_buf
;
1817 register Lisp_Object tail
;
1819 #ifdef USE_MMAP_FOR_BUFFERS
1820 if (b
->text
->beg
== NULL
)
1821 enlarge_buffer_text (b
, 0);
1822 #endif /* USE_MMAP_FOR_BUFFERS */
1824 if (current_buffer
== b
)
1827 old_buf
= current_buffer
;
1829 last_known_column_point
= -1; /* invalidate indentation cache */
1833 /* Put the undo list back in the base buffer, so that it appears
1834 that an indirect buffer shares the undo list of its base. */
1835 if (old_buf
->base_buffer
)
1836 BVAR (old_buf
->base_buffer
, undo_list
) = BVAR (old_buf
, undo_list
);
1838 /* If the old current buffer has markers to record PT, BEGV and ZV
1839 when it is not current, update them now. */
1840 record_buffer_markers (old_buf
);
1843 /* Get the undo list from the base buffer, so that it appears
1844 that an indirect buffer shares the undo list of its base. */
1846 BVAR (b
, undo_list
) = BVAR (b
->base_buffer
, undo_list
);
1848 /* If the new current buffer has markers to record PT, BEGV and ZV
1849 when it is not current, fetch them now. */
1850 fetch_buffer_markers (b
);
1852 /* Look down buffer's list of local Lisp variables
1853 to find and update any that forward into C variables. */
1857 for (tail
= BVAR (b
, local_var_alist
); CONSP (tail
); tail
= XCDR (tail
))
1859 Lisp_Object var
= XCAR (XCAR (tail
));
1860 struct Lisp_Symbol
*sym
= XSYMBOL (var
);
1861 if (sym
->redirect
== SYMBOL_LOCALIZED
/* Just to be sure. */
1862 && SYMBOL_BLV (sym
)->fwd
)
1863 /* Just reference the variable
1864 to cause it to become set for this buffer. */
1865 Fsymbol_value (var
);
1868 /* Do the same with any others that were local to the previous buffer */
1869 while (b
!= old_buf
&& (b
= old_buf
, b
));
1872 /* Switch to buffer B temporarily for redisplay purposes.
1873 This avoids certain things that don't need to be done within redisplay. */
1876 set_buffer_temp (struct buffer
*b
)
1878 register struct buffer
*old_buf
;
1880 if (current_buffer
== b
)
1883 old_buf
= current_buffer
;
1886 /* If the old current buffer has markers to record PT, BEGV and ZV
1887 when it is not current, update them now. */
1888 record_buffer_markers (old_buf
);
1890 /* If the new current buffer has markers to record PT, BEGV and ZV
1891 when it is not current, fetch them now. */
1892 fetch_buffer_markers (b
);
1895 DEFUN ("set-buffer", Fset_buffer
, Sset_buffer
, 1, 1, 0,
1896 doc
: /* Make buffer BUFFER-OR-NAME current for editing operations.
1897 BUFFER-OR-NAME may be a buffer or the name of an existing buffer. See
1898 also `save-excursion' when you want to make a buffer current
1899 temporarily. This function does not display the buffer, so its effect
1900 ends when the current command terminates. Use `switch-to-buffer' or
1901 `pop-to-buffer' to switch buffers permanently. */)
1902 (register Lisp_Object buffer_or_name
)
1904 register Lisp_Object buffer
;
1905 buffer
= Fget_buffer (buffer_or_name
);
1907 nsberror (buffer_or_name
);
1908 if (NILP (BVAR (XBUFFER (buffer
), name
)))
1909 error ("Selecting deleted buffer");
1910 set_buffer_internal (XBUFFER (buffer
));
1914 /* Set the current buffer to BUFFER provided it is alive. */
1917 set_buffer_if_live (Lisp_Object buffer
)
1919 if (! NILP (BVAR (XBUFFER (buffer
), name
)))
1920 Fset_buffer (buffer
);
1924 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only
,
1925 Sbarf_if_buffer_read_only
, 0, 0, 0,
1926 doc
: /* Signal a `buffer-read-only' error if the current buffer is read-only. */)
1929 if (!NILP (BVAR (current_buffer
, read_only
))
1930 && NILP (Vinhibit_read_only
))
1931 xsignal1 (Qbuffer_read_only
, Fcurrent_buffer ());
1935 DEFUN ("erase-buffer", Ferase_buffer
, Serase_buffer
, 0, 0, "*",
1936 doc
: /* Delete the entire contents of the current buffer.
1937 Any narrowing restriction in effect (see `narrow-to-region') is removed,
1938 so the buffer is truly empty after this. */)
1945 current_buffer
->last_window_start
= 1;
1946 /* Prevent warnings, or suspension of auto saving, that would happen
1947 if future size is less than past size. Use of erase-buffer
1948 implies that the future text is not really related to the past text. */
1949 XSETFASTINT (BVAR (current_buffer
, save_length
), 0);
1954 validate_region (register Lisp_Object
*b
, register Lisp_Object
*e
)
1956 CHECK_NUMBER_COERCE_MARKER (*b
);
1957 CHECK_NUMBER_COERCE_MARKER (*e
);
1959 if (XINT (*b
) > XINT (*e
))
1962 tem
= *b
; *b
= *e
; *e
= tem
;
1965 if (!(BEGV
<= XINT (*b
) && XINT (*b
) <= XINT (*e
)
1966 && XINT (*e
) <= ZV
))
1967 args_out_of_range (*b
, *e
);
1970 /* Advance BYTE_POS up to a character boundary
1971 and return the adjusted position. */
1974 advance_to_char_boundary (EMACS_INT byte_pos
)
1978 if (byte_pos
== BEG
)
1979 /* Beginning of buffer is always a character boundary. */
1982 c
= FETCH_BYTE (byte_pos
);
1983 if (! CHAR_HEAD_P (c
))
1985 /* We should advance BYTE_POS only when C is a constituent of a
1986 multibyte sequence. */
1987 EMACS_INT orig_byte_pos
= byte_pos
;
1992 c
= FETCH_BYTE (byte_pos
);
1994 while (! CHAR_HEAD_P (c
) && byte_pos
> BEG
);
1996 if (byte_pos
< orig_byte_pos
)
1997 byte_pos
= orig_byte_pos
;
1998 /* If C is a constituent of a multibyte sequence, BYTE_POS was
1999 surely advance to the correct character boundary. If C is
2000 not, BYTE_POS was unchanged. */
2007 extern void r_alloc_reset_variable (POINTER_TYPE
*, POINTER_TYPE
*);
2008 #endif /* REL_ALLOC */
2010 DEFUN ("buffer-swap-text", Fbuffer_swap_text
, Sbuffer_swap_text
,
2012 doc
: /* Swap the text between current buffer and BUFFER. */)
2013 (Lisp_Object buffer
)
2015 struct buffer
*other_buffer
;
2016 CHECK_BUFFER (buffer
);
2017 other_buffer
= XBUFFER (buffer
);
2019 if (NILP (BVAR (other_buffer
, name
)))
2020 error ("Cannot swap a dead buffer's text");
2022 /* Actually, it probably works just fine.
2023 * if (other_buffer == current_buffer)
2024 * error ("Cannot swap a buffer's text with itself"); */
2026 /* Actually, this may be workable as well, tho probably only if they're
2028 if (other_buffer
->base_buffer
2029 || current_buffer
->base_buffer
)
2030 error ("Cannot swap indirect buffers's text");
2032 { /* This is probably harder to make work. */
2033 struct buffer
*other
;
2034 for (other
= all_buffers
; other
; other
= other
->header
.next
.buffer
)
2035 if (other
->base_buffer
== other_buffer
2036 || other
->base_buffer
== current_buffer
)
2037 error ("One of the buffers to swap has indirect buffers");
2040 #define swapfield(field, type) \
2042 type tmp##field = other_buffer->field; \
2043 other_buffer->field = current_buffer->field; \
2044 current_buffer->field = tmp##field; \
2046 #define swapfield_(field, type) \
2048 type tmp##field = BVAR (other_buffer, field); \
2049 BVAR (other_buffer, field) = BVAR (current_buffer, field); \
2050 BVAR (current_buffer, field) = tmp##field; \
2053 swapfield (own_text
, struct buffer_text
);
2054 eassert (current_buffer
->text
== ¤t_buffer
->own_text
);
2055 eassert (other_buffer
->text
== &other_buffer
->own_text
);
2057 r_alloc_reset_variable ((POINTER_TYPE
**) ¤t_buffer
->own_text
.beg
,
2058 (POINTER_TYPE
**) &other_buffer
->own_text
.beg
);
2059 r_alloc_reset_variable ((POINTER_TYPE
**) &other_buffer
->own_text
.beg
,
2060 (POINTER_TYPE
**) ¤t_buffer
->own_text
.beg
);
2061 #endif /* REL_ALLOC */
2063 swapfield (pt
, EMACS_INT
);
2064 swapfield (pt_byte
, EMACS_INT
);
2065 swapfield (begv
, EMACS_INT
);
2066 swapfield (begv_byte
, EMACS_INT
);
2067 swapfield (zv
, EMACS_INT
);
2068 swapfield (zv_byte
, EMACS_INT
);
2069 eassert (!current_buffer
->base_buffer
);
2070 eassert (!other_buffer
->base_buffer
);
2071 current_buffer
->clip_changed
= 1; other_buffer
->clip_changed
= 1;
2072 swapfield (newline_cache
, struct region_cache
*);
2073 swapfield (width_run_cache
, struct region_cache
*);
2074 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2075 other_buffer
->prevent_redisplay_optimizations_p
= 1;
2076 swapfield (overlays_before
, struct Lisp_Overlay
*);
2077 swapfield (overlays_after
, struct Lisp_Overlay
*);
2078 swapfield (overlay_center
, EMACS_INT
);
2079 swapfield_ (undo_list
, Lisp_Object
);
2080 swapfield_ (mark
, Lisp_Object
);
2081 swapfield_ (enable_multibyte_characters
, Lisp_Object
);
2082 swapfield_ (bidi_display_reordering
, Lisp_Object
);
2083 swapfield_ (bidi_paragraph_direction
, Lisp_Object
);
2084 /* FIXME: Not sure what we should do with these *_marker fields.
2085 Hopefully they're just nil anyway. */
2086 swapfield_ (pt_marker
, Lisp_Object
);
2087 swapfield_ (begv_marker
, Lisp_Object
);
2088 swapfield_ (zv_marker
, Lisp_Object
);
2089 BVAR (current_buffer
, point_before_scroll
) = Qnil
;
2090 BVAR (other_buffer
, point_before_scroll
) = Qnil
;
2092 current_buffer
->text
->modiff
++; other_buffer
->text
->modiff
++;
2093 current_buffer
->text
->chars_modiff
++; other_buffer
->text
->chars_modiff
++;
2094 current_buffer
->text
->overlay_modiff
++; other_buffer
->text
->overlay_modiff
++;
2095 current_buffer
->text
->beg_unchanged
= current_buffer
->text
->gpt
;
2096 current_buffer
->text
->end_unchanged
= current_buffer
->text
->gpt
;
2097 other_buffer
->text
->beg_unchanged
= other_buffer
->text
->gpt
;
2098 other_buffer
->text
->end_unchanged
= other_buffer
->text
->gpt
;
2100 struct Lisp_Marker
*m
;
2101 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
2102 if (m
->buffer
== other_buffer
)
2103 m
->buffer
= current_buffer
;
2105 /* Since there's no indirect buffer in sight, markers on
2106 BUF_MARKERS(buf) should either be for `buf' or dead. */
2107 eassert (!m
->buffer
);
2108 for (m
= BUF_MARKERS (other_buffer
); m
; m
= m
->next
)
2109 if (m
->buffer
== current_buffer
)
2110 m
->buffer
= other_buffer
;
2112 /* Since there's no indirect buffer in sight, markers on
2113 BUF_MARKERS(buf) should either be for `buf' or dead. */
2114 eassert (!m
->buffer
);
2116 { /* Some of the C code expects that w->buffer == w->pointm->buffer.
2117 So since we just swapped the markers between the two buffers, we need
2118 to undo the effect of this swap for window markers. */
2119 Lisp_Object w
= Fselected_window (), ws
= Qnil
;
2120 Lisp_Object buf1
, buf2
;
2121 XSETBUFFER (buf1
, current_buffer
); XSETBUFFER (buf2
, other_buffer
);
2123 while (NILP (Fmemq (w
, ws
)))
2126 if (MARKERP (XWINDOW (w
)->pointm
)
2127 && (EQ (XWINDOW (w
)->buffer
, buf1
)
2128 || EQ (XWINDOW (w
)->buffer
, buf2
)))
2129 Fset_marker (XWINDOW (w
)->pointm
,
2130 make_number (BUF_BEGV (XBUFFER (XWINDOW (w
)->buffer
))),
2131 XWINDOW (w
)->buffer
);
2132 w
= Fnext_window (w
, Qt
, Qt
);
2136 if (current_buffer
->text
->intervals
)
2137 (eassert (EQ (current_buffer
->text
->intervals
->up
.obj
, buffer
)),
2138 XSETBUFFER (current_buffer
->text
->intervals
->up
.obj
, current_buffer
));
2139 if (other_buffer
->text
->intervals
)
2140 (eassert (EQ (other_buffer
->text
->intervals
->up
.obj
, Fcurrent_buffer ())),
2141 XSETBUFFER (other_buffer
->text
->intervals
->up
.obj
, other_buffer
));
2146 DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte
, Sset_buffer_multibyte
,
2148 doc
: /* Set the multibyte flag of the current buffer to FLAG.
2149 If FLAG is t, this makes the buffer a multibyte buffer.
2150 If FLAG is nil, this makes the buffer a single-byte buffer.
2151 In these cases, the buffer contents remain unchanged as a sequence of
2152 bytes but the contents viewed as characters do change.
2153 If FLAG is `to', this makes the buffer a multibyte buffer by changing
2154 all eight-bit bytes to eight-bit characters.
2155 If the multibyte flag was really changed, undo information of the
2156 current buffer is cleared. */)
2159 struct Lisp_Marker
*tail
, *markers
;
2160 struct buffer
*other
;
2162 int narrowed
= (BEG
!= BEGV
|| Z
!= ZV
);
2163 int modified_p
= !NILP (Fbuffer_modified_p (Qnil
));
2164 Lisp_Object old_undo
= BVAR (current_buffer
, undo_list
);
2165 struct gcpro gcpro1
;
2167 if (current_buffer
->base_buffer
)
2168 error ("Cannot do `set-buffer-multibyte' on an indirect buffer");
2170 /* Do nothing if nothing actually changes. */
2171 if (NILP (flag
) == NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
2176 /* Don't record these buffer changes. We will put a special undo entry
2178 BVAR (current_buffer
, undo_list
) = Qt
;
2180 /* If the cached position is for this buffer, clear it out. */
2181 clear_charpos_cache (current_buffer
);
2184 begv
= BEGV_BYTE
, zv
= ZV_BYTE
;
2186 begv
= BEGV
, zv
= ZV
;
2193 EMACS_INT pos
, stop
;
2196 /* Do this first, so it can use CHAR_TO_BYTE
2197 to calculate the old correspondences. */
2198 set_intervals_multibyte (0);
2200 BVAR (current_buffer
, enable_multibyte_characters
) = Qnil
;
2206 TEMP_SET_PT_BOTH (PT_BYTE
, PT_BYTE
);
2209 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
2210 tail
->charpos
= tail
->bytepos
;
2212 /* Convert multibyte form of 8-bit characters to unibyte. */
2227 if (ASCII_BYTE_P (*p
))
2229 else if (CHAR_BYTE8_HEAD_P (*p
))
2231 c
= STRING_CHAR_AND_LENGTH (p
, bytes
);
2232 /* Delete all bytes for this 8-bit character but the
2233 last one, and change the last one to the character
2236 del_range_2 (pos
, pos
, pos
+ bytes
, pos
+ bytes
, 0);
2248 bytes
= BYTES_BY_CHAR_HEAD (*p
);
2249 p
+= bytes
, pos
+= bytes
;
2253 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2258 EMACS_INT pos
, stop
;
2259 unsigned char *p
, *pend
;
2261 /* Be sure not to have a multibyte sequence striding over the GAP.
2262 Ex: We change this: "...abc\302 _GAP_ \241def..."
2263 to: "...abc _GAP_ \302\241def..." */
2266 && GPT_BYTE
> 1 && GPT_BYTE
< Z_BYTE
2267 && ! CHAR_HEAD_P (*(GAP_END_ADDR
)))
2269 unsigned char *q
= GPT_ADDR
- 1;
2271 while (! CHAR_HEAD_P (*q
) && q
> BEG_ADDR
) q
--;
2272 if (LEADING_CODE_P (*q
))
2274 EMACS_INT new_gpt
= GPT_BYTE
- (GPT_ADDR
- q
);
2276 move_gap_both (new_gpt
, new_gpt
);
2280 /* Make the buffer contents valid as multibyte by converting
2281 8-bit characters to multibyte form. */
2299 if (ASCII_BYTE_P (*p
))
2301 else if (EQ (flag
, Qt
)
2302 && ! CHAR_BYTE8_HEAD_P (*p
)
2303 && (bytes
= MULTIBYTE_LENGTH (p
, pend
)) > 0)
2304 p
+= bytes
, pos
+= bytes
;
2307 unsigned char tmp
[MAX_MULTIBYTE_LENGTH
];
2310 c
= BYTE8_TO_CHAR (*p
);
2311 bytes
= CHAR_STRING (c
, tmp
);
2313 TEMP_SET_PT_BOTH (pos
+ 1, pos
+ 1);
2315 insert_1_both ((char *) tmp
+ 1, bytes
, bytes
, 1, 0, 0);
2316 /* Now the gap is after the just inserted data. */
2334 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2336 /* Do this first, so that chars_in_text asks the right question.
2337 set_intervals_multibyte needs it too. */
2338 BVAR (current_buffer
, enable_multibyte_characters
) = Qt
;
2340 GPT_BYTE
= advance_to_char_boundary (GPT_BYTE
);
2341 GPT
= chars_in_text (BEG_ADDR
, GPT_BYTE
- BEG_BYTE
) + BEG
;
2343 Z
= chars_in_text (GAP_END_ADDR
, Z_BYTE
- GPT_BYTE
) + GPT
;
2345 BEGV_BYTE
= advance_to_char_boundary (BEGV_BYTE
);
2346 if (BEGV_BYTE
> GPT_BYTE
)
2347 BEGV
= chars_in_text (GAP_END_ADDR
, BEGV_BYTE
- GPT_BYTE
) + GPT
;
2349 BEGV
= chars_in_text (BEG_ADDR
, BEGV_BYTE
- BEG_BYTE
) + BEG
;
2351 ZV_BYTE
= advance_to_char_boundary (ZV_BYTE
);
2352 if (ZV_BYTE
> GPT_BYTE
)
2353 ZV
= chars_in_text (GAP_END_ADDR
, ZV_BYTE
- GPT_BYTE
) + GPT
;
2355 ZV
= chars_in_text (BEG_ADDR
, ZV_BYTE
- BEG_BYTE
) + BEG
;
2358 EMACS_INT byte
= advance_to_char_boundary (PT_BYTE
);
2361 if (byte
> GPT_BYTE
)
2362 position
= chars_in_text (GAP_END_ADDR
, byte
- GPT_BYTE
) + GPT
;
2364 position
= chars_in_text (BEG_ADDR
, byte
- BEG_BYTE
) + BEG
;
2365 TEMP_SET_PT_BOTH (position
, byte
);
2368 tail
= markers
= BUF_MARKERS (current_buffer
);
2370 /* This prevents BYTE_TO_CHAR (that is, buf_bytepos_to_charpos) from
2371 getting confused by the markers that have not yet been updated.
2372 It is also a signal that it should never create a marker. */
2373 BUF_MARKERS (current_buffer
) = NULL
;
2375 for (; tail
; tail
= tail
->next
)
2377 tail
->bytepos
= advance_to_char_boundary (tail
->bytepos
);
2378 tail
->charpos
= BYTE_TO_CHAR (tail
->bytepos
);
2381 /* Make sure no markers were put on the chain
2382 while the chain value was incorrect. */
2383 if (BUF_MARKERS (current_buffer
))
2386 BUF_MARKERS (current_buffer
) = markers
;
2388 /* Do this last, so it can calculate the new correspondences
2389 between chars and bytes. */
2390 set_intervals_multibyte (1);
2393 if (!EQ (old_undo
, Qt
))
2395 /* Represent all the above changes by a special undo entry. */
2396 BVAR (current_buffer
, undo_list
) = Fcons (list3 (Qapply
,
2397 intern ("set-buffer-multibyte"),
2398 NILP (flag
) ? Qt
: Qnil
),
2404 /* Changing the multibyteness of a buffer means that all windows
2405 showing that buffer must be updated thoroughly. */
2406 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2407 ++windows_or_buffers_changed
;
2409 /* Copy this buffer's new multibyte status
2410 into all of its indirect buffers. */
2411 for (other
= all_buffers
; other
; other
= other
->header
.next
.buffer
)
2412 if (other
->base_buffer
== current_buffer
&& !NILP (BVAR (other
, name
)))
2414 BVAR (other
, enable_multibyte_characters
)
2415 = BVAR (current_buffer
, enable_multibyte_characters
);
2416 other
->prevent_redisplay_optimizations_p
= 1;
2419 /* Restore the modifiedness of the buffer. */
2420 if (!modified_p
&& !NILP (Fbuffer_modified_p (Qnil
)))
2421 Fset_buffer_modified_p (Qnil
);
2423 /* Update coding systems of this buffer's process (if any). */
2425 Lisp_Object process
;
2427 process
= Fget_buffer_process (Fcurrent_buffer ());
2428 if (PROCESSP (process
))
2429 setup_process_coding_systems (process
);
2435 DEFUN ("kill-all-local-variables", Fkill_all_local_variables
,
2436 Skill_all_local_variables
, 0, 0, 0,
2437 doc
: /* Switch to Fundamental mode by killing current buffer's local variables.
2438 Most local variable bindings are eliminated so that the default values
2439 become effective once more. Also, the syntax table is set from
2440 `standard-syntax-table', the local keymap is set to nil,
2441 and the abbrev table from `fundamental-mode-abbrev-table'.
2442 This function also forces redisplay of the mode line.
2444 Every function to select a new major mode starts by
2445 calling this function.
2447 As a special exception, local variables whose names have
2448 a non-nil `permanent-local' property are not eliminated by this function.
2450 The first thing this function does is run
2451 the normal hook `change-major-mode-hook'. */)
2454 Frun_hooks (1, &Qchange_major_mode_hook
);
2456 /* Make sure none of the bindings in local_var_alist
2457 remain swapped in, in their symbols. */
2459 swap_out_buffer_local_variables (current_buffer
);
2461 /* Actually eliminate all local bindings of this buffer. */
2463 reset_buffer_local_variables (current_buffer
, 0);
2465 /* Force mode-line redisplay. Useful here because all major mode
2466 commands call this function. */
2467 update_mode_lines
++;
2472 /* Make sure no local variables remain set up with buffer B
2473 for their current values. */
2476 swap_out_buffer_local_variables (struct buffer
*b
)
2478 Lisp_Object oalist
, alist
, buffer
;
2480 XSETBUFFER (buffer
, b
);
2481 oalist
= BVAR (b
, local_var_alist
);
2483 for (alist
= oalist
; CONSP (alist
); alist
= XCDR (alist
))
2485 Lisp_Object sym
= XCAR (XCAR (alist
));
2486 eassert (XSYMBOL (sym
)->redirect
== SYMBOL_LOCALIZED
);
2487 /* Need not do anything if some other buffer's binding is
2489 if (EQ (SYMBOL_BLV (XSYMBOL (sym
))->where
, buffer
))
2491 /* Symbol is set up for this buffer's old local value:
2493 swap_in_global_binding (XSYMBOL (sym
));
2498 /* Find all the overlays in the current buffer that contain position POS.
2499 Return the number found, and store them in a vector in *VEC_PTR.
2500 Store in *LEN_PTR the size allocated for the vector.
2501 Store in *NEXT_PTR the next position after POS where an overlay starts,
2502 or ZV if there are no more overlays between POS and ZV.
2503 Store in *PREV_PTR the previous position before POS where an overlay ends,
2504 or where an overlay starts which ends at or after POS;
2505 or BEGV if there are no such overlays from BEGV to POS.
2506 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2508 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2509 when this function is called.
2511 If EXTEND is non-zero, we make the vector bigger if necessary.
2512 If EXTEND is zero, we never extend the vector,
2513 and we store only as many overlays as will fit.
2514 But we still return the total number of overlays.
2516 If CHANGE_REQ is true, then any position written into *PREV_PTR or
2517 *NEXT_PTR is guaranteed to be not equal to POS, unless it is the
2518 default (BEGV or ZV). */
2521 overlays_at (EMACS_INT pos
, int extend
, Lisp_Object
**vec_ptr
, int *len_ptr
,
2522 EMACS_INT
*next_ptr
, EMACS_INT
*prev_ptr
, int change_req
)
2524 Lisp_Object overlay
, start
, end
;
2525 struct Lisp_Overlay
*tail
;
2528 Lisp_Object
*vec
= *vec_ptr
;
2529 EMACS_INT next
= ZV
;
2530 EMACS_INT prev
= BEGV
;
2531 int inhibit_storing
= 0;
2533 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2535 EMACS_INT startpos
, endpos
;
2537 XSETMISC (overlay
, tail
);
2539 start
= OVERLAY_START (overlay
);
2540 end
= OVERLAY_END (overlay
);
2541 endpos
= OVERLAY_POSITION (end
);
2548 startpos
= OVERLAY_POSITION (start
);
2549 /* This one ends at or after POS
2550 so its start counts for PREV_PTR if it's before POS. */
2551 if (prev
< startpos
&& startpos
< pos
)
2555 if (startpos
<= pos
)
2559 /* The supplied vector is full.
2560 Either make it bigger, or don't store any more in it. */
2563 /* Make it work with an initial len == 0. */
2568 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2572 inhibit_storing
= 1;
2575 if (!inhibit_storing
)
2577 /* Keep counting overlays even if we can't return them all. */
2580 else if (startpos
< next
)
2584 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2586 EMACS_INT startpos
, endpos
;
2588 XSETMISC (overlay
, tail
);
2590 start
= OVERLAY_START (overlay
);
2591 end
= OVERLAY_END (overlay
);
2592 startpos
= OVERLAY_POSITION (start
);
2595 if (startpos
< next
)
2599 endpos
= OVERLAY_POSITION (end
);
2606 /* Make it work with an initial len == 0. */
2611 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2615 inhibit_storing
= 1;
2618 if (!inhibit_storing
)
2622 if (startpos
< pos
&& startpos
> prev
)
2625 else if (endpos
< pos
&& endpos
> prev
)
2627 else if (endpos
== pos
&& startpos
> prev
2628 && (!change_req
|| startpos
< pos
))
2639 /* Find all the overlays in the current buffer that overlap the range
2640 BEG-END, or are empty at BEG, or are empty at END provided END
2641 denotes the position at the end of the current buffer.
2643 Return the number found, and store them in a vector in *VEC_PTR.
2644 Store in *LEN_PTR the size allocated for the vector.
2645 Store in *NEXT_PTR the next position after POS where an overlay starts,
2646 or ZV if there are no more overlays.
2647 Store in *PREV_PTR the previous position before POS where an overlay ends,
2648 or BEGV if there are no previous overlays.
2649 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2651 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2652 when this function is called.
2654 If EXTEND is non-zero, we make the vector bigger if necessary.
2655 If EXTEND is zero, we never extend the vector,
2656 and we store only as many overlays as will fit.
2657 But we still return the total number of overlays. */
2660 overlays_in (EMACS_INT beg
, EMACS_INT end
, int extend
,
2661 Lisp_Object
**vec_ptr
, int *len_ptr
,
2662 EMACS_INT
*next_ptr
, EMACS_INT
*prev_ptr
)
2664 Lisp_Object overlay
, ostart
, oend
;
2665 struct Lisp_Overlay
*tail
;
2668 Lisp_Object
*vec
= *vec_ptr
;
2669 EMACS_INT next
= ZV
;
2670 EMACS_INT prev
= BEGV
;
2671 int inhibit_storing
= 0;
2672 int end_is_Z
= end
== Z
;
2674 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2676 EMACS_INT startpos
, endpos
;
2678 XSETMISC (overlay
, tail
);
2680 ostart
= OVERLAY_START (overlay
);
2681 oend
= OVERLAY_END (overlay
);
2682 endpos
= OVERLAY_POSITION (oend
);
2689 startpos
= OVERLAY_POSITION (ostart
);
2690 /* Count an interval if it overlaps the range, is empty at the
2691 start of the range, or is empty at END provided END denotes the
2692 end of the buffer. */
2693 if ((beg
< endpos
&& startpos
< end
)
2694 || (startpos
== endpos
2695 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
2699 /* The supplied vector is full.
2700 Either make it bigger, or don't store any more in it. */
2703 /* Make it work with an initial len == 0. */
2708 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2712 inhibit_storing
= 1;
2715 if (!inhibit_storing
)
2717 /* Keep counting overlays even if we can't return them all. */
2720 else if (startpos
< next
)
2724 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2726 EMACS_INT startpos
, endpos
;
2728 XSETMISC (overlay
, tail
);
2730 ostart
= OVERLAY_START (overlay
);
2731 oend
= OVERLAY_END (overlay
);
2732 startpos
= OVERLAY_POSITION (ostart
);
2735 if (startpos
< next
)
2739 endpos
= OVERLAY_POSITION (oend
);
2740 /* Count an interval if it overlaps the range, is empty at the
2741 start of the range, or is empty at END provided END denotes the
2742 end of the buffer. */
2743 if ((beg
< endpos
&& startpos
< end
)
2744 || (startpos
== endpos
2745 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
2751 /* Make it work with an initial len == 0. */
2756 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2760 inhibit_storing
= 1;
2763 if (!inhibit_storing
)
2767 else if (endpos
< beg
&& endpos
> prev
)
2779 /* Return non-zero if there exists an overlay with a non-nil
2780 `mouse-face' property overlapping OVERLAY. */
2783 mouse_face_overlay_overlaps (Lisp_Object overlay
)
2785 EMACS_INT start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2786 EMACS_INT end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2788 Lisp_Object
*v
, tem
;
2791 v
= (Lisp_Object
*) alloca (size
* sizeof *v
);
2792 n
= overlays_in (start
, end
, 0, &v
, &size
, NULL
, NULL
);
2795 v
= (Lisp_Object
*) alloca (n
* sizeof *v
);
2796 overlays_in (start
, end
, 0, &v
, &n
, NULL
, NULL
);
2799 for (i
= 0; i
< n
; ++i
)
2800 if (!EQ (v
[i
], overlay
)
2801 && (tem
= Foverlay_get (overlay
, Qmouse_face
),
2810 /* Fast function to just test if we're at an overlay boundary. */
2812 overlay_touches_p (EMACS_INT pos
)
2814 Lisp_Object overlay
;
2815 struct Lisp_Overlay
*tail
;
2817 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2821 XSETMISC (overlay
,tail
);
2822 if (!OVERLAYP (overlay
))
2825 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2828 if (endpos
== pos
|| OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
)
2832 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2836 XSETMISC (overlay
, tail
);
2837 if (!OVERLAYP (overlay
))
2840 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2843 if (startpos
== pos
|| OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
)
2851 Lisp_Object overlay
;
2857 compare_overlays (const void *v1
, const void *v2
)
2859 const struct sortvec
*s1
= (const struct sortvec
*) v1
;
2860 const struct sortvec
*s2
= (const struct sortvec
*) v2
;
2861 if (s1
->priority
!= s2
->priority
)
2862 return s1
->priority
- s2
->priority
;
2863 if (s1
->beg
!= s2
->beg
)
2864 return s1
->beg
- s2
->beg
;
2865 if (s1
->end
!= s2
->end
)
2866 return s2
->end
- s1
->end
;
2870 /* Sort an array of overlays by priority. The array is modified in place.
2871 The return value is the new size; this may be smaller than the original
2872 size if some of the overlays were invalid or were window-specific. */
2874 sort_overlays (Lisp_Object
*overlay_vec
, int noverlays
, struct window
*w
)
2877 struct sortvec
*sortvec
;
2878 sortvec
= (struct sortvec
*) alloca (noverlays
* sizeof (struct sortvec
));
2880 /* Put the valid and relevant overlays into sortvec. */
2882 for (i
= 0, j
= 0; i
< noverlays
; i
++)
2885 Lisp_Object overlay
;
2887 overlay
= overlay_vec
[i
];
2888 if (OVERLAY_VALID (overlay
)
2889 && OVERLAY_POSITION (OVERLAY_START (overlay
)) > 0
2890 && OVERLAY_POSITION (OVERLAY_END (overlay
)) > 0)
2892 /* If we're interested in a specific window, then ignore
2893 overlays that are limited to some other window. */
2898 window
= Foverlay_get (overlay
, Qwindow
);
2899 if (WINDOWP (window
) && XWINDOW (window
) != w
)
2903 /* This overlay is good and counts: put it into sortvec. */
2904 sortvec
[j
].overlay
= overlay
;
2905 sortvec
[j
].beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2906 sortvec
[j
].end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2907 tem
= Foverlay_get (overlay
, Qpriority
);
2909 sortvec
[j
].priority
= XINT (tem
);
2911 sortvec
[j
].priority
= 0;
2917 /* Sort the overlays into the proper order: increasing priority. */
2920 qsort (sortvec
, noverlays
, sizeof (struct sortvec
), compare_overlays
);
2922 for (i
= 0; i
< noverlays
; i
++)
2923 overlay_vec
[i
] = sortvec
[i
].overlay
;
2929 Lisp_Object string
, string2
;
2936 struct sortstr
*buf
; /* An array that expands as needed; never freed. */
2937 int size
; /* Allocated length of that array. */
2938 int used
; /* How much of the array is currently in use. */
2939 EMACS_INT bytes
; /* Total length of the strings in buf. */
2942 /* Buffers for storing information about the overlays touching a given
2943 position. These could be automatic variables in overlay_strings, but
2944 it's more efficient to hold onto the memory instead of repeatedly
2945 allocating and freeing it. */
2946 static struct sortstrlist overlay_heads
, overlay_tails
;
2947 static unsigned char *overlay_str_buf
;
2949 /* Allocated length of overlay_str_buf. */
2950 static EMACS_INT overlay_str_len
;
2952 /* A comparison function suitable for passing to qsort. */
2954 cmp_for_strings (const void *as1
, const void *as2
)
2956 struct sortstr
*s1
= (struct sortstr
*)as1
;
2957 struct sortstr
*s2
= (struct sortstr
*)as2
;
2958 if (s1
->size
!= s2
->size
)
2959 return s2
->size
- s1
->size
;
2960 if (s1
->priority
!= s2
->priority
)
2961 return s1
->priority
- s2
->priority
;
2966 record_overlay_string (struct sortstrlist
*ssl
, Lisp_Object str
, Lisp_Object str2
, Lisp_Object pri
, int size
)
2970 if (ssl
->used
== ssl
->size
)
2976 ssl
->buf
= ((struct sortstr
*)
2977 xrealloc (ssl
->buf
, ssl
->size
* sizeof (struct sortstr
)));
2979 ssl
->buf
[ssl
->used
].string
= str
;
2980 ssl
->buf
[ssl
->used
].string2
= str2
;
2981 ssl
->buf
[ssl
->used
].size
= size
;
2982 ssl
->buf
[ssl
->used
].priority
= (INTEGERP (pri
) ? XINT (pri
) : 0);
2985 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
2986 nbytes
= SCHARS (str
);
2987 else if (! STRING_MULTIBYTE (str
))
2988 nbytes
= count_size_as_multibyte (SDATA (str
),
2991 nbytes
= SBYTES (str
);
2993 ssl
->bytes
+= nbytes
;
2997 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
2998 nbytes
= SCHARS (str2
);
2999 else if (! STRING_MULTIBYTE (str2
))
3000 nbytes
= count_size_as_multibyte (SDATA (str2
),
3003 nbytes
= SBYTES (str2
);
3005 ssl
->bytes
+= nbytes
;
3009 /* Return the concatenation of the strings associated with overlays that
3010 begin or end at POS, ignoring overlays that are specific to a window
3011 other than W. The strings are concatenated in the appropriate order:
3012 shorter overlays nest inside longer ones, and higher priority inside
3013 lower. Normally all of the after-strings come first, but zero-sized
3014 overlays have their after-strings ride along with the before-strings
3015 because it would look strange to print them inside-out.
3017 Returns the string length, and stores the contents indirectly through
3018 PSTR, if that variable is non-null. The string may be overwritten by
3019 subsequent calls. */
3022 overlay_strings (EMACS_INT pos
, struct window
*w
, unsigned char **pstr
)
3024 Lisp_Object overlay
, window
, str
;
3025 struct Lisp_Overlay
*ov
;
3026 EMACS_INT startpos
, endpos
;
3027 int multibyte
= ! NILP (BVAR (current_buffer
, enable_multibyte_characters
));
3029 overlay_heads
.used
= overlay_heads
.bytes
= 0;
3030 overlay_tails
.used
= overlay_tails
.bytes
= 0;
3031 for (ov
= current_buffer
->overlays_before
; ov
; ov
= ov
->next
)
3033 XSETMISC (overlay
, ov
);
3034 eassert (OVERLAYP (overlay
));
3036 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3037 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3040 if (endpos
!= pos
&& startpos
!= pos
)
3042 window
= Foverlay_get (overlay
, Qwindow
);
3043 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3046 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3047 record_overlay_string (&overlay_heads
, str
,
3049 ? Foverlay_get (overlay
, Qafter_string
)
3051 Foverlay_get (overlay
, Qpriority
),
3053 else if (endpos
== pos
3054 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3055 record_overlay_string (&overlay_tails
, str
, Qnil
,
3056 Foverlay_get (overlay
, Qpriority
),
3059 for (ov
= current_buffer
->overlays_after
; ov
; ov
= ov
->next
)
3061 XSETMISC (overlay
, ov
);
3062 eassert (OVERLAYP (overlay
));
3064 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3065 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3068 if (endpos
!= pos
&& startpos
!= pos
)
3070 window
= Foverlay_get (overlay
, Qwindow
);
3071 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3074 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3075 record_overlay_string (&overlay_heads
, str
,
3077 ? Foverlay_get (overlay
, Qafter_string
)
3079 Foverlay_get (overlay
, Qpriority
),
3081 else if (endpos
== pos
3082 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3083 record_overlay_string (&overlay_tails
, str
, Qnil
,
3084 Foverlay_get (overlay
, Qpriority
),
3087 if (overlay_tails
.used
> 1)
3088 qsort (overlay_tails
.buf
, overlay_tails
.used
, sizeof (struct sortstr
),
3090 if (overlay_heads
.used
> 1)
3091 qsort (overlay_heads
.buf
, overlay_heads
.used
, sizeof (struct sortstr
),
3093 if (overlay_heads
.bytes
|| overlay_tails
.bytes
)
3098 EMACS_INT total
= overlay_heads
.bytes
+ overlay_tails
.bytes
;
3100 if (total
> overlay_str_len
)
3102 overlay_str_len
= total
;
3103 overlay_str_buf
= (unsigned char *)xrealloc (overlay_str_buf
,
3106 p
= overlay_str_buf
;
3107 for (i
= overlay_tails
.used
; --i
>= 0;)
3110 tem
= overlay_tails
.buf
[i
].string
;
3111 nbytes
= copy_text (SDATA (tem
), p
,
3113 STRING_MULTIBYTE (tem
), multibyte
);
3116 for (i
= 0; i
< overlay_heads
.used
; ++i
)
3119 tem
= overlay_heads
.buf
[i
].string
;
3120 nbytes
= copy_text (SDATA (tem
), p
,
3122 STRING_MULTIBYTE (tem
), multibyte
);
3124 tem
= overlay_heads
.buf
[i
].string2
;
3127 nbytes
= copy_text (SDATA (tem
), p
,
3129 STRING_MULTIBYTE (tem
), multibyte
);
3133 if (p
!= overlay_str_buf
+ total
)
3136 *pstr
= overlay_str_buf
;
3142 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
3145 recenter_overlay_lists (struct buffer
*buf
, EMACS_INT pos
)
3147 Lisp_Object overlay
, beg
, end
;
3148 struct Lisp_Overlay
*prev
, *tail
, *next
;
3150 /* See if anything in overlays_before should move to overlays_after. */
3152 /* We don't strictly need prev in this loop; it should always be nil.
3153 But we use it for symmetry and in case that should cease to be true
3154 with some future change. */
3156 for (tail
= buf
->overlays_before
; tail
; prev
= tail
, tail
= next
)
3159 XSETMISC (overlay
, tail
);
3161 /* If the overlay is not valid, get rid of it. */
3162 if (!OVERLAY_VALID (overlay
))
3167 /* Splice the cons cell TAIL out of overlays_before. */
3171 buf
->overlays_before
= next
;
3177 beg
= OVERLAY_START (overlay
);
3178 end
= OVERLAY_END (overlay
);
3180 if (OVERLAY_POSITION (end
) > pos
)
3182 /* OVERLAY needs to be moved. */
3183 EMACS_INT where
= OVERLAY_POSITION (beg
);
3184 struct Lisp_Overlay
*other
, *other_prev
;
3186 /* Splice the cons cell TAIL out of overlays_before. */
3190 buf
->overlays_before
= next
;
3192 /* Search thru overlays_after for where to put it. */
3194 for (other
= buf
->overlays_after
; other
;
3195 other_prev
= other
, other
= other
->next
)
3197 Lisp_Object otherbeg
, otheroverlay
;
3199 XSETMISC (otheroverlay
, other
);
3200 eassert (OVERLAY_VALID (otheroverlay
));
3202 otherbeg
= OVERLAY_START (otheroverlay
);
3203 if (OVERLAY_POSITION (otherbeg
) >= where
)
3207 /* Add TAIL to overlays_after before OTHER. */
3210 other_prev
->next
= tail
;
3212 buf
->overlays_after
= tail
;
3216 /* We've reached the things that should stay in overlays_before.
3217 All the rest of overlays_before must end even earlier,
3222 /* See if anything in overlays_after should be in overlays_before. */
3224 for (tail
= buf
->overlays_after
; tail
; prev
= tail
, tail
= next
)
3227 XSETMISC (overlay
, tail
);
3229 /* If the overlay is not valid, get rid of it. */
3230 if (!OVERLAY_VALID (overlay
))
3235 /* Splice the cons cell TAIL out of overlays_after. */
3239 buf
->overlays_after
= next
;
3245 beg
= OVERLAY_START (overlay
);
3246 end
= OVERLAY_END (overlay
);
3248 /* Stop looking, when we know that nothing further
3249 can possibly end before POS. */
3250 if (OVERLAY_POSITION (beg
) > pos
)
3253 if (OVERLAY_POSITION (end
) <= pos
)
3255 /* OVERLAY needs to be moved. */
3256 EMACS_INT where
= OVERLAY_POSITION (end
);
3257 struct Lisp_Overlay
*other
, *other_prev
;
3259 /* Splice the cons cell TAIL out of overlays_after. */
3263 buf
->overlays_after
= next
;
3265 /* Search thru overlays_before for where to put it. */
3267 for (other
= buf
->overlays_before
; other
;
3268 other_prev
= other
, other
= other
->next
)
3270 Lisp_Object otherend
, otheroverlay
;
3272 XSETMISC (otheroverlay
, other
);
3273 eassert (OVERLAY_VALID (otheroverlay
));
3275 otherend
= OVERLAY_END (otheroverlay
);
3276 if (OVERLAY_POSITION (otherend
) <= where
)
3280 /* Add TAIL to overlays_before before OTHER. */
3283 other_prev
->next
= tail
;
3285 buf
->overlays_before
= tail
;
3290 buf
->overlay_center
= pos
;
3294 adjust_overlays_for_insert (EMACS_INT pos
, EMACS_INT length
)
3296 /* After an insertion, the lists are still sorted properly,
3297 but we may need to update the value of the overlay center. */
3298 if (current_buffer
->overlay_center
>= pos
)
3299 current_buffer
->overlay_center
+= length
;
3303 adjust_overlays_for_delete (EMACS_INT pos
, EMACS_INT length
)
3305 if (current_buffer
->overlay_center
< pos
)
3306 /* The deletion was to our right. No change needed; the before- and
3307 after-lists are still consistent. */
3309 else if (current_buffer
->overlay_center
> pos
+ length
)
3310 /* The deletion was to our left. We need to adjust the center value
3311 to account for the change in position, but the lists are consistent
3312 given the new value. */
3313 current_buffer
->overlay_center
-= length
;
3315 /* We're right in the middle. There might be things on the after-list
3316 that now belong on the before-list. Recentering will move them,
3317 and also update the center point. */
3318 recenter_overlay_lists (current_buffer
, pos
);
3321 /* Fix up overlays that were garbled as a result of permuting markers
3322 in the range START through END. Any overlay with at least one
3323 endpoint in this range will need to be unlinked from the overlay
3324 list and reinserted in its proper place.
3325 Such an overlay might even have negative size at this point.
3326 If so, we'll make the overlay empty. */
3328 fix_start_end_in_overlays (register EMACS_INT start
, register EMACS_INT end
)
3330 Lisp_Object overlay
;
3331 struct Lisp_Overlay
*before_list
IF_LINT (= NULL
);
3332 struct Lisp_Overlay
*after_list
IF_LINT (= NULL
);
3333 /* These are either nil, indicating that before_list or after_list
3334 should be assigned, or the cons cell the cdr of which should be
3336 struct Lisp_Overlay
*beforep
= NULL
, *afterp
= NULL
;
3337 /* 'Parent', likewise, indicates a cons cell or
3338 current_buffer->overlays_before or overlays_after, depending
3339 which loop we're in. */
3340 struct Lisp_Overlay
*tail
, *parent
;
3341 EMACS_INT startpos
, endpos
;
3343 /* This algorithm shifts links around instead of consing and GCing.
3344 The loop invariant is that before_list (resp. after_list) is a
3345 well-formed list except that its last element, the CDR of beforep
3346 (resp. afterp) if beforep (afterp) isn't nil or before_list
3347 (after_list) if it is, is still uninitialized. So it's not a bug
3348 that before_list isn't initialized, although it may look
3350 for (parent
= NULL
, tail
= current_buffer
->overlays_before
; tail
;)
3352 XSETMISC (overlay
, tail
);
3354 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3355 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3357 /* If the overlay is backwards, make it empty. */
3358 if (endpos
< startpos
)
3361 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3369 || (startpos
>= start
&& startpos
< end
))
3371 /* Add it to the end of the wrong list. Later on,
3372 recenter_overlay_lists will move it to the right place. */
3373 if (endpos
< current_buffer
->overlay_center
)
3378 afterp
->next
= tail
;
3386 beforep
->next
= tail
;
3390 current_buffer
->overlays_before
= tail
->next
;
3392 parent
->next
= tail
->next
;
3396 parent
= tail
, tail
= parent
->next
;
3398 for (parent
= NULL
, tail
= current_buffer
->overlays_after
; tail
;)
3400 XSETMISC (overlay
, tail
);
3402 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3403 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3405 /* If the overlay is backwards, make it empty. */
3406 if (endpos
< startpos
)
3409 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3413 if (startpos
>= end
)
3416 if (startpos
>= start
3417 || (endpos
>= start
&& endpos
< end
))
3419 if (endpos
< current_buffer
->overlay_center
)
3424 afterp
->next
= tail
;
3432 beforep
->next
= tail
;
3436 current_buffer
->overlays_after
= tail
->next
;
3438 parent
->next
= tail
->next
;
3442 parent
= tail
, tail
= parent
->next
;
3445 /* Splice the constructed (wrong) lists into the buffer's lists,
3446 and let the recenter function make it sane again. */
3449 beforep
->next
= current_buffer
->overlays_before
;
3450 current_buffer
->overlays_before
= before_list
;
3452 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3456 afterp
->next
= current_buffer
->overlays_after
;
3457 current_buffer
->overlays_after
= after_list
;
3459 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3462 /* We have two types of overlay: the one whose ending marker is
3463 after-insertion-marker (this is the usual case) and the one whose
3464 ending marker is before-insertion-marker. When `overlays_before'
3465 contains overlays of the latter type and the former type in this
3466 order and both overlays end at inserting position, inserting a text
3467 increases only the ending marker of the latter type, which results
3468 in incorrect ordering of `overlays_before'.
3470 This function fixes ordering of overlays in the slot
3471 `overlays_before' of the buffer *BP. Before the insertion, `point'
3472 was at PREV, and now is at POS. */
3475 fix_overlays_before (struct buffer
*bp
, EMACS_INT prev
, EMACS_INT pos
)
3477 /* If parent is nil, replace overlays_before; otherwise, parent->next. */
3478 struct Lisp_Overlay
*tail
= bp
->overlays_before
, *parent
= NULL
, *right_pair
;
3480 EMACS_INT end
IF_LINT (= 0);
3482 /* After the insertion, the several overlays may be in incorrect
3483 order. The possibility is that, in the list `overlays_before',
3484 an overlay which ends at POS appears after an overlay which ends
3485 at PREV. Since POS is greater than PREV, we must fix the
3486 ordering of these overlays, by moving overlays ends at POS before
3487 the overlays ends at PREV. */
3489 /* At first, find a place where disordered overlays should be linked
3490 in. It is where an overlay which end before POS exists. (i.e. an
3491 overlay whose ending marker is after-insertion-marker if disorder
3494 && (XSETMISC (tem
, tail
),
3495 (end
= OVERLAY_POSITION (OVERLAY_END (tem
))) >= pos
))
3501 /* If we don't find such an overlay,
3502 or the found one ends before PREV,
3503 or the found one is the last one in the list,
3504 we don't have to fix anything. */
3505 if (!tail
|| end
< prev
|| !tail
->next
)
3508 right_pair
= parent
;
3512 /* Now, end position of overlays in the list TAIL should be before
3513 or equal to PREV. In the loop, an overlay which ends at POS is
3514 moved ahead to the place indicated by the CDR of RIGHT_PAIR. If
3515 we found an overlay which ends before PREV, the remaining
3516 overlays are in correct order. */
3519 XSETMISC (tem
, tail
);
3520 end
= OVERLAY_POSITION (OVERLAY_END (tem
));
3523 { /* This overlay is disordered. */
3524 struct Lisp_Overlay
*found
= tail
;
3526 /* Unlink the found overlay. */
3528 parent
->next
= tail
;
3529 /* Move an overlay at RIGHT_PLACE to the next of the found one,
3530 and link it into the right place. */
3533 found
->next
= bp
->overlays_before
;
3534 bp
->overlays_before
= found
;
3538 found
->next
= right_pair
->next
;
3539 right_pair
->next
= found
;
3542 else if (end
== prev
)
3547 else /* No more disordered overlay. */
3552 DEFUN ("overlayp", Foverlayp
, Soverlayp
, 1, 1, 0,
3553 doc
: /* Return t if OBJECT is an overlay. */)
3554 (Lisp_Object object
)
3556 return (OVERLAYP (object
) ? Qt
: Qnil
);
3559 DEFUN ("make-overlay", Fmake_overlay
, Smake_overlay
, 2, 5, 0,
3560 doc
: /* Create a new overlay with range BEG to END in BUFFER.
3561 If omitted, BUFFER defaults to the current buffer.
3562 BEG and END may be integers or markers.
3563 The fourth arg FRONT-ADVANCE, if non-nil, makes the marker
3564 for the front of the overlay advance when text is inserted there
3565 \(which means the text *is not* included in the overlay).
3566 The fifth arg REAR-ADVANCE, if non-nil, makes the marker
3567 for the rear of the overlay advance when text is inserted there
3568 \(which means the text *is* included in the overlay). */)
3569 (Lisp_Object beg
, Lisp_Object end
, Lisp_Object buffer
, Lisp_Object front_advance
, Lisp_Object rear_advance
)
3571 Lisp_Object overlay
;
3575 XSETBUFFER (buffer
, current_buffer
);
3577 CHECK_BUFFER (buffer
);
3579 && ! EQ (Fmarker_buffer (beg
), buffer
))
3580 error ("Marker points into wrong buffer");
3582 && ! EQ (Fmarker_buffer (end
), buffer
))
3583 error ("Marker points into wrong buffer");
3585 CHECK_NUMBER_COERCE_MARKER (beg
);
3586 CHECK_NUMBER_COERCE_MARKER (end
);
3588 if (XINT (beg
) > XINT (end
))
3591 temp
= beg
; beg
= end
; end
= temp
;
3594 b
= XBUFFER (buffer
);
3596 beg
= Fset_marker (Fmake_marker (), beg
, buffer
);
3597 end
= Fset_marker (Fmake_marker (), end
, buffer
);
3599 if (!NILP (front_advance
))
3600 XMARKER (beg
)->insertion_type
= 1;
3601 if (!NILP (rear_advance
))
3602 XMARKER (end
)->insertion_type
= 1;
3604 overlay
= allocate_misc ();
3605 XMISCTYPE (overlay
) = Lisp_Misc_Overlay
;
3606 XOVERLAY (overlay
)->start
= beg
;
3607 XOVERLAY (overlay
)->end
= end
;
3608 XOVERLAY (overlay
)->plist
= Qnil
;
3609 XOVERLAY (overlay
)->next
= NULL
;
3611 /* Put the new overlay on the wrong list. */
3612 end
= OVERLAY_END (overlay
);
3613 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
3615 if (b
->overlays_after
)
3616 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3617 b
->overlays_after
= XOVERLAY (overlay
);
3621 if (b
->overlays_before
)
3622 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3623 b
->overlays_before
= XOVERLAY (overlay
);
3626 /* This puts it in the right list, and in the right order. */
3627 recenter_overlay_lists (b
, b
->overlay_center
);
3629 /* We don't need to redisplay the region covered by the overlay, because
3630 the overlay has no properties at the moment. */
3635 /* Mark a section of BUF as needing redisplay because of overlays changes. */
3638 modify_overlay (struct buffer
*buf
, EMACS_INT start
, EMACS_INT end
)
3642 EMACS_INT temp
= start
;
3647 BUF_COMPUTE_UNCHANGED (buf
, start
, end
);
3649 /* If this is a buffer not in the selected window,
3650 we must do other windows. */
3651 if (buf
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
3652 windows_or_buffers_changed
= 1;
3653 /* If multiple windows show this buffer, we must do other windows. */
3654 else if (buffer_shared
> 1)
3655 windows_or_buffers_changed
= 1;
3656 /* If we modify an overlay at the end of the buffer, we cannot
3657 be sure that window end is still valid. */
3658 else if (end
>= ZV
&& start
<= ZV
)
3659 windows_or_buffers_changed
= 1;
3661 ++BUF_OVERLAY_MODIFF (buf
);
3665 static struct Lisp_Overlay
*
3666 unchain_overlay (struct Lisp_Overlay
*list
, struct Lisp_Overlay
*overlay
)
3668 struct Lisp_Overlay
*tmp
, *prev
;
3669 for (tmp
= list
, prev
= NULL
; tmp
; prev
= tmp
, tmp
= tmp
->next
)
3673 prev
->next
= tmp
->next
;
3676 overlay
->next
= NULL
;
3682 DEFUN ("move-overlay", Fmove_overlay
, Smove_overlay
, 3, 4, 0,
3683 doc
: /* Set the endpoints of OVERLAY to BEG and END in BUFFER.
3684 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.
3685 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current
3687 (Lisp_Object overlay
, Lisp_Object beg
, Lisp_Object end
, Lisp_Object buffer
)
3689 struct buffer
*b
, *ob
;
3690 Lisp_Object obuffer
;
3691 int count
= SPECPDL_INDEX ();
3693 CHECK_OVERLAY (overlay
);
3695 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3697 XSETBUFFER (buffer
, current_buffer
);
3698 CHECK_BUFFER (buffer
);
3701 && ! EQ (Fmarker_buffer (beg
), buffer
))
3702 error ("Marker points into wrong buffer");
3704 && ! EQ (Fmarker_buffer (end
), buffer
))
3705 error ("Marker points into wrong buffer");
3707 CHECK_NUMBER_COERCE_MARKER (beg
);
3708 CHECK_NUMBER_COERCE_MARKER (end
);
3710 if (XINT (beg
) == XINT (end
) && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
3711 return Fdelete_overlay (overlay
);
3713 if (XINT (beg
) > XINT (end
))
3716 temp
= beg
; beg
= end
; end
= temp
;
3719 specbind (Qinhibit_quit
, Qt
);
3721 obuffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3722 b
= XBUFFER (buffer
);
3723 ob
= BUFFERP (obuffer
) ? XBUFFER (obuffer
) : (struct buffer
*) 0;
3725 /* If the overlay has changed buffers, do a thorough redisplay. */
3726 if (!EQ (buffer
, obuffer
))
3728 /* Redisplay where the overlay was. */
3729 if (!NILP (obuffer
))
3734 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3735 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3737 modify_overlay (ob
, o_beg
, o_end
);
3740 /* Redisplay where the overlay is going to be. */
3741 modify_overlay (b
, XINT (beg
), XINT (end
));
3744 /* Redisplay the area the overlay has just left, or just enclosed. */
3746 EMACS_INT o_beg
, o_end
;
3748 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3749 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3751 if (o_beg
== XINT (beg
))
3752 modify_overlay (b
, o_end
, XINT (end
));
3753 else if (o_end
== XINT (end
))
3754 modify_overlay (b
, o_beg
, XINT (beg
));
3757 if (XINT (beg
) < o_beg
) o_beg
= XINT (beg
);
3758 if (XINT (end
) > o_end
) o_end
= XINT (end
);
3759 modify_overlay (b
, o_beg
, o_end
);
3763 if (!NILP (obuffer
))
3766 = unchain_overlay (ob
->overlays_before
, XOVERLAY (overlay
));
3768 = unchain_overlay (ob
->overlays_after
, XOVERLAY (overlay
));
3769 eassert (XOVERLAY (overlay
)->next
== NULL
);
3772 Fset_marker (OVERLAY_START (overlay
), beg
, buffer
);
3773 Fset_marker (OVERLAY_END (overlay
), end
, buffer
);
3775 /* Put the overlay on the wrong list. */
3776 end
= OVERLAY_END (overlay
);
3777 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
3779 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3780 b
->overlays_after
= XOVERLAY (overlay
);
3784 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3785 b
->overlays_before
= XOVERLAY (overlay
);
3788 /* This puts it in the right list, and in the right order. */
3789 recenter_overlay_lists (b
, b
->overlay_center
);
3791 return unbind_to (count
, overlay
);
3794 DEFUN ("delete-overlay", Fdelete_overlay
, Sdelete_overlay
, 1, 1, 0,
3795 doc
: /* Delete the overlay OVERLAY from its buffer. */)
3796 (Lisp_Object overlay
)
3800 int count
= SPECPDL_INDEX ();
3802 CHECK_OVERLAY (overlay
);
3804 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3808 b
= XBUFFER (buffer
);
3809 specbind (Qinhibit_quit
, Qt
);
3811 b
->overlays_before
= unchain_overlay (b
->overlays_before
,XOVERLAY (overlay
));
3812 b
->overlays_after
= unchain_overlay (b
->overlays_after
, XOVERLAY (overlay
));
3813 eassert (XOVERLAY (overlay
)->next
== NULL
);
3815 marker_position (OVERLAY_START (overlay
)),
3816 marker_position (OVERLAY_END (overlay
)));
3817 Fset_marker (OVERLAY_START (overlay
), Qnil
, Qnil
);
3818 Fset_marker (OVERLAY_END (overlay
), Qnil
, Qnil
);
3820 /* When deleting an overlay with before or after strings, turn off
3821 display optimizations for the affected buffer, on the basis that
3822 these strings may contain newlines. This is easier to do than to
3823 check for that situation during redisplay. */
3824 if (!windows_or_buffers_changed
3825 && (!NILP (Foverlay_get (overlay
, Qbefore_string
))
3826 || !NILP (Foverlay_get (overlay
, Qafter_string
))))
3827 b
->prevent_redisplay_optimizations_p
= 1;
3829 return unbind_to (count
, Qnil
);
3832 /* Overlay dissection functions. */
3834 DEFUN ("overlay-start", Foverlay_start
, Soverlay_start
, 1, 1, 0,
3835 doc
: /* Return the position at which OVERLAY starts. */)
3836 (Lisp_Object overlay
)
3838 CHECK_OVERLAY (overlay
);
3840 return (Fmarker_position (OVERLAY_START (overlay
)));
3843 DEFUN ("overlay-end", Foverlay_end
, Soverlay_end
, 1, 1, 0,
3844 doc
: /* Return the position at which OVERLAY ends. */)
3845 (Lisp_Object overlay
)
3847 CHECK_OVERLAY (overlay
);
3849 return (Fmarker_position (OVERLAY_END (overlay
)));
3852 DEFUN ("overlay-buffer", Foverlay_buffer
, Soverlay_buffer
, 1, 1, 0,
3853 doc
: /* Return the buffer OVERLAY belongs to.
3854 Return nil if OVERLAY has been deleted. */)
3855 (Lisp_Object overlay
)
3857 CHECK_OVERLAY (overlay
);
3859 return Fmarker_buffer (OVERLAY_START (overlay
));
3862 DEFUN ("overlay-properties", Foverlay_properties
, Soverlay_properties
, 1, 1, 0,
3863 doc
: /* Return a list of the properties on OVERLAY.
3864 This is a copy of OVERLAY's plist; modifying its conses has no effect on
3866 (Lisp_Object overlay
)
3868 CHECK_OVERLAY (overlay
);
3870 return Fcopy_sequence (XOVERLAY (overlay
)->plist
);
3874 DEFUN ("overlays-at", Foverlays_at
, Soverlays_at
, 1, 1, 0,
3875 doc
: /* Return a list of the overlays that contain the character at POS. */)
3879 Lisp_Object
*overlay_vec
;
3883 CHECK_NUMBER_COERCE_MARKER (pos
);
3886 /* We can't use alloca here because overlays_at can call xrealloc. */
3887 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3889 /* Put all the overlays we want in a vector in overlay_vec.
3890 Store the length in len. */
3891 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
3892 (EMACS_INT
*) 0, (EMACS_INT
*) 0, 0);
3894 /* Make a list of them all. */
3895 result
= Flist (noverlays
, overlay_vec
);
3897 xfree (overlay_vec
);
3901 DEFUN ("overlays-in", Foverlays_in
, Soverlays_in
, 2, 2, 0,
3902 doc
: /* Return a list of the overlays that overlap the region BEG ... END.
3903 Overlap means that at least one character is contained within the overlay
3904 and also contained within the specified region.
3905 Empty overlays are included in the result if they are located at BEG,
3906 between BEG and END, or at END provided END denotes the position at the
3907 end of the buffer. */)
3908 (Lisp_Object beg
, Lisp_Object end
)
3911 Lisp_Object
*overlay_vec
;
3915 CHECK_NUMBER_COERCE_MARKER (beg
);
3916 CHECK_NUMBER_COERCE_MARKER (end
);
3919 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3921 /* Put all the overlays we want in a vector in overlay_vec.
3922 Store the length in len. */
3923 noverlays
= overlays_in (XINT (beg
), XINT (end
), 1, &overlay_vec
, &len
,
3926 /* Make a list of them all. */
3927 result
= Flist (noverlays
, overlay_vec
);
3929 xfree (overlay_vec
);
3933 DEFUN ("next-overlay-change", Fnext_overlay_change
, Snext_overlay_change
,
3935 doc
: /* Return the next position after POS where an overlay starts or ends.
3936 If there are no overlay boundaries from POS to (point-max),
3937 the value is (point-max). */)
3942 Lisp_Object
*overlay_vec
;
3946 CHECK_NUMBER_COERCE_MARKER (pos
);
3949 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3951 /* Put all the overlays we want in a vector in overlay_vec.
3952 Store the length in len.
3953 endpos gets the position where the next overlay starts. */
3954 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
3955 &endpos
, (EMACS_INT
*) 0, 1);
3957 /* If any of these overlays ends before endpos,
3958 use its ending point instead. */
3959 for (i
= 0; i
< noverlays
; i
++)
3964 oend
= OVERLAY_END (overlay_vec
[i
]);
3965 oendpos
= OVERLAY_POSITION (oend
);
3966 if (oendpos
< endpos
)
3970 xfree (overlay_vec
);
3971 return make_number (endpos
);
3974 DEFUN ("previous-overlay-change", Fprevious_overlay_change
,
3975 Sprevious_overlay_change
, 1, 1, 0,
3976 doc
: /* Return the previous position before POS where an overlay starts or ends.
3977 If there are no overlay boundaries from (point-min) to POS,
3978 the value is (point-min). */)
3982 Lisp_Object
*overlay_vec
;
3985 CHECK_NUMBER_COERCE_MARKER (pos
);
3987 /* At beginning of buffer, we know the answer;
3988 avoid bug subtracting 1 below. */
3989 if (XINT (pos
) == BEGV
)
3993 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3995 /* Put all the overlays we want in a vector in overlay_vec.
3996 Store the length in len.
3997 prevpos gets the position of the previous change. */
3998 overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
3999 (EMACS_INT
*) 0, &prevpos
, 1);
4001 xfree (overlay_vec
);
4002 return make_number (prevpos
);
4005 /* These functions are for debugging overlays. */
4007 DEFUN ("overlay-lists", Foverlay_lists
, Soverlay_lists
, 0, 0, 0,
4008 doc
: /* Return a pair of lists giving all the overlays of the current buffer.
4009 The car has all the overlays before the overlay center;
4010 the cdr has all the overlays after the overlay center.
4011 Recentering overlays moves overlays between these lists.
4012 The lists you get are copies, so that changing them has no effect.
4013 However, the overlays you get are the real objects that the buffer uses. */)
4016 struct Lisp_Overlay
*ol
;
4017 Lisp_Object before
= Qnil
, after
= Qnil
, tmp
;
4018 for (ol
= current_buffer
->overlays_before
; ol
; ol
= ol
->next
)
4021 before
= Fcons (tmp
, before
);
4023 for (ol
= current_buffer
->overlays_after
; ol
; ol
= ol
->next
)
4026 after
= Fcons (tmp
, after
);
4028 return Fcons (Fnreverse (before
), Fnreverse (after
));
4031 DEFUN ("overlay-recenter", Foverlay_recenter
, Soverlay_recenter
, 1, 1, 0,
4032 doc
: /* Recenter the overlays of the current buffer around position POS.
4033 That makes overlay lookup faster for positions near POS (but perhaps slower
4034 for positions far away from POS). */)
4037 CHECK_NUMBER_COERCE_MARKER (pos
);
4039 recenter_overlay_lists (current_buffer
, XINT (pos
));
4043 DEFUN ("overlay-get", Foverlay_get
, Soverlay_get
, 2, 2, 0,
4044 doc
: /* Get the property of overlay OVERLAY with property name PROP. */)
4045 (Lisp_Object overlay
, Lisp_Object prop
)
4047 CHECK_OVERLAY (overlay
);
4048 return lookup_char_property (XOVERLAY (overlay
)->plist
, prop
, 0);
4051 DEFUN ("overlay-put", Foverlay_put
, Soverlay_put
, 3, 3, 0,
4052 doc
: /* Set one property of overlay OVERLAY: give property PROP value VALUE. */)
4053 (Lisp_Object overlay
, Lisp_Object prop
, Lisp_Object value
)
4055 Lisp_Object tail
, buffer
;
4058 CHECK_OVERLAY (overlay
);
4060 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4062 for (tail
= XOVERLAY (overlay
)->plist
;
4063 CONSP (tail
) && CONSP (XCDR (tail
));
4064 tail
= XCDR (XCDR (tail
)))
4065 if (EQ (XCAR (tail
), prop
))
4067 changed
= !EQ (XCAR (XCDR (tail
)), value
);
4068 XSETCAR (XCDR (tail
), value
);
4071 /* It wasn't in the list, so add it to the front. */
4072 changed
= !NILP (value
);
4073 XOVERLAY (overlay
)->plist
4074 = Fcons (prop
, Fcons (value
, XOVERLAY (overlay
)->plist
));
4076 if (! NILP (buffer
))
4079 modify_overlay (XBUFFER (buffer
),
4080 marker_position (OVERLAY_START (overlay
)),
4081 marker_position (OVERLAY_END (overlay
)));
4082 if (EQ (prop
, Qevaporate
) && ! NILP (value
)
4083 && (OVERLAY_POSITION (OVERLAY_START (overlay
))
4084 == OVERLAY_POSITION (OVERLAY_END (overlay
))))
4085 Fdelete_overlay (overlay
);
4091 /* Subroutine of report_overlay_modification. */
4093 /* Lisp vector holding overlay hook functions to call.
4094 Vector elements come in pairs.
4095 Each even-index element is a list of hook functions.
4096 The following odd-index element is the overlay they came from.
4098 Before the buffer change, we fill in this vector
4099 as we call overlay hook functions.
4100 After the buffer change, we get the functions to call from this vector.
4101 This way we always call the same functions before and after the change. */
4102 static Lisp_Object last_overlay_modification_hooks
;
4104 /* Number of elements actually used in last_overlay_modification_hooks. */
4105 static int last_overlay_modification_hooks_used
;
4107 /* Add one functionlist/overlay pair
4108 to the end of last_overlay_modification_hooks. */
4111 add_overlay_mod_hooklist (Lisp_Object functionlist
, Lisp_Object overlay
)
4113 int oldsize
= ASIZE (last_overlay_modification_hooks
);
4115 if (last_overlay_modification_hooks_used
== oldsize
)
4116 last_overlay_modification_hooks
= larger_vector
4117 (last_overlay_modification_hooks
, oldsize
* 2, Qnil
);
4118 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4119 functionlist
); last_overlay_modification_hooks_used
++;
4120 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4121 overlay
); last_overlay_modification_hooks_used
++;
4124 /* Run the modification-hooks of overlays that include
4125 any part of the text in START to END.
4126 If this change is an insertion, also
4127 run the insert-before-hooks of overlay starting at END,
4128 and the insert-after-hooks of overlay ending at START.
4130 This is called both before and after the modification.
4131 AFTER is nonzero when we call after the modification.
4133 ARG1, ARG2, ARG3 are arguments to pass to the hook functions.
4134 When AFTER is nonzero, they are the start position,
4135 the position after the inserted new text,
4136 and the length of deleted or replaced old text. */
4139 report_overlay_modification (Lisp_Object start
, Lisp_Object end
, int after
,
4140 Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
)
4142 Lisp_Object prop
, overlay
;
4143 struct Lisp_Overlay
*tail
;
4144 /* 1 if this change is an insertion. */
4145 int insertion
= (after
? XFASTINT (arg3
) == 0 : EQ (start
, end
));
4146 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4151 /* We used to run the functions as soon as we found them and only register
4152 them in last_overlay_modification_hooks for the purpose of the `after'
4153 case. But running elisp code as we traverse the list of overlays is
4154 painful because the list can be modified by the elisp code so we had to
4155 copy at several places. We now simply do a read-only traversal that
4156 only collects the functions to run and we run them afterwards. It's
4157 simpler, especially since all the code was already there. -stef */
4161 /* We are being called before a change.
4162 Scan the overlays to find the functions to call. */
4163 last_overlay_modification_hooks_used
= 0;
4164 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4166 EMACS_INT startpos
, endpos
;
4167 Lisp_Object ostart
, oend
;
4169 XSETMISC (overlay
, tail
);
4171 ostart
= OVERLAY_START (overlay
);
4172 oend
= OVERLAY_END (overlay
);
4173 endpos
= OVERLAY_POSITION (oend
);
4174 if (XFASTINT (start
) > endpos
)
4176 startpos
= OVERLAY_POSITION (ostart
);
4177 if (insertion
&& (XFASTINT (start
) == startpos
4178 || XFASTINT (end
) == startpos
))
4180 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4182 add_overlay_mod_hooklist (prop
, overlay
);
4184 if (insertion
&& (XFASTINT (start
) == endpos
4185 || XFASTINT (end
) == endpos
))
4187 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4189 add_overlay_mod_hooklist (prop
, overlay
);
4191 /* Test for intersecting intervals. This does the right thing
4192 for both insertion and deletion. */
4193 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4195 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4197 add_overlay_mod_hooklist (prop
, overlay
);
4201 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4203 EMACS_INT startpos
, endpos
;
4204 Lisp_Object ostart
, oend
;
4206 XSETMISC (overlay
, tail
);
4208 ostart
= OVERLAY_START (overlay
);
4209 oend
= OVERLAY_END (overlay
);
4210 startpos
= OVERLAY_POSITION (ostart
);
4211 endpos
= OVERLAY_POSITION (oend
);
4212 if (XFASTINT (end
) < startpos
)
4214 if (insertion
&& (XFASTINT (start
) == startpos
4215 || XFASTINT (end
) == startpos
))
4217 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4219 add_overlay_mod_hooklist (prop
, overlay
);
4221 if (insertion
&& (XFASTINT (start
) == endpos
4222 || XFASTINT (end
) == endpos
))
4224 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4226 add_overlay_mod_hooklist (prop
, overlay
);
4228 /* Test for intersecting intervals. This does the right thing
4229 for both insertion and deletion. */
4230 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4232 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4234 add_overlay_mod_hooklist (prop
, overlay
);
4239 GCPRO4 (overlay
, arg1
, arg2
, arg3
);
4241 /* Call the functions recorded in last_overlay_modification_hooks.
4242 First copy the vector contents, in case some of these hooks
4243 do subsequent modification of the buffer. */
4244 int size
= last_overlay_modification_hooks_used
;
4245 Lisp_Object
*copy
= (Lisp_Object
*) alloca (size
* sizeof (Lisp_Object
));
4248 memcpy (copy
, XVECTOR (last_overlay_modification_hooks
)->contents
,
4249 size
* sizeof (Lisp_Object
));
4251 gcpro1
.nvars
= size
;
4253 for (i
= 0; i
< size
;)
4255 Lisp_Object prop_i
, overlay_i
;
4257 overlay_i
= copy
[i
++];
4258 call_overlay_mod_hooks (prop_i
, overlay_i
, after
, arg1
, arg2
, arg3
);
4265 call_overlay_mod_hooks (Lisp_Object list
, Lisp_Object overlay
, int after
,
4266 Lisp_Object arg1
, Lisp_Object arg2
, Lisp_Object arg3
)
4268 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4270 GCPRO4 (list
, arg1
, arg2
, arg3
);
4272 while (CONSP (list
))
4275 call4 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
);
4277 call5 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
, arg3
);
4283 /* Delete any zero-sized overlays at position POS, if the `evaporate'
4286 evaporate_overlays (EMACS_INT pos
)
4288 Lisp_Object overlay
, hit_list
;
4289 struct Lisp_Overlay
*tail
;
4292 if (pos
<= current_buffer
->overlay_center
)
4293 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4296 XSETMISC (overlay
, tail
);
4297 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4300 if (endpos
== pos
&& OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
4301 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4302 hit_list
= Fcons (overlay
, hit_list
);
4305 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4308 XSETMISC (overlay
, tail
);
4309 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4312 if (startpos
== pos
&& OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
4313 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4314 hit_list
= Fcons (overlay
, hit_list
);
4316 for (; CONSP (hit_list
); hit_list
= XCDR (hit_list
))
4317 Fdelete_overlay (XCAR (hit_list
));
4320 /* Somebody has tried to store a value with an unacceptable type
4321 in the slot with offset OFFSET. */
4324 buffer_slot_type_mismatch (Lisp_Object newval
, int type
)
4326 Lisp_Object predicate
;
4330 case_Lisp_Int
: predicate
= Qintegerp
; break;
4331 case Lisp_String
: predicate
= Qstringp
; break;
4332 case Lisp_Symbol
: predicate
= Qsymbolp
; break;
4336 wrong_type_argument (predicate
, newval
);
4340 /***********************************************************************
4341 Allocation with mmap
4342 ***********************************************************************/
4344 #ifdef USE_MMAP_FOR_BUFFERS
4346 #include <sys/types.h>
4347 #include <sys/mman.h>
4350 #ifdef MAP_ANONYMOUS
4351 #define MAP_ANON MAP_ANONYMOUS
4358 #define MAP_FAILED ((void *) -1)
4370 /* Memory is allocated in regions which are mapped using mmap(2).
4371 The current implementation lets the system select mapped
4372 addresses; we're not using MAP_FIXED in general, except when
4373 trying to enlarge regions.
4375 Each mapped region starts with a mmap_region structure, the user
4376 area starts after that structure, aligned to MEM_ALIGN.
4378 +-----------------------+
4379 | struct mmap_info + |
4381 +-----------------------+
4385 +-----------------------+ */
4389 /* User-specified size. */
4390 size_t nbytes_specified
;
4392 /* Number of bytes mapped */
4393 size_t nbytes_mapped
;
4395 /* Pointer to the location holding the address of the memory
4396 allocated with the mmap'd block. The variable actually points
4397 after this structure. */
4400 /* Next and previous in list of all mmap'd regions. */
4401 struct mmap_region
*next
, *prev
;
4404 /* Doubly-linked list of mmap'd regions. */
4406 static struct mmap_region
*mmap_regions
;
4408 /* File descriptor for mmap. If we don't have anonymous mapping,
4409 /dev/zero will be opened on it. */
4413 /* Temporary storage for mmap_set_vars, see there. */
4415 static struct mmap_region
*mmap_regions_1
;
4416 static int mmap_fd_1
;
4418 /* Page size on this system. */
4420 static int mmap_page_size
;
4422 /* 1 means mmap has been intialized. */
4424 static int mmap_initialized_p
;
4426 /* Value is X rounded up to the next multiple of N. */
4428 #define ROUND(X, N) (((X) + (N) - 1) / (N) * (N))
4430 /* Size of mmap_region structure plus padding. */
4432 #define MMAP_REGION_STRUCT_SIZE \
4433 ROUND (sizeof (struct mmap_region), MEM_ALIGN)
4435 /* Given a pointer P to the start of the user-visible part of a mapped
4436 region, return a pointer to the start of the region. */
4438 #define MMAP_REGION(P) \
4439 ((struct mmap_region *) ((char *) (P) - MMAP_REGION_STRUCT_SIZE))
4441 /* Given a pointer P to the start of a mapped region, return a pointer
4442 to the start of the user-visible part of the region. */
4444 #define MMAP_USER_AREA(P) \
4445 ((POINTER_TYPE *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
4447 #define MEM_ALIGN sizeof (double)
4449 /* Predicate returning true if part of the address range [START .. END]
4450 is currently mapped. Used to prevent overwriting an existing
4453 Default is to conservativly assume the address range is occupied by
4454 something else. This can be overridden by system configuration
4455 files if system-specific means to determine this exists. */
4457 #ifndef MMAP_ALLOCATED_P
4458 #define MMAP_ALLOCATED_P(start, end) 1
4461 /* Function prototypes. */
4463 static int mmap_free_1 (struct mmap_region
*);
4464 static int mmap_enlarge (struct mmap_region
*, int);
4465 static struct mmap_region
*mmap_find (POINTER_TYPE
*, POINTER_TYPE
*);
4466 static POINTER_TYPE
*mmap_alloc (POINTER_TYPE
**, size_t);
4467 static POINTER_TYPE
*mmap_realloc (POINTER_TYPE
**, size_t);
4468 static void mmap_free (POINTER_TYPE
**ptr
);
4469 static void mmap_init (void);
4472 /* Return a region overlapping address range START...END, or null if
4473 none. END is not including, i.e. the last byte in the range
4476 static struct mmap_region
*
4477 mmap_find (start
, end
)
4478 POINTER_TYPE
*start
, *end
;
4480 struct mmap_region
*r
;
4481 char *s
= (char *) start
, *e
= (char *) end
;
4483 for (r
= mmap_regions
; r
; r
= r
->next
)
4485 char *rstart
= (char *) r
;
4486 char *rend
= rstart
+ r
->nbytes_mapped
;
4488 if (/* First byte of range, i.e. START, in this region? */
4489 (s
>= rstart
&& s
< rend
)
4490 /* Last byte of range, i.e. END - 1, in this region? */
4491 || (e
> rstart
&& e
<= rend
)
4492 /* First byte of this region in the range? */
4493 || (rstart
>= s
&& rstart
< e
)
4494 /* Last byte of this region in the range? */
4495 || (rend
> s
&& rend
<= e
))
4503 /* Unmap a region. P is a pointer to the start of the user-araa of
4504 the region. Value is non-zero if successful. */
4508 struct mmap_region
*r
;
4511 r
->next
->prev
= r
->prev
;
4513 r
->prev
->next
= r
->next
;
4515 mmap_regions
= r
->next
;
4517 if (munmap ((POINTER_TYPE
*) r
, r
->nbytes_mapped
) == -1)
4519 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4527 /* Enlarge region R by NPAGES pages. NPAGES < 0 means shrink R.
4528 Value is non-zero if successful. */
4531 mmap_enlarge (r
, npages
)
4532 struct mmap_region
*r
;
4535 char *region_end
= (char *) r
+ r
->nbytes_mapped
;
4541 /* Unmap pages at the end of the region. */
4542 nbytes
= - npages
* mmap_page_size
;
4543 if (munmap (region_end
- nbytes
, nbytes
) == -1)
4544 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4547 r
->nbytes_mapped
-= nbytes
;
4551 else if (npages
> 0)
4553 nbytes
= npages
* mmap_page_size
;
4555 /* Try to map additional pages at the end of the region. We
4556 cannot do this if the address range is already occupied by
4557 something else because mmap deletes any previous mapping.
4558 I'm not sure this is worth doing, let's see. */
4559 if (!MMAP_ALLOCATED_P (region_end
, region_end
+ nbytes
))
4563 p
= mmap (region_end
, nbytes
, PROT_READ
| PROT_WRITE
,
4564 MAP_ANON
| MAP_PRIVATE
| MAP_FIXED
, mmap_fd
, 0);
4565 if (p
== MAP_FAILED
)
4566 ; /* fprintf (stderr, "mmap: %s\n", emacs_strerror (errno)); */
4567 else if (p
!= (POINTER_TYPE
*) region_end
)
4569 /* Kernels are free to choose a different address. In
4570 that case, unmap what we've mapped above; we have
4572 if (munmap (p
, nbytes
) == -1)
4573 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4577 r
->nbytes_mapped
+= nbytes
;
4587 /* Set or reset variables holding references to mapped regions. If
4588 RESTORE_P is zero, set all variables to null. If RESTORE_P is
4589 non-zero, set all variables to the start of the user-areas
4592 This function is called from Fdump_emacs to ensure that the dumped
4593 Emacs doesn't contain references to memory that won't be mapped
4594 when Emacs starts. */
4597 mmap_set_vars (restore_p
)
4600 struct mmap_region
*r
;
4604 mmap_regions
= mmap_regions_1
;
4605 mmap_fd
= mmap_fd_1
;
4606 for (r
= mmap_regions
; r
; r
= r
->next
)
4607 *r
->var
= MMAP_USER_AREA (r
);
4611 for (r
= mmap_regions
; r
; r
= r
->next
)
4613 mmap_regions_1
= mmap_regions
;
4614 mmap_regions
= NULL
;
4615 mmap_fd_1
= mmap_fd
;
4621 /* Allocate a block of storage large enough to hold NBYTES bytes of
4622 data. A pointer to the data is returned in *VAR. VAR is thus the
4623 address of some variable which will use the data area.
4625 The allocation of 0 bytes is valid.
4627 If we can't allocate the necessary memory, set *VAR to null, and
4630 static POINTER_TYPE
*
4631 mmap_alloc (var
, nbytes
)
4640 map
= ROUND (nbytes
+ MMAP_REGION_STRUCT_SIZE
, mmap_page_size
);
4641 p
= mmap (NULL
, map
, PROT_READ
| PROT_WRITE
, MAP_ANON
| MAP_PRIVATE
,
4644 if (p
== MAP_FAILED
)
4646 if (errno
!= ENOMEM
)
4647 fprintf (stderr
, "mmap: %s\n", emacs_strerror (errno
));
4652 struct mmap_region
*r
= (struct mmap_region
*) p
;
4654 r
->nbytes_specified
= nbytes
;
4655 r
->nbytes_mapped
= map
;
4658 r
->next
= mmap_regions
;
4663 p
= MMAP_USER_AREA (p
);
4670 /* Given a pointer at address VAR to data allocated with mmap_alloc,
4671 resize it to size NBYTES. Change *VAR to reflect the new block,
4672 and return this value. If more memory cannot be allocated, then
4673 leave *VAR unchanged, and return null. */
4675 static POINTER_TYPE
*
4676 mmap_realloc (var
, nbytes
)
4680 POINTER_TYPE
*result
;
4685 result
= mmap_alloc (var
, nbytes
);
4686 else if (nbytes
== 0)
4689 result
= mmap_alloc (var
, nbytes
);
4693 struct mmap_region
*r
= MMAP_REGION (*var
);
4694 size_t room
= r
->nbytes_mapped
- MMAP_REGION_STRUCT_SIZE
;
4699 POINTER_TYPE
*old_ptr
= *var
;
4701 /* Try to map additional pages at the end of the region.
4702 If that fails, allocate a new region, copy data
4703 from the old region, then free it. */
4704 if (mmap_enlarge (r
, (ROUND (nbytes
- room
, mmap_page_size
)
4707 r
->nbytes_specified
= nbytes
;
4708 *var
= result
= old_ptr
;
4710 else if (mmap_alloc (var
, nbytes
))
4712 memcpy (*var
, old_ptr
, r
->nbytes_specified
);
4713 mmap_free_1 (MMAP_REGION (old_ptr
));
4715 r
= MMAP_REGION (result
);
4716 r
->nbytes_specified
= nbytes
;
4724 else if (room
- nbytes
>= mmap_page_size
)
4726 /* Shrinking by at least a page. Let's give some
4727 memory back to the system.
4729 The extra parens are to make the division happens first,
4730 on positive values, so we know it will round towards
4732 mmap_enlarge (r
, - ((room
- nbytes
) / mmap_page_size
));
4734 r
->nbytes_specified
= nbytes
;
4738 /* Leave it alone. */
4740 r
->nbytes_specified
= nbytes
;
4748 /* Free a block of relocatable storage whose data is pointed to by
4749 PTR. Store 0 in *PTR to show there's no block allocated. */
4759 mmap_free_1 (MMAP_REGION (*var
));
4765 /* Perform necessary intializations for the use of mmap. */
4771 /* The value of mmap_fd is initially 0 in temacs, and -1
4772 in a dumped Emacs. */
4775 /* No anonymous mmap -- we need the file descriptor. */
4776 mmap_fd
= open ("/dev/zero", O_RDONLY
);
4778 fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno
));
4780 #endif /* MAP_ANON == 0 */
4782 if (mmap_initialized_p
)
4784 mmap_initialized_p
= 1;
4790 mmap_page_size
= getpagesize ();
4793 #endif /* USE_MMAP_FOR_BUFFERS */
4797 /***********************************************************************
4798 Buffer-text Allocation
4799 ***********************************************************************/
4802 extern POINTER_TYPE
*r_alloc (POINTER_TYPE
**, size_t);
4803 extern POINTER_TYPE
*r_re_alloc (POINTER_TYPE
**, size_t);
4804 extern void r_alloc_free (POINTER_TYPE
**ptr
);
4805 #endif /* REL_ALLOC */
4808 /* Allocate NBYTES bytes for buffer B's text buffer. */
4811 alloc_buffer_text (struct buffer
*b
, size_t nbytes
)
4816 #if defined USE_MMAP_FOR_BUFFERS
4817 p
= mmap_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4818 #elif defined REL_ALLOC
4819 p
= r_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4821 p
= xmalloc (nbytes
);
4827 memory_full (nbytes
);
4830 b
->text
->beg
= (unsigned char *) p
;
4834 /* Enlarge buffer B's text buffer by DELTA bytes. DELTA < 0 means
4838 enlarge_buffer_text (struct buffer
*b
, EMACS_INT delta
)
4841 size_t nbytes
= (BUF_Z_BYTE (b
) - BUF_BEG_BYTE (b
) + BUF_GAP_SIZE (b
) + 1
4844 #if defined USE_MMAP_FOR_BUFFERS
4845 p
= mmap_realloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4846 #elif defined REL_ALLOC
4847 p
= r_re_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4849 p
= xrealloc (b
->text
->beg
, nbytes
);
4855 memory_full (nbytes
);
4858 BUF_BEG_ADDR (b
) = (unsigned char *) p
;
4863 /* Free buffer B's text buffer. */
4866 free_buffer_text (struct buffer
*b
)
4870 #if defined USE_MMAP_FOR_BUFFERS
4871 mmap_free ((POINTER_TYPE
**) &b
->text
->beg
);
4872 #elif defined REL_ALLOC
4873 r_alloc_free ((POINTER_TYPE
**) &b
->text
->beg
);
4875 xfree (b
->text
->beg
);
4878 BUF_BEG_ADDR (b
) = NULL
;
4884 /***********************************************************************
4886 ***********************************************************************/
4889 init_buffer_once (void)
4893 memset (buffer_permanent_local_flags
, 0, sizeof buffer_permanent_local_flags
);
4895 /* Make sure all markable slots in buffer_defaults
4896 are initialized reasonably, so mark_buffer won't choke. */
4897 reset_buffer (&buffer_defaults
);
4898 eassert (EQ (BVAR (&buffer_defaults
, name
), make_number (0)));
4899 reset_buffer_local_variables (&buffer_defaults
, 1);
4900 eassert (EQ (BVAR (&buffer_local_symbols
, name
), make_number (0)));
4901 reset_buffer (&buffer_local_symbols
);
4902 reset_buffer_local_variables (&buffer_local_symbols
, 1);
4903 /* Prevent GC from getting confused. */
4904 buffer_defaults
.text
= &buffer_defaults
.own_text
;
4905 buffer_local_symbols
.text
= &buffer_local_symbols
.own_text
;
4906 BUF_INTERVALS (&buffer_defaults
) = 0;
4907 BUF_INTERVALS (&buffer_local_symbols
) = 0;
4908 XSETPVECTYPESIZE (&buffer_defaults
, PVEC_BUFFER
, 0);
4909 XSETBUFFER (Vbuffer_defaults
, &buffer_defaults
);
4910 XSETPVECTYPESIZE (&buffer_local_symbols
, PVEC_BUFFER
, 0);
4911 XSETBUFFER (Vbuffer_local_symbols
, &buffer_local_symbols
);
4913 /* Set up the default values of various buffer slots. */
4914 /* Must do these before making the first buffer! */
4916 /* real setup is done in bindings.el */
4917 BVAR (&buffer_defaults
, mode_line_format
) = make_pure_c_string ("%-");
4918 BVAR (&buffer_defaults
, header_line_format
) = Qnil
;
4919 BVAR (&buffer_defaults
, abbrev_mode
) = Qnil
;
4920 BVAR (&buffer_defaults
, overwrite_mode
) = Qnil
;
4921 BVAR (&buffer_defaults
, case_fold_search
) = Qt
;
4922 BVAR (&buffer_defaults
, auto_fill_function
) = Qnil
;
4923 BVAR (&buffer_defaults
, selective_display
) = Qnil
;
4925 BVAR (&buffer_defaults
, selective_display_ellipses
) = Qt
;
4927 BVAR (&buffer_defaults
, abbrev_table
) = Qnil
;
4928 BVAR (&buffer_defaults
, display_table
) = Qnil
;
4929 BVAR (&buffer_defaults
, undo_list
) = Qnil
;
4930 BVAR (&buffer_defaults
, mark_active
) = Qnil
;
4931 BVAR (&buffer_defaults
, file_format
) = Qnil
;
4932 BVAR (&buffer_defaults
, auto_save_file_format
) = Qt
;
4933 buffer_defaults
.overlays_before
= NULL
;
4934 buffer_defaults
.overlays_after
= NULL
;
4935 buffer_defaults
.overlay_center
= BEG
;
4937 XSETFASTINT (BVAR (&buffer_defaults
, tab_width
), 8);
4938 BVAR (&buffer_defaults
, truncate_lines
) = Qnil
;
4939 BVAR (&buffer_defaults
, word_wrap
) = Qnil
;
4940 BVAR (&buffer_defaults
, ctl_arrow
) = Qt
;
4941 BVAR (&buffer_defaults
, bidi_display_reordering
) = Qnil
;
4942 BVAR (&buffer_defaults
, bidi_paragraph_direction
) = Qnil
;
4943 BVAR (&buffer_defaults
, cursor_type
) = Qt
;
4944 BVAR (&buffer_defaults
, extra_line_spacing
) = Qnil
;
4945 BVAR (&buffer_defaults
, cursor_in_non_selected_windows
) = Qt
;
4947 BVAR (&buffer_defaults
, enable_multibyte_characters
) = Qt
;
4948 BVAR (&buffer_defaults
, buffer_file_coding_system
) = Qnil
;
4949 XSETFASTINT (BVAR (&buffer_defaults
, fill_column
), 70);
4950 XSETFASTINT (BVAR (&buffer_defaults
, left_margin
), 0);
4951 BVAR (&buffer_defaults
, cache_long_line_scans
) = Qnil
;
4952 BVAR (&buffer_defaults
, file_truename
) = Qnil
;
4953 XSETFASTINT (BVAR (&buffer_defaults
, display_count
), 0);
4954 XSETFASTINT (BVAR (&buffer_defaults
, left_margin_cols
), 0);
4955 XSETFASTINT (BVAR (&buffer_defaults
, right_margin_cols
), 0);
4956 BVAR (&buffer_defaults
, left_fringe_width
) = Qnil
;
4957 BVAR (&buffer_defaults
, right_fringe_width
) = Qnil
;
4958 BVAR (&buffer_defaults
, fringes_outside_margins
) = Qnil
;
4959 BVAR (&buffer_defaults
, scroll_bar_width
) = Qnil
;
4960 BVAR (&buffer_defaults
, vertical_scroll_bar_type
) = Qt
;
4961 BVAR (&buffer_defaults
, indicate_empty_lines
) = Qnil
;
4962 BVAR (&buffer_defaults
, indicate_buffer_boundaries
) = Qnil
;
4963 BVAR (&buffer_defaults
, fringe_indicator_alist
) = Qnil
;
4964 BVAR (&buffer_defaults
, fringe_cursor_alist
) = Qnil
;
4965 BVAR (&buffer_defaults
, scroll_up_aggressively
) = Qnil
;
4966 BVAR (&buffer_defaults
, scroll_down_aggressively
) = Qnil
;
4967 BVAR (&buffer_defaults
, display_time
) = Qnil
;
4969 /* Assign the local-flags to the slots that have default values.
4970 The local flag is a bit that is used in the buffer
4971 to say that it has its own local value for the slot.
4972 The local flag bits are in the local_var_flags slot of the buffer. */
4974 /* Nothing can work if this isn't true */
4975 if (sizeof (EMACS_INT
) != sizeof (Lisp_Object
)) abort ();
4977 /* 0 means not a lisp var, -1 means always local, else mask */
4978 memset (&buffer_local_flags
, 0, sizeof buffer_local_flags
);
4979 XSETINT (BVAR (&buffer_local_flags
, filename
), -1);
4980 XSETINT (BVAR (&buffer_local_flags
, directory
), -1);
4981 XSETINT (BVAR (&buffer_local_flags
, backed_up
), -1);
4982 XSETINT (BVAR (&buffer_local_flags
, save_length
), -1);
4983 XSETINT (BVAR (&buffer_local_flags
, auto_save_file_name
), -1);
4984 XSETINT (BVAR (&buffer_local_flags
, read_only
), -1);
4985 XSETINT (BVAR (&buffer_local_flags
, major_mode
), -1);
4986 XSETINT (BVAR (&buffer_local_flags
, mode_name
), -1);
4987 XSETINT (BVAR (&buffer_local_flags
, undo_list
), -1);
4988 XSETINT (BVAR (&buffer_local_flags
, mark_active
), -1);
4989 XSETINT (BVAR (&buffer_local_flags
, point_before_scroll
), -1);
4990 XSETINT (BVAR (&buffer_local_flags
, file_truename
), -1);
4991 XSETINT (BVAR (&buffer_local_flags
, invisibility_spec
), -1);
4992 XSETINT (BVAR (&buffer_local_flags
, file_format
), -1);
4993 XSETINT (BVAR (&buffer_local_flags
, auto_save_file_format
), -1);
4994 XSETINT (BVAR (&buffer_local_flags
, display_count
), -1);
4995 XSETINT (BVAR (&buffer_local_flags
, display_time
), -1);
4996 XSETINT (BVAR (&buffer_local_flags
, enable_multibyte_characters
), -1);
4999 XSETFASTINT (BVAR (&buffer_local_flags
, mode_line_format
), idx
); ++idx
;
5000 XSETFASTINT (BVAR (&buffer_local_flags
, abbrev_mode
), idx
); ++idx
;
5001 XSETFASTINT (BVAR (&buffer_local_flags
, overwrite_mode
), idx
); ++idx
;
5002 XSETFASTINT (BVAR (&buffer_local_flags
, case_fold_search
), idx
); ++idx
;
5003 XSETFASTINT (BVAR (&buffer_local_flags
, auto_fill_function
), idx
); ++idx
;
5004 XSETFASTINT (BVAR (&buffer_local_flags
, selective_display
), idx
); ++idx
;
5006 XSETFASTINT (BVAR (&buffer_local_flags
, selective_display_ellipses
), idx
); ++idx
;
5008 XSETFASTINT (BVAR (&buffer_local_flags
, tab_width
), idx
); ++idx
;
5009 XSETFASTINT (BVAR (&buffer_local_flags
, truncate_lines
), idx
); ++idx
;
5010 XSETFASTINT (BVAR (&buffer_local_flags
, word_wrap
), idx
); ++idx
;
5011 XSETFASTINT (BVAR (&buffer_local_flags
, ctl_arrow
), idx
); ++idx
;
5012 XSETFASTINT (BVAR (&buffer_local_flags
, fill_column
), idx
); ++idx
;
5013 XSETFASTINT (BVAR (&buffer_local_flags
, left_margin
), idx
); ++idx
;
5014 XSETFASTINT (BVAR (&buffer_local_flags
, abbrev_table
), idx
); ++idx
;
5015 XSETFASTINT (BVAR (&buffer_local_flags
, display_table
), idx
); ++idx
;
5016 XSETFASTINT (BVAR (&buffer_local_flags
, syntax_table
), idx
); ++idx
;
5017 XSETFASTINT (BVAR (&buffer_local_flags
, cache_long_line_scans
), idx
); ++idx
;
5018 XSETFASTINT (BVAR (&buffer_local_flags
, category_table
), idx
); ++idx
;
5019 XSETFASTINT (BVAR (&buffer_local_flags
, bidi_display_reordering
), idx
); ++idx
;
5020 XSETFASTINT (BVAR (&buffer_local_flags
, bidi_paragraph_direction
), idx
); ++idx
;
5021 XSETFASTINT (BVAR (&buffer_local_flags
, buffer_file_coding_system
), idx
);
5022 /* Make this one a permanent local. */
5023 buffer_permanent_local_flags
[idx
++] = 1;
5024 XSETFASTINT (BVAR (&buffer_local_flags
, left_margin_cols
), idx
); ++idx
;
5025 XSETFASTINT (BVAR (&buffer_local_flags
, right_margin_cols
), idx
); ++idx
;
5026 XSETFASTINT (BVAR (&buffer_local_flags
, left_fringe_width
), idx
); ++idx
;
5027 XSETFASTINT (BVAR (&buffer_local_flags
, right_fringe_width
), idx
); ++idx
;
5028 XSETFASTINT (BVAR (&buffer_local_flags
, fringes_outside_margins
), idx
); ++idx
;
5029 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_bar_width
), idx
); ++idx
;
5030 XSETFASTINT (BVAR (&buffer_local_flags
, vertical_scroll_bar_type
), idx
); ++idx
;
5031 XSETFASTINT (BVAR (&buffer_local_flags
, indicate_empty_lines
), idx
); ++idx
;
5032 XSETFASTINT (BVAR (&buffer_local_flags
, indicate_buffer_boundaries
), idx
); ++idx
;
5033 XSETFASTINT (BVAR (&buffer_local_flags
, fringe_indicator_alist
), idx
); ++idx
;
5034 XSETFASTINT (BVAR (&buffer_local_flags
, fringe_cursor_alist
), idx
); ++idx
;
5035 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_up_aggressively
), idx
); ++idx
;
5036 XSETFASTINT (BVAR (&buffer_local_flags
, scroll_down_aggressively
), idx
); ++idx
;
5037 XSETFASTINT (BVAR (&buffer_local_flags
, header_line_format
), idx
); ++idx
;
5038 XSETFASTINT (BVAR (&buffer_local_flags
, cursor_type
), idx
); ++idx
;
5039 XSETFASTINT (BVAR (&buffer_local_flags
, extra_line_spacing
), idx
); ++idx
;
5040 XSETFASTINT (BVAR (&buffer_local_flags
, cursor_in_non_selected_windows
), idx
); ++idx
;
5042 /* Need more room? */
5043 if (idx
>= MAX_PER_BUFFER_VARS
)
5045 last_per_buffer_idx
= idx
;
5047 Vbuffer_alist
= Qnil
;
5051 QSFundamental
= make_pure_c_string ("Fundamental");
5053 Qfundamental_mode
= intern_c_string ("fundamental-mode");
5054 BVAR (&buffer_defaults
, major_mode
) = Qfundamental_mode
;
5056 Qmode_class
= intern_c_string ("mode-class");
5058 Qprotected_field
= intern_c_string ("protected-field");
5060 Qpermanent_local
= intern_c_string ("permanent-local");
5062 Qkill_buffer_hook
= intern_c_string ("kill-buffer-hook");
5063 Fput (Qkill_buffer_hook
, Qpermanent_local
, Qt
);
5065 Qucs_set_table_for_input
= intern_c_string ("ucs-set-table-for-input");
5067 /* super-magic invisible buffer */
5068 Vprin1_to_string_buffer
= Fget_buffer_create (make_pure_c_string (" prin1"));
5069 Vbuffer_alist
= Qnil
;
5071 Fset_buffer (Fget_buffer_create (make_pure_c_string ("*scratch*")));
5073 inhibit_modification_hooks
= 0;
5083 #ifdef USE_MMAP_FOR_BUFFERS
5085 /* When using the ralloc implementation based on mmap(2), buffer
5086 text pointers will have been set to null in the dumped Emacs.
5090 for (b
= all_buffers
; b
; b
= b
->header
.next
.buffer
)
5091 if (b
->text
->beg
== NULL
)
5092 enlarge_buffer_text (b
, 0);
5094 #endif /* USE_MMAP_FOR_BUFFERS */
5096 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
5097 if (NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
)))
5098 Fset_buffer_multibyte (Qnil
);
5100 pwd
= get_current_dir_name ();
5103 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5105 /* Maybe this should really use some standard subroutine
5106 whose definition is filename syntax dependent. */
5108 if (!(IS_DIRECTORY_SEP (pwd
[len
- 1])))
5110 /* Grow buffer to add directory separator and '\0'. */
5111 pwd
= (char *) realloc (pwd
, len
+ 2);
5113 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5114 pwd
[len
] = DIRECTORY_SEP
;
5115 pwd
[len
+ 1] = '\0';
5118 BVAR (current_buffer
, directory
) = make_unibyte_string (pwd
, strlen (pwd
));
5119 if (! NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
)))
5120 /* At this moment, we still don't know how to decode the
5121 directory name. So, we keep the bytes in multibyte form so
5122 that ENCODE_FILE correctly gets the original bytes. */
5123 BVAR (current_buffer
, directory
)
5124 = string_to_multibyte (BVAR (current_buffer
, directory
));
5126 /* Add /: to the front of the name
5127 if it would otherwise be treated as magic. */
5128 temp
= Ffind_file_name_handler (BVAR (current_buffer
, directory
), Qt
);
5130 /* If the default dir is just /, TEMP is non-nil
5131 because of the ange-ftp completion handler.
5132 However, it is not necessary to turn / into /:/.
5133 So avoid doing that. */
5134 && strcmp ("/", SSDATA (BVAR (current_buffer
, directory
))))
5135 BVAR (current_buffer
, directory
)
5136 = concat2 (build_string ("/:"), BVAR (current_buffer
, directory
));
5138 temp
= get_minibuffer (0);
5139 BVAR (XBUFFER (temp
), directory
) = BVAR (current_buffer
, directory
);
5144 /* Similar to defvar_lisp but define a variable whose value is the Lisp
5145 Object stored in the current buffer. address is the address of the slot
5146 in the buffer that is current now. */
5148 /* TYPE is nil for a general Lisp variable.
5149 An integer specifies a type; then only Lisp values
5150 with that type code are allowed (except that nil is allowed too).
5151 LNAME is the Lisp-level variable name.
5152 VNAME is the name of the buffer slot.
5153 DOC is a dummy where you write the doc string as a comment. */
5154 #define DEFVAR_PER_BUFFER(lname, vname, type, doc) \
5156 static struct Lisp_Buffer_Objfwd bo_fwd; \
5157 defvar_per_buffer (&bo_fwd, lname, vname, type); \
5161 defvar_per_buffer (struct Lisp_Buffer_Objfwd
*bo_fwd
, const char *namestring
,
5162 Lisp_Object
*address
, Lisp_Object type
)
5164 struct Lisp_Symbol
*sym
;
5167 sym
= XSYMBOL (intern (namestring
));
5168 offset
= (char *)address
- (char *)current_buffer
;
5170 bo_fwd
->type
= Lisp_Fwd_Buffer_Obj
;
5171 bo_fwd
->offset
= offset
;
5172 bo_fwd
->slottype
= type
;
5173 sym
->declared_special
= 1;
5174 sym
->redirect
= SYMBOL_FORWARDED
;
5176 /* I tried to do the job without a cast, but it seems impossible.
5177 union Lisp_Fwd *fwd; &(fwd->u_buffer_objfwd) = bo_fwd; */
5178 SET_SYMBOL_FWD (sym
, (union Lisp_Fwd
*)bo_fwd
);
5180 XSETSYMBOL (PER_BUFFER_SYMBOL (offset
), sym
);
5182 if (PER_BUFFER_IDX (offset
) == 0)
5183 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
5184 slot of buffer_local_flags */
5189 /* initialize the buffer routines */
5191 syms_of_buffer (void)
5193 staticpro (&last_overlay_modification_hooks
);
5194 last_overlay_modification_hooks
5195 = Fmake_vector (make_number (10), Qnil
);
5197 staticpro (&Vbuffer_defaults
);
5198 staticpro (&Vbuffer_local_symbols
);
5199 staticpro (&Qfundamental_mode
);
5200 staticpro (&Qmode_class
);
5201 staticpro (&QSFundamental
);
5202 staticpro (&Vbuffer_alist
);
5203 staticpro (&Qprotected_field
);
5204 staticpro (&Qpermanent_local
);
5205 Qpermanent_local_hook
= intern_c_string ("permanent-local-hook");
5206 staticpro (&Qpermanent_local_hook
);
5207 staticpro (&Qkill_buffer_hook
);
5208 Qoverlayp
= intern_c_string ("overlayp");
5209 staticpro (&Qoverlayp
);
5210 Qevaporate
= intern_c_string ("evaporate");
5211 staticpro (&Qevaporate
);
5212 Qmodification_hooks
= intern_c_string ("modification-hooks");
5213 staticpro (&Qmodification_hooks
);
5214 Qinsert_in_front_hooks
= intern_c_string ("insert-in-front-hooks");
5215 staticpro (&Qinsert_in_front_hooks
);
5216 Qinsert_behind_hooks
= intern_c_string ("insert-behind-hooks");
5217 staticpro (&Qinsert_behind_hooks
);
5218 Qget_file_buffer
= intern_c_string ("get-file-buffer");
5219 staticpro (&Qget_file_buffer
);
5220 Qpriority
= intern_c_string ("priority");
5221 staticpro (&Qpriority
);
5222 Qbefore_string
= intern_c_string ("before-string");
5223 staticpro (&Qbefore_string
);
5224 Qafter_string
= intern_c_string ("after-string");
5225 staticpro (&Qafter_string
);
5226 Qfirst_change_hook
= intern_c_string ("first-change-hook");
5227 staticpro (&Qfirst_change_hook
);
5228 Qbefore_change_functions
= intern_c_string ("before-change-functions");
5229 staticpro (&Qbefore_change_functions
);
5230 Qafter_change_functions
= intern_c_string ("after-change-functions");
5231 staticpro (&Qafter_change_functions
);
5232 /* The next one is initialized in init_buffer_once. */
5233 staticpro (&Qucs_set_table_for_input
);
5235 Qkill_buffer_query_functions
= intern_c_string ("kill-buffer-query-functions");
5236 staticpro (&Qkill_buffer_query_functions
);
5238 Fput (Qprotected_field
, Qerror_conditions
,
5239 pure_cons (Qprotected_field
, pure_cons (Qerror
, Qnil
)));
5240 Fput (Qprotected_field
, Qerror_message
,
5241 make_pure_c_string ("Attempt to modify a protected field"));
5243 DEFVAR_BUFFER_DEFAULTS ("default-mode-line-format",
5245 doc
: /* Default value of `mode-line-format' for buffers that don't override it.
5246 This is the same as (default-value 'mode-line-format). */);
5248 DEFVAR_BUFFER_DEFAULTS ("default-header-line-format",
5250 doc
: /* Default value of `header-line-format' for buffers that don't override it.
5251 This is the same as (default-value 'header-line-format). */);
5253 DEFVAR_BUFFER_DEFAULTS ("default-cursor-type", cursor_type
,
5254 doc
: /* Default value of `cursor-type' for buffers that don't override it.
5255 This is the same as (default-value 'cursor-type). */);
5257 DEFVAR_BUFFER_DEFAULTS ("default-line-spacing",
5259 doc
: /* Default value of `line-spacing' for buffers that don't override it.
5260 This is the same as (default-value 'line-spacing). */);
5262 DEFVAR_BUFFER_DEFAULTS ("default-cursor-in-non-selected-windows",
5263 cursor_in_non_selected_windows
,
5264 doc
: /* Default value of `cursor-in-non-selected-windows'.
5265 This is the same as (default-value 'cursor-in-non-selected-windows). */);
5267 DEFVAR_BUFFER_DEFAULTS ("default-abbrev-mode",
5269 doc
: /* Default value of `abbrev-mode' for buffers that do not override it.
5270 This is the same as (default-value 'abbrev-mode). */);
5272 DEFVAR_BUFFER_DEFAULTS ("default-ctl-arrow",
5274 doc
: /* Default value of `ctl-arrow' for buffers that do not override it.
5275 This is the same as (default-value 'ctl-arrow). */);
5277 DEFVAR_BUFFER_DEFAULTS ("default-enable-multibyte-characters",
5278 enable_multibyte_characters
,
5279 doc
: /* *Default value of `enable-multibyte-characters' for buffers not overriding it.
5280 This is the same as (default-value 'enable-multibyte-characters). */);
5282 DEFVAR_BUFFER_DEFAULTS ("default-buffer-file-coding-system",
5283 buffer_file_coding_system
,
5284 doc
: /* Default value of `buffer-file-coding-system' for buffers not overriding it.
5285 This is the same as (default-value 'buffer-file-coding-system). */);
5287 DEFVAR_BUFFER_DEFAULTS ("default-truncate-lines",
5289 doc
: /* Default value of `truncate-lines' for buffers that do not override it.
5290 This is the same as (default-value 'truncate-lines). */);
5292 DEFVAR_BUFFER_DEFAULTS ("default-fill-column",
5294 doc
: /* Default value of `fill-column' for buffers that do not override it.
5295 This is the same as (default-value 'fill-column). */);
5297 DEFVAR_BUFFER_DEFAULTS ("default-left-margin",
5299 doc
: /* Default value of `left-margin' for buffers that do not override it.
5300 This is the same as (default-value 'left-margin). */);
5302 DEFVAR_BUFFER_DEFAULTS ("default-tab-width",
5304 doc
: /* Default value of `tab-width' for buffers that do not override it.
5305 This is the same as (default-value 'tab-width). */);
5307 DEFVAR_BUFFER_DEFAULTS ("default-case-fold-search",
5309 doc
: /* Default value of `case-fold-search' for buffers that don't override it.
5310 This is the same as (default-value 'case-fold-search). */);
5312 DEFVAR_BUFFER_DEFAULTS ("default-left-margin-width",
5314 doc
: /* Default value of `left-margin-width' for buffers that don't override it.
5315 This is the same as (default-value 'left-margin-width). */);
5317 DEFVAR_BUFFER_DEFAULTS ("default-right-margin-width",
5319 doc
: /* Default value of `right-margin-width' for buffers that don't override it.
5320 This is the same as (default-value 'right-margin-width). */);
5322 DEFVAR_BUFFER_DEFAULTS ("default-left-fringe-width",
5324 doc
: /* Default value of `left-fringe-width' for buffers that don't override it.
5325 This is the same as (default-value 'left-fringe-width). */);
5327 DEFVAR_BUFFER_DEFAULTS ("default-right-fringe-width",
5329 doc
: /* Default value of `right-fringe-width' for buffers that don't override it.
5330 This is the same as (default-value 'right-fringe-width). */);
5332 DEFVAR_BUFFER_DEFAULTS ("default-fringes-outside-margins",
5333 fringes_outside_margins
,
5334 doc
: /* Default value of `fringes-outside-margins' for buffers that don't override it.
5335 This is the same as (default-value 'fringes-outside-margins). */);
5337 DEFVAR_BUFFER_DEFAULTS ("default-scroll-bar-width",
5339 doc
: /* Default value of `scroll-bar-width' for buffers that don't override it.
5340 This is the same as (default-value 'scroll-bar-width). */);
5342 DEFVAR_BUFFER_DEFAULTS ("default-vertical-scroll-bar",
5343 vertical_scroll_bar_type
,
5344 doc
: /* Default value of `vertical-scroll-bar' for buffers that don't override it.
5345 This is the same as (default-value 'vertical-scroll-bar). */);
5347 DEFVAR_BUFFER_DEFAULTS ("default-indicate-empty-lines",
5348 indicate_empty_lines
,
5349 doc
: /* Default value of `indicate-empty-lines' for buffers that don't override it.
5350 This is the same as (default-value 'indicate-empty-lines). */);
5352 DEFVAR_BUFFER_DEFAULTS ("default-indicate-buffer-boundaries",
5353 indicate_buffer_boundaries
,
5354 doc
: /* Default value of `indicate-buffer-boundaries' for buffers that don't override it.
5355 This is the same as (default-value 'indicate-buffer-boundaries). */);
5357 DEFVAR_BUFFER_DEFAULTS ("default-fringe-indicator-alist",
5358 fringe_indicator_alist
,
5359 doc
: /* Default value of `fringe-indicator-alist' for buffers that don't override it.
5360 This is the same as (default-value 'fringe-indicator-alist'). */);
5362 DEFVAR_BUFFER_DEFAULTS ("default-fringe-cursor-alist",
5363 fringe_cursor_alist
,
5364 doc
: /* Default value of `fringe-cursor-alist' for buffers that don't override it.
5365 This is the same as (default-value 'fringe-cursor-alist'). */);
5367 DEFVAR_BUFFER_DEFAULTS ("default-scroll-up-aggressively",
5368 scroll_up_aggressively
,
5369 doc
: /* Default value of `scroll-up-aggressively'.
5370 This value applies in buffers that don't have their own local values.
5371 This is the same as (default-value 'scroll-up-aggressively). */);
5373 DEFVAR_BUFFER_DEFAULTS ("default-scroll-down-aggressively",
5374 scroll_down_aggressively
,
5375 doc
: /* Default value of `scroll-down-aggressively'.
5376 This value applies in buffers that don't have their own local values.
5377 This is the same as (default-value 'scroll-down-aggressively). */);
5379 DEFVAR_PER_BUFFER ("header-line-format",
5380 &BVAR (current_buffer
, header_line_format
),
5382 doc
: /* Analogous to `mode-line-format', but controls the header line.
5383 The header line appears, optionally, at the top of a window;
5384 the mode line appears at the bottom. */);
5386 DEFVAR_PER_BUFFER ("mode-line-format", &BVAR (current_buffer
, mode_line_format
),
5388 doc
: /* Template for displaying mode line for current buffer.
5389 Each buffer has its own value of this variable.
5390 Value may be nil, a string, a symbol or a list or cons cell.
5391 A value of nil means don't display a mode line.
5392 For a symbol, its value is used (but it is ignored if t or nil).
5393 A string appearing directly as the value of a symbol is processed verbatim
5394 in that the %-constructs below are not recognized.
5395 Note that unless the symbol is marked as a `risky-local-variable', all
5396 properties in any strings, as well as all :eval and :propertize forms
5397 in the value of that symbol will be ignored.
5398 For a list of the form `(:eval FORM)', FORM is evaluated and the result
5399 is used as a mode line element. Be careful--FORM should not load any files,
5400 because that can cause an infinite recursion.
5401 For a list of the form `(:propertize ELT PROPS...)', ELT is displayed
5402 with the specified properties PROPS applied.
5403 For a list whose car is a symbol, the symbol's value is taken,
5404 and if that is non-nil, the cadr of the list is processed recursively.
5405 Otherwise, the caddr of the list (if there is one) is processed.
5406 For a list whose car is a string or list, each element is processed
5407 recursively and the results are effectively concatenated.
5408 For a list whose car is an integer, the cdr of the list is processed
5409 and padded (if the number is positive) or truncated (if negative)
5410 to the width specified by that number.
5411 A string is printed verbatim in the mode line except for %-constructs:
5412 (%-constructs are allowed when the string is the entire mode-line-format
5413 or when it is found in a cons-cell or a list)
5414 %b -- print buffer name. %f -- print visited file name.
5415 %F -- print frame name.
5416 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
5417 %& is like %*, but ignore read-only-ness.
5418 % means buffer is read-only and * means it is modified.
5419 For a modified read-only buffer, %* gives % and %+ gives *.
5420 %s -- print process status. %l -- print the current line number.
5421 %c -- print the current column number (this makes editing slower).
5422 To make the column number update correctly in all cases,
5423 `column-number-mode' must be non-nil.
5424 %i -- print the size of the buffer.
5425 %I -- like %i, but use k, M, G, etc., to abbreviate.
5426 %p -- print percent of buffer above top of window, or Top, Bot or All.
5427 %P -- print percent of buffer above bottom of window, perhaps plus Top,
5428 or print Bottom or All.
5429 %n -- print Narrow if appropriate.
5430 %t -- visited file is text or binary (if OS supports this distinction).
5431 %z -- print mnemonics of keyboard, terminal, and buffer coding systems.
5432 %Z -- like %z, but including the end-of-line format.
5433 %e -- print error message about full memory.
5434 %@ -- print @ or hyphen. @ means that default-directory is on a
5436 %[ -- print one [ for each recursive editing level. %] similar.
5437 %% -- print %. %- -- print infinitely many dashes.
5438 Decimal digits after the % specify field width to which to pad. */);
5440 DEFVAR_BUFFER_DEFAULTS ("default-major-mode", major_mode
,
5441 doc
: /* *Value of `major-mode' for new buffers. */);
5443 DEFVAR_PER_BUFFER ("major-mode", &BVAR (current_buffer
, major_mode
),
5444 make_number (Lisp_Symbol
),
5445 doc
: /* Symbol for current buffer's major mode.
5446 The default value (normally `fundamental-mode') affects new buffers.
5447 A value of nil means to use the current buffer's major mode, provided
5448 it is not marked as "special".
5450 When a mode is used by default, `find-file' switches to it before it
5451 reads the contents into the buffer and before it finishes setting up
5452 the buffer. Thus, the mode and its hooks should not expect certain
5453 variables such as `buffer-read-only' and `buffer-file-coding-system'
5456 DEFVAR_PER_BUFFER ("mode-name", &BVAR (current_buffer
, mode_name
),
5458 doc
: /* Pretty name of current buffer's major mode.
5459 Usually a string, but can use any of the constructs for `mode-line-format',
5461 Format with `format-mode-line' to produce a string value. */);
5463 DEFVAR_PER_BUFFER ("local-abbrev-table", &BVAR (current_buffer
, abbrev_table
), Qnil
,
5464 doc
: /* Local (mode-specific) abbrev table of current buffer. */);
5466 DEFVAR_PER_BUFFER ("abbrev-mode", &BVAR (current_buffer
, abbrev_mode
), Qnil
,
5467 doc
: /* Non-nil if Abbrev mode is enabled.
5468 Use the command `abbrev-mode' to change this variable. */);
5470 DEFVAR_PER_BUFFER ("case-fold-search", &BVAR (current_buffer
, case_fold_search
),
5472 doc
: /* *Non-nil if searches and matches should ignore case. */);
5474 DEFVAR_PER_BUFFER ("fill-column", &BVAR (current_buffer
, fill_column
),
5475 make_number (LISP_INT_TAG
),
5476 doc
: /* *Column beyond which automatic line-wrapping should happen.
5477 Interactively, you can set the buffer local value using \\[set-fill-column]. */);
5479 DEFVAR_PER_BUFFER ("left-margin", &BVAR (current_buffer
, left_margin
),
5480 make_number (LISP_INT_TAG
),
5481 doc
: /* *Column for the default `indent-line-function' to indent to.
5482 Linefeed indents to this column in Fundamental mode. */);
5484 DEFVAR_PER_BUFFER ("tab-width", &BVAR (current_buffer
, tab_width
),
5485 make_number (LISP_INT_TAG
),
5486 doc
: /* *Distance between tab stops (for display of tab characters), in columns.
5487 This should be an integer greater than zero. */);
5489 DEFVAR_PER_BUFFER ("ctl-arrow", &BVAR (current_buffer
, ctl_arrow
), Qnil
,
5490 doc
: /* *Non-nil means display control chars with uparrow.
5491 A value of nil means use backslash and octal digits.
5492 This variable does not apply to characters whose display is specified
5493 in the current display table (if there is one). */);
5495 DEFVAR_PER_BUFFER ("enable-multibyte-characters",
5496 &BVAR (current_buffer
, enable_multibyte_characters
),
5498 doc
: /* Non-nil means the buffer contents are regarded as multi-byte characters.
5499 Otherwise they are regarded as unibyte. This affects the display,
5500 file I/O and the behavior of various editing commands.
5502 This variable is buffer-local but you cannot set it directly;
5503 use the function `set-buffer-multibyte' to change a buffer's representation.
5504 Changing its default value with `setq-default' is supported.
5505 See also variable `default-enable-multibyte-characters' and Info node
5506 `(elisp)Text Representations'. */);
5507 XSYMBOL (intern_c_string ("enable-multibyte-characters"))->constant
= 1;
5509 DEFVAR_PER_BUFFER ("buffer-file-coding-system",
5510 &BVAR (current_buffer
, buffer_file_coding_system
), Qnil
,
5511 doc
: /* Coding system to be used for encoding the buffer contents on saving.
5512 This variable applies to saving the buffer, and also to `write-region'
5513 and other functions that use `write-region'.
5514 It does not apply to sending output to subprocesses, however.
5516 If this is nil, the buffer is saved without any code conversion
5517 unless some coding system is specified in `file-coding-system-alist'
5518 for the buffer file.
5520 If the text to be saved cannot be encoded as specified by this variable,
5521 an alternative encoding is selected by `select-safe-coding-system', which see.
5523 The variable `coding-system-for-write', if non-nil, overrides this variable.
5525 This variable is never applied to a way of decoding a file while reading it. */);
5527 DEFVAR_PER_BUFFER ("bidi-display-reordering",
5528 &BVAR (current_buffer
, bidi_display_reordering
), Qnil
,
5529 doc
: /* Non-nil means reorder bidirectional text for display in the visual order. */);
5531 DEFVAR_PER_BUFFER ("bidi-paragraph-direction",
5532 &BVAR (current_buffer
, bidi_paragraph_direction
), Qnil
,
5533 doc
: /* *If non-nil, forces directionality of text paragraphs in the buffer.
5535 If this is nil (the default), the direction of each paragraph is
5536 determined by the first strong directional character of its text.
5537 The values of `right-to-left' and `left-to-right' override that.
5538 Any other value is treated as nil.
5540 This variable has no effect unless the buffer's value of
5541 \`bidi-display-reordering' is non-nil. */);
5543 DEFVAR_PER_BUFFER ("truncate-lines", &BVAR (current_buffer
, truncate_lines
), Qnil
,
5544 doc
: /* *Non-nil means do not display continuation lines.
5545 Instead, give each line of text just one screen line.
5547 Note that this is overridden by the variable
5548 `truncate-partial-width-windows' if that variable is non-nil
5549 and this buffer is not full-frame width. */);
5551 DEFVAR_PER_BUFFER ("word-wrap", &BVAR (current_buffer
, word_wrap
), Qnil
,
5552 doc
: /* *Non-nil means to use word-wrapping for continuation lines.
5553 When word-wrapping is on, continuation lines are wrapped at the space
5554 or tab character nearest to the right window edge.
5555 If nil, continuation lines are wrapped at the right screen edge.
5557 This variable has no effect if long lines are truncated (see
5558 `truncate-lines' and `truncate-partial-width-windows'). If you use
5559 word-wrapping, you might want to reduce the value of
5560 `truncate-partial-width-windows', since wrapping can make text readable
5561 in narrower windows. */);
5563 DEFVAR_PER_BUFFER ("default-directory", &BVAR (current_buffer
, directory
),
5564 make_number (Lisp_String
),
5565 doc
: /* Name of default directory of current buffer. Should end with slash.
5566 To interactively change the default directory, use command `cd'. */);
5568 DEFVAR_PER_BUFFER ("auto-fill-function", &BVAR (current_buffer
, auto_fill_function
),
5570 doc
: /* Function called (if non-nil) to perform auto-fill.
5571 It is called after self-inserting any character specified in
5572 the `auto-fill-chars' table.
5573 NOTE: This variable is not a hook;
5574 its value may not be a list of functions. */);
5576 DEFVAR_PER_BUFFER ("buffer-file-name", &BVAR (current_buffer
, filename
),
5577 make_number (Lisp_String
),
5578 doc
: /* Name of file visited in current buffer, or nil if not visiting a file. */);
5580 DEFVAR_PER_BUFFER ("buffer-file-truename", &BVAR (current_buffer
, file_truename
),
5581 make_number (Lisp_String
),
5582 doc
: /* Abbreviated truename of file visited in current buffer, or nil if none.
5583 The truename of a file is calculated by `file-truename'
5584 and then abbreviated with `abbreviate-file-name'. */);
5586 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
5587 &BVAR (current_buffer
, auto_save_file_name
),
5588 make_number (Lisp_String
),
5589 doc
: /* Name of file for auto-saving current buffer.
5590 If it is nil, that means don't auto-save this buffer. */);
5592 DEFVAR_PER_BUFFER ("buffer-read-only", &BVAR (current_buffer
, read_only
), Qnil
,
5593 doc
: /* Non-nil if this buffer is read-only. */);
5595 DEFVAR_PER_BUFFER ("buffer-backed-up", &BVAR (current_buffer
, backed_up
), Qnil
,
5596 doc
: /* Non-nil if this buffer's file has been backed up.
5597 Backing up is done before the first time the file is saved. */);
5599 DEFVAR_PER_BUFFER ("buffer-saved-size", &BVAR (current_buffer
, save_length
),
5600 make_number (LISP_INT_TAG
),
5601 doc
: /* Length of current buffer when last read in, saved or auto-saved.
5603 -1 means auto-saving turned off until next real save.
5605 If you set this to -2, that means don't turn off auto-saving in this buffer
5606 if its text size shrinks. If you use `buffer-swap-text' on a buffer,
5607 you probably should set this to -2 in that buffer. */);
5609 DEFVAR_PER_BUFFER ("selective-display", &BVAR (current_buffer
, selective_display
),
5611 doc
: /* Non-nil enables selective display.
5612 An integer N as value means display only lines
5613 that start with less than N columns of space.
5614 A value of t means that the character ^M makes itself and
5615 all the rest of the line invisible; also, when saving the buffer
5616 in a file, save the ^M as a newline. */);
5619 DEFVAR_PER_BUFFER ("selective-display-ellipses",
5620 &BVAR (current_buffer
, selective_display_ellipses
),
5622 doc
: /* Non-nil means display ... on previous line when a line is invisible. */);
5625 DEFVAR_PER_BUFFER ("overwrite-mode", &BVAR (current_buffer
, overwrite_mode
), Qnil
,
5626 doc
: /* Non-nil if self-insertion should replace existing text.
5627 The value should be one of `overwrite-mode-textual',
5628 `overwrite-mode-binary', or nil.
5629 If it is `overwrite-mode-textual', self-insertion still
5630 inserts at the end of a line, and inserts when point is before a tab,
5631 until the tab is filled in.
5632 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too. */);
5634 DEFVAR_PER_BUFFER ("buffer-display-table", &BVAR (current_buffer
, display_table
),
5636 doc
: /* Display table that controls display of the contents of current buffer.
5638 If this variable is nil, the value of `standard-display-table' is used.
5639 Each window can have its own, overriding display table, see
5640 `set-window-display-table' and `window-display-table'.
5642 The display table is a char-table created with `make-display-table'.
5643 A char-table is an array indexed by character codes. Normal array
5644 primitives `aref' and `aset' can be used to access elements of a char-table.
5646 Each of the char-table elements control how to display the corresponding
5647 text character: the element at index C in the table says how to display
5648 the character whose code is C. Each element should be a vector of
5649 characters or nil. The value nil means display the character in the
5650 default fashion; otherwise, the characters from the vector are delivered
5651 to the screen instead of the original character.
5653 For example, (aset buffer-display-table ?X [?Y]) tells Emacs
5654 to display a capital Y instead of each X character.
5656 In addition, a char-table has six extra slots to control the display of:
5658 the end of a truncated screen line (extra-slot 0, a single character);
5659 the end of a continued line (extra-slot 1, a single character);
5660 the escape character used to display character codes in octal
5661 (extra-slot 2, a single character);
5662 the character used as an arrow for control characters (extra-slot 3,
5663 a single character);
5664 the decoration indicating the presence of invisible lines (extra-slot 4,
5665 a vector of characters);
5666 the character used to draw the border between side-by-side windows
5667 (extra-slot 5, a single character).
5669 See also the functions `display-table-slot' and `set-display-table-slot'. */);
5671 DEFVAR_PER_BUFFER ("left-margin-width", &BVAR (current_buffer
, left_margin_cols
),
5673 doc
: /* *Width of left marginal area for display of a buffer.
5674 A value of nil means no marginal area. */);
5676 DEFVAR_PER_BUFFER ("right-margin-width", &BVAR (current_buffer
, right_margin_cols
),
5678 doc
: /* *Width of right marginal area for display of a buffer.
5679 A value of nil means no marginal area. */);
5681 DEFVAR_PER_BUFFER ("left-fringe-width", &BVAR (current_buffer
, left_fringe_width
),
5683 doc
: /* *Width of this buffer's left fringe (in pixels).
5684 A value of 0 means no left fringe is shown in this buffer's window.
5685 A value of nil means to use the left fringe width from the window's frame. */);
5687 DEFVAR_PER_BUFFER ("right-fringe-width", &BVAR (current_buffer
, right_fringe_width
),
5689 doc
: /* *Width of this buffer's right fringe (in pixels).
5690 A value of 0 means no right fringe is shown in this buffer's window.
5691 A value of nil means to use the right fringe width from the window's frame. */);
5693 DEFVAR_PER_BUFFER ("fringes-outside-margins", &BVAR (current_buffer
, fringes_outside_margins
),
5695 doc
: /* *Non-nil means to display fringes outside display margins.
5696 A value of nil means to display fringes between margins and buffer text. */);
5698 DEFVAR_PER_BUFFER ("scroll-bar-width", &BVAR (current_buffer
, scroll_bar_width
),
5700 doc
: /* *Width of this buffer's scroll bars in pixels.
5701 A value of nil means to use the scroll bar width from the window's frame. */);
5703 DEFVAR_PER_BUFFER ("vertical-scroll-bar", &BVAR (current_buffer
, vertical_scroll_bar_type
),
5705 doc
: /* *Position of this buffer's vertical scroll bar.
5706 The value takes effect whenever you tell a window to display this buffer;
5707 for instance, with `set-window-buffer' or when `display-buffer' displays it.
5709 A value of `left' or `right' means put the vertical scroll bar at that side
5710 of the window; a value of nil means don't show any vertical scroll bars.
5711 A value of t (the default) means do whatever the window's frame specifies. */);
5713 DEFVAR_PER_BUFFER ("indicate-empty-lines",
5714 &BVAR (current_buffer
, indicate_empty_lines
), Qnil
,
5715 doc
: /* *Visually indicate empty lines after the buffer end.
5716 If non-nil, a bitmap is displayed in the left fringe of a window on
5717 window-systems. */);
5719 DEFVAR_PER_BUFFER ("indicate-buffer-boundaries",
5720 &BVAR (current_buffer
, indicate_buffer_boundaries
), Qnil
,
5721 doc
: /* *Visually indicate buffer boundaries and scrolling.
5722 If non-nil, the first and last line of the buffer are marked in the fringe
5723 of a window on window-systems with angle bitmaps, or if the window can be
5724 scrolled, the top and bottom line of the window are marked with up and down
5727 If value is a symbol `left' or `right', both angle and arrow bitmaps
5728 are displayed in the left or right fringe, resp. Any other value
5729 that doesn't look like an alist means display the angle bitmaps in
5730 the left fringe but no arrows.
5732 You can exercise more precise control by using an alist as the
5733 value. Each alist element (INDICATOR . POSITION) specifies
5734 where to show one of the indicators. INDICATOR is one of `top',
5735 `bottom', `up', `down', or t, which specifies the default position,
5736 and POSITION is one of `left', `right', or nil, meaning do not show
5739 For example, ((top . left) (t . right)) places the top angle bitmap in
5740 left fringe, the bottom angle bitmap in right fringe, and both arrow
5741 bitmaps in right fringe. To show just the angle bitmaps in the left
5742 fringe, but no arrow bitmaps, use ((top . left) (bottom . left)). */);
5744 DEFVAR_PER_BUFFER ("fringe-indicator-alist",
5745 &BVAR (current_buffer
, fringe_indicator_alist
), Qnil
,
5746 doc
: /* *Mapping from logical to physical fringe indicator bitmaps.
5747 The value is an alist where each element (INDICATOR . BITMAPS)
5748 specifies the fringe bitmaps used to display a specific logical
5751 INDICATOR specifies the logical indicator type which is one of the
5752 following symbols: `truncation' , `continuation', `overlay-arrow',
5753 `top', `bottom', `top-bottom', `up', `down', empty-line', or `unknown'.
5755 BITMAPS is a list of symbols (LEFT RIGHT [LEFT1 RIGHT1]) which specifies
5756 the actual bitmap shown in the left or right fringe for the logical
5757 indicator. LEFT and RIGHT are the bitmaps shown in the left and/or
5758 right fringe for the specific indicator. The LEFT1 or RIGHT1 bitmaps
5759 are used only for the `bottom' and `top-bottom' indicators when the
5760 last (only) line has no final newline. BITMAPS may also be a single
5761 symbol which is used in both left and right fringes. */);
5763 DEFVAR_PER_BUFFER ("fringe-cursor-alist",
5764 &BVAR (current_buffer
, fringe_cursor_alist
), Qnil
,
5765 doc
: /* *Mapping from logical to physical fringe cursor bitmaps.
5766 The value is an alist where each element (CURSOR . BITMAP)
5767 specifies the fringe bitmaps used to display a specific logical
5768 cursor type in the fringe.
5770 CURSOR specifies the logical cursor type which is one of the following
5771 symbols: `box' , `hollow', `bar', `hbar', or `hollow-small'. The last
5772 one is used to show a hollow cursor on narrow lines display lines
5773 where the normal hollow cursor will not fit.
5775 BITMAP is the corresponding fringe bitmap shown for the logical
5778 DEFVAR_PER_BUFFER ("scroll-up-aggressively",
5779 &BVAR (current_buffer
, scroll_up_aggressively
), Qnil
,
5780 doc
: /* How far to scroll windows upward.
5781 If you move point off the bottom, the window scrolls automatically.
5782 This variable controls how far it scrolls. The value nil, the default,
5783 means scroll to center point. A fraction means scroll to put point
5784 that fraction of the window's height from the bottom of the window.
5785 When the value is 0.0, point goes at the bottom line, which in the
5786 simple case that you moved off with C-f means scrolling just one line.
5787 1.0 means point goes at the top, so that in that simple case, the
5788 window scrolls by a full window height. Meaningful values are
5789 between 0.0 and 1.0, inclusive. */);
5791 DEFVAR_PER_BUFFER ("scroll-down-aggressively",
5792 &BVAR (current_buffer
, scroll_down_aggressively
), Qnil
,
5793 doc
: /* How far to scroll windows downward.
5794 If you move point off the top, the window scrolls automatically.
5795 This variable controls how far it scrolls. The value nil, the default,
5796 means scroll to center point. A fraction means scroll to put point
5797 that fraction of the window's height from the top of the window.
5798 When the value is 0.0, point goes at the top line, which in the
5799 simple case that you moved off with C-b means scrolling just one line.
5800 1.0 means point goes at the bottom, so that in that simple case, the
5801 window scrolls by a full window height. Meaningful values are
5802 between 0.0 and 1.0, inclusive. */);
5804 /*DEFVAR_LISP ("debug-check-symbol", &Vcheck_symbol,
5808 DEFVAR_LISP ("before-change-functions", Vbefore_change_functions
,
5809 doc
: /* List of functions to call before each text change.
5810 Two arguments are passed to each function: the positions of
5811 the beginning and end of the range of old text to be changed.
5812 \(For an insertion, the beginning and end are at the same place.)
5813 No information is given about the length of the text after the change.
5815 Buffer changes made while executing the `before-change-functions'
5816 don't call any before-change or after-change functions.
5817 That's because `inhibit-modification-hooks' is temporarily set non-nil.
5819 If an unhandled error happens in running these functions,
5820 the variable's value remains nil. That prevents the error
5821 from happening repeatedly and making Emacs nonfunctional. */);
5822 Vbefore_change_functions
= Qnil
;
5824 DEFVAR_LISP ("after-change-functions", Vafter_change_functions
,
5825 doc
: /* List of functions to call after each text change.
5826 Three arguments are passed to each function: the positions of
5827 the beginning and end of the range of changed text,
5828 and the length in bytes of the pre-change text replaced by that range.
5829 \(For an insertion, the pre-change length is zero;
5830 for a deletion, that length is the number of bytes deleted,
5831 and the post-change beginning and end are at the same place.)
5833 Buffer changes made while executing the `after-change-functions'
5834 don't call any before-change or after-change functions.
5835 That's because `inhibit-modification-hooks' is temporarily set non-nil.
5837 If an unhandled error happens in running these functions,
5838 the variable's value remains nil. That prevents the error
5839 from happening repeatedly and making Emacs nonfunctional. */);
5840 Vafter_change_functions
= Qnil
;
5842 DEFVAR_LISP ("first-change-hook", Vfirst_change_hook
,
5843 doc
: /* A list of functions to call before changing a buffer which is unmodified.
5844 The functions are run using the `run-hooks' function. */);
5845 Vfirst_change_hook
= Qnil
;
5847 DEFVAR_PER_BUFFER ("buffer-undo-list", &BVAR (current_buffer
, undo_list
), Qnil
,
5848 doc
: /* List of undo entries in current buffer.
5849 Recent changes come first; older changes follow newer.
5851 An entry (BEG . END) represents an insertion which begins at
5852 position BEG and ends at position END.
5854 An entry (TEXT . POSITION) represents the deletion of the string TEXT
5855 from (abs POSITION). If POSITION is positive, point was at the front
5856 of the text being deleted; if negative, point was at the end.
5858 An entry (t HIGH . LOW) indicates that the buffer previously had
5859 \"unmodified\" status. HIGH and LOW are the high and low 16-bit portions
5860 of the visited file's modification time, as of that time. If the
5861 modification time of the most recent save is different, this entry is
5864 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
5865 was modified between BEG and END. PROPERTY is the property name,
5866 and VALUE is the old value.
5868 An entry (apply FUN-NAME . ARGS) means undo the change with
5869 \(apply FUN-NAME ARGS).
5871 An entry (apply DELTA BEG END FUN-NAME . ARGS) supports selective undo
5872 in the active region. BEG and END is the range affected by this entry
5873 and DELTA is the number of bytes added or deleted in that range by
5876 An entry (MARKER . DISTANCE) indicates that the marker MARKER
5877 was adjusted in position by the offset DISTANCE (an integer).
5879 An entry of the form POSITION indicates that point was at the buffer
5880 location given by the integer. Undoing an entry of this form places
5883 Entries with value `nil' mark undo boundaries. The undo command treats
5884 the changes between two undo boundaries as a single step to be undone.
5886 If the value of the variable is t, undo information is not recorded. */);
5888 DEFVAR_PER_BUFFER ("mark-active", &BVAR (current_buffer
, mark_active
), Qnil
,
5889 doc
: /* Non-nil means the mark and region are currently active in this buffer. */);
5891 DEFVAR_PER_BUFFER ("cache-long-line-scans", &BVAR (current_buffer
, cache_long_line_scans
), Qnil
,
5892 doc
: /* Non-nil means that Emacs should use caches to handle long lines more quickly.
5894 Normally, the line-motion functions work by scanning the buffer for
5895 newlines. Columnar operations (like `move-to-column' and
5896 `compute-motion') also work by scanning the buffer, summing character
5897 widths as they go. This works well for ordinary text, but if the
5898 buffer's lines are very long (say, more than 500 characters), these
5899 motion functions will take longer to execute. Emacs may also take
5900 longer to update the display.
5902 If `cache-long-line-scans' is non-nil, these motion functions cache the
5903 results of their scans, and consult the cache to avoid rescanning
5904 regions of the buffer until the text is modified. The caches are most
5905 beneficial when they prevent the most searching---that is, when the
5906 buffer contains long lines and large regions of characters with the
5907 same, fixed screen width.
5909 When `cache-long-line-scans' is non-nil, processing short lines will
5910 become slightly slower (because of the overhead of consulting the
5911 cache), and the caches will use memory roughly proportional to the
5912 number of newlines and characters whose screen width varies.
5914 The caches require no explicit maintenance; their accuracy is
5915 maintained internally by the Emacs primitives. Enabling or disabling
5916 the cache should not affect the behavior of any of the motion
5917 functions; it should only affect their performance. */);
5919 DEFVAR_PER_BUFFER ("point-before-scroll", &BVAR (current_buffer
, point_before_scroll
), Qnil
,
5920 doc
: /* Value of point before the last series of scroll operations, or nil. */);
5922 DEFVAR_PER_BUFFER ("buffer-file-format", &BVAR (current_buffer
, file_format
), Qnil
,
5923 doc
: /* List of formats to use when saving this buffer.
5924 Formats are defined by `format-alist'. This variable is
5925 set when a file is visited. */);
5927 DEFVAR_PER_BUFFER ("buffer-auto-save-file-format",
5928 &BVAR (current_buffer
, auto_save_file_format
), Qnil
,
5929 doc
: /* *Format in which to write auto-save files.
5930 Should be a list of symbols naming formats that are defined in `format-alist'.
5931 If it is t, which is the default, auto-save files are written in the
5932 same format as a regular save would use. */);
5934 DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
5935 &BVAR (current_buffer
, invisibility_spec
), Qnil
,
5936 doc
: /* Invisibility spec of this buffer.
5937 The default is t, which means that text is invisible
5938 if it has a non-nil `invisible' property.
5939 If the value is a list, a text character is invisible if its `invisible'
5940 property is an element in that list (or is a list with members in common).
5941 If an element is a cons cell of the form (PROP . ELLIPSIS),
5942 then characters with property value PROP are invisible,
5943 and they have an ellipsis as well if ELLIPSIS is non-nil. */);
5945 DEFVAR_PER_BUFFER ("buffer-display-count",
5946 &BVAR (current_buffer
, display_count
), Qnil
,
5947 doc
: /* A number incremented each time this buffer is displayed in a window.
5948 The function `set-window-buffer' increments it. */);
5950 DEFVAR_PER_BUFFER ("buffer-display-time",
5951 &BVAR (current_buffer
, display_time
), Qnil
,
5952 doc
: /* Time stamp updated each time this buffer is displayed in a window.
5953 The function `set-window-buffer' updates this variable
5954 to the value obtained by calling `current-time'.
5955 If the buffer has never been shown in a window, the value is nil. */);
5957 DEFVAR_LISP ("transient-mark-mode", Vtransient_mark_mode
,
5958 doc
: /* Non-nil if Transient Mark mode is enabled.
5959 See the command `transient-mark-mode' for a description of this minor mode.
5961 Non-nil also enables highlighting of the region whenever the mark is active.
5962 The variable `highlight-nonselected-windows' controls whether to highlight
5963 all windows or just the selected window.
5965 Lisp programs may give this variable certain special values:
5967 - A value of `lambda' enables Transient Mark mode temporarily.
5968 It is disabled again after any subsequent action that would
5969 normally deactivate the mark (e.g. buffer modification).
5971 - A value of (only . OLDVAL) enables Transient Mark mode
5972 temporarily. After any subsequent point motion command that is
5973 not shift-translated, or any other action that would normally
5974 deactivate the mark (e.g. buffer modification), the value of
5975 `transient-mark-mode' is set to OLDVAL. */);
5976 Vtransient_mark_mode
= Qnil
;
5978 DEFVAR_LISP ("inhibit-read-only", Vinhibit_read_only
,
5979 doc
: /* *Non-nil means disregard read-only status of buffers or characters.
5980 If the value is t, disregard `buffer-read-only' and all `read-only'
5981 text properties. If the value is a list, disregard `buffer-read-only'
5982 and disregard a `read-only' text property if the property value
5983 is a member of the list. */);
5984 Vinhibit_read_only
= Qnil
;
5986 DEFVAR_PER_BUFFER ("cursor-type", &BVAR (current_buffer
, cursor_type
), Qnil
,
5987 doc
: /* Cursor to use when this buffer is in the selected window.
5988 Values are interpreted as follows:
5990 t use the cursor specified for the frame
5991 nil don't display a cursor
5992 box display a filled box cursor
5993 hollow display a hollow box cursor
5994 bar display a vertical bar cursor with default width
5995 (bar . WIDTH) display a vertical bar cursor with width WIDTH
5996 hbar display a horizontal bar cursor with default height
5997 (hbar . HEIGHT) display a horizontal bar cursor with height HEIGHT
5998 ANYTHING ELSE display a hollow box cursor
6000 When the buffer is displayed in a non-selected window, the
6001 cursor's appearance is instead controlled by the variable
6002 `cursor-in-non-selected-windows'. */);
6004 DEFVAR_PER_BUFFER ("line-spacing",
6005 &BVAR (current_buffer
, extra_line_spacing
), Qnil
,
6006 doc
: /* Additional space to put between lines when displaying a buffer.
6007 The space is measured in pixels, and put below lines on graphic displays,
6008 see `display-graphic-p'.
6009 If value is a floating point number, it specifies the spacing relative
6010 to the default frame line height. A value of nil means add no extra space. */);
6012 DEFVAR_PER_BUFFER ("cursor-in-non-selected-windows",
6013 &BVAR (current_buffer
, cursor_in_non_selected_windows
), Qnil
,
6014 doc
: /* *Non-nil means show a cursor in non-selected windows.
6015 If nil, only shows a cursor in the selected window.
6016 If t, displays a cursor related to the usual cursor type
6017 \(a solid box becomes hollow, a bar becomes a narrower bar).
6018 You can also specify the cursor type as in the `cursor-type' variable.
6019 Use Custom to set this variable and update the display." */);
6021 DEFVAR_LISP ("kill-buffer-query-functions", Vkill_buffer_query_functions
,
6022 doc
: /* List of functions called with no args to query before killing a buffer.
6023 The buffer being killed will be current while the functions are running.
6024 If any of them returns nil, the buffer is not killed. */);
6025 Vkill_buffer_query_functions
= Qnil
;
6027 DEFVAR_LISP ("change-major-mode-hook", Vchange_major_mode_hook
,
6028 doc
: /* Normal hook run before changing the major mode of a buffer.
6029 The function `kill-all-local-variables' runs this before doing anything else. */);
6030 Vchange_major_mode_hook
= Qnil
;
6031 Qchange_major_mode_hook
= intern_c_string ("change-major-mode-hook");
6032 staticpro (&Qchange_major_mode_hook
);
6034 DEFVAR_LISP ("buffer-list-update-hook", Vbuffer_list_update_hook
,
6035 doc
: /* Hook run when the buffer list changes.
6036 Functions running this hook are `get-buffer-create',
6037 `make-indirect-buffer', `rename-buffer', `kill-buffer',
6038 `record-buffer' and `unrecord-buffer'. */);
6039 Vbuffer_list_update_hook
= Qnil
;
6040 Qbuffer_list_update_hook
= intern_c_string ("buffer-list-update-hook");
6041 staticpro (&Qbuffer_list_update_hook
);
6043 defsubr (&Sbuffer_live_p
);
6044 defsubr (&Sbuffer_list
);
6045 defsubr (&Sget_buffer
);
6046 defsubr (&Sget_file_buffer
);
6047 defsubr (&Sget_buffer_create
);
6048 defsubr (&Smake_indirect_buffer
);
6049 defsubr (&Sgenerate_new_buffer_name
);
6050 defsubr (&Sbuffer_name
);
6051 /*defsubr (&Sbuffer_number);*/
6052 defsubr (&Sbuffer_file_name
);
6053 defsubr (&Sbuffer_base_buffer
);
6054 defsubr (&Sbuffer_local_value
);
6055 defsubr (&Sbuffer_local_variables
);
6056 defsubr (&Sbuffer_modified_p
);
6057 defsubr (&Sset_buffer_modified_p
);
6058 defsubr (&Sbuffer_modified_tick
);
6059 defsubr (&Sbuffer_chars_modified_tick
);
6060 defsubr (&Srename_buffer
);
6061 defsubr (&Sother_buffer
);
6062 defsubr (&Sbuffer_enable_undo
);
6063 defsubr (&Skill_buffer
);
6064 defsubr (&Srecord_buffer
);
6065 defsubr (&Sunrecord_buffer
);
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
);