1 /* Buffer manipulation primitives for GNU Emacs.
2 Copyright (C) 1985, 1986, 1987, 1988, 1989, 1993, 1994,
3 1995, 1997, 1998, 1999, 2000, 2001, 2002,
4 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
5 Free Software Foundation, Inc.
7 This file is part of GNU Emacs.
9 GNU Emacs is free software: you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation, either version 3 of the License, or
12 (at your option) any later version.
14 GNU Emacs is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
24 #include <sys/types.h>
26 #include <sys/param.h>
43 #include "intervals.h"
47 #include "character.h"
48 #include "region-cache.h"
50 #include "blockinput.h"
55 /* First buffer in chain of all buffers (in reverse order of creation).
56 Threaded through ->next. */
58 struct buffer
*all_buffers
;
60 /* This structure holds the default values of the buffer-local variables
61 defined with DEFVAR_PER_BUFFER, that have special slots in each buffer.
62 The default value occupies the same slot in this structure
63 as an individual buffer's value occupies in that buffer.
64 Setting the default value also goes through the alist of buffers
65 and stores into each buffer that does not say it has a local value. */
67 DECL_ALIGN (struct buffer
, buffer_defaults
);
69 /* A Lisp_Object pointer to the above, used for staticpro */
71 static Lisp_Object Vbuffer_defaults
;
73 /* This structure marks which slots in a buffer have corresponding
74 default values in buffer_defaults.
75 Each such slot has a nonzero value in this structure.
76 The value has only one nonzero bit.
78 When a buffer has its own local value for a slot,
79 the entry for that slot (found in the same slot in this structure)
80 is turned on in the buffer's local_flags array.
82 If a slot in this structure is -1, then even though there may
83 be a DEFVAR_PER_BUFFER for the slot, there is no default value for it;
84 and the corresponding slot in buffer_defaults is not used.
86 If a slot is -2, then there is no DEFVAR_PER_BUFFER for it,
87 but there is a default value which is copied into each buffer.
89 If a slot in this structure corresponding to a DEFVAR_PER_BUFFER is
90 zero, that is a bug */
92 struct buffer buffer_local_flags
;
94 /* This structure holds the names of symbols whose values may be
95 buffer-local. It is indexed and accessed in the same way as the above. */
97 DECL_ALIGN (struct buffer
, buffer_local_symbols
);
99 /* A Lisp_Object pointer to the above, used for staticpro */
100 static Lisp_Object Vbuffer_local_symbols
;
102 /* Flags indicating which built-in buffer-local variables
103 are permanent locals. */
104 static char buffer_permanent_local_flags
[MAX_PER_BUFFER_VARS
];
106 /* Number of per-buffer variables used. */
108 int last_per_buffer_idx
;
110 EXFUN (Fset_buffer
, 1);
111 void set_buffer_internal
P_ ((struct buffer
*b
));
112 void set_buffer_internal_1
P_ ((struct buffer
*b
));
113 static void call_overlay_mod_hooks
P_ ((Lisp_Object list
, Lisp_Object overlay
,
114 int after
, Lisp_Object arg1
,
115 Lisp_Object arg2
, Lisp_Object arg3
));
116 static void swap_out_buffer_local_variables
P_ ((struct buffer
*b
));
117 static void reset_buffer_local_variables
P_ ((struct buffer
*b
, int permanent_too
));
119 /* Alist of all buffer names vs the buffers. */
120 /* This used to be a variable, but is no longer,
121 to prevent lossage due to user rplac'ing this alist or its elements. */
122 Lisp_Object Vbuffer_alist
;
124 /* Functions to call before and after each text change. */
125 Lisp_Object impl_Vbefore_change_functions
;
126 Lisp_Object impl_Vafter_change_functions
;
128 Lisp_Object impl_Vtransient_mark_mode
;
130 /* t means ignore all read-only text properties.
131 A list means ignore such a property if its value is a member of the list.
132 Any non-nil value means ignore buffer-read-only. */
133 Lisp_Object impl_Vinhibit_read_only
;
135 /* List of functions to call that can query about killing a buffer.
136 If any of these functions returns nil, we don't kill it. */
137 Lisp_Object impl_Vkill_buffer_query_functions
;
138 Lisp_Object Qkill_buffer_query_functions
;
140 /* Hook run before changing a major mode. */
141 Lisp_Object impl_Vchange_major_mode_hook
, Qchange_major_mode_hook
;
143 /* List of functions to call before changing an unmodified buffer. */
144 Lisp_Object impl_Vfirst_change_hook
;
146 Lisp_Object Qfirst_change_hook
;
147 Lisp_Object Qbefore_change_functions
;
148 Lisp_Object Qafter_change_functions
;
149 Lisp_Object Qucs_set_table_for_input
;
151 /* If nonzero, all modification hooks are suppressed. */
152 int inhibit_modification_hooks
;
154 Lisp_Object Qfundamental_mode
, Qmode_class
, Qpermanent_local
;
155 Lisp_Object Qpermanent_local_hook
;
157 Lisp_Object Qprotected_field
;
159 Lisp_Object QSFundamental
; /* A string "Fundamental" */
161 Lisp_Object Qkill_buffer_hook
;
163 Lisp_Object Qget_file_buffer
;
165 Lisp_Object Qoverlayp
;
167 Lisp_Object Qpriority
, Qwindow
, Qevaporate
, Qbefore_string
, Qafter_string
;
169 Lisp_Object Qmodification_hooks
;
170 Lisp_Object Qinsert_in_front_hooks
;
171 Lisp_Object Qinsert_behind_hooks
;
173 static void alloc_buffer_text
P_ ((struct buffer
*, size_t));
174 static void free_buffer_text
P_ ((struct buffer
*b
));
175 static struct Lisp_Overlay
* copy_overlays
P_ ((struct buffer
*, struct Lisp_Overlay
*));
176 static void modify_overlay
P_ ((struct buffer
*, EMACS_INT
, EMACS_INT
));
177 static Lisp_Object buffer_lisp_local_variables
P_ ((struct buffer
*));
179 extern char * emacs_strerror
P_ ((int));
181 /* For debugging; temporary. See set_buffer_internal. */
182 /* Lisp_Object Qlisp_mode, Vcheck_symbol; */
189 error ("No buffer named %s", SDATA (spec
));
190 error ("Invalid buffer argument");
193 DEFUN ("buffer-live-p", Fbuffer_live_p
, Sbuffer_live_p
, 1, 1, 0,
194 doc
: /* Return non-nil if OBJECT is a buffer which has not been killed.
195 Value is nil if OBJECT is not a buffer or if it has been killed. */)
199 return ((BUFFERP (object
) && ! NILP (BUF_NAME (XBUFFER (object
))))
203 DEFUN ("buffer-list", Fbuffer_list
, Sbuffer_list
, 0, 1, 0,
204 doc
: /* Return a list of all existing live buffers.
205 If the optional arg FRAME is a frame, we return the buffer list
206 in the proper order for that frame: the buffers in FRAME's `buffer-list'
207 frame parameter come first, followed by the rest of the buffers. */)
212 general
= Fmapcar (Qcdr
, Vbuffer_alist
);
216 Lisp_Object framelist
, prevlist
, tail
;
221 framelist
= Fcopy_sequence (XFRAME (frame
)->buffer_list
);
222 prevlist
= Fnreverse (Fcopy_sequence (XFRAME (frame
)->buried_buffer_list
));
224 /* Remove from GENERAL any buffer that duplicates one in
225 FRAMELIST or PREVLIST. */
229 general
= Fdelq (XCAR (tail
), general
);
235 general
= Fdelq (XCAR (tail
), general
);
242 return Fnconc (3, args
);
248 /* Like Fassoc, but use Fstring_equal to compare
249 (which ignores text properties),
250 and don't ever QUIT. */
253 assoc_ignore_text_properties (key
, list
)
254 register Lisp_Object key
;
257 register Lisp_Object tail
;
258 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
260 register Lisp_Object elt
, tem
;
262 tem
= Fstring_equal (Fcar (elt
), key
);
269 DEFUN ("get-buffer", Fget_buffer
, Sget_buffer
, 1, 1, 0,
270 doc
: /* Return the buffer named BUFFER-OR-NAME.
271 BUFFER-OR-NAME must be either a string or a buffer. If BUFFER-OR-NAME
272 is a string and there is no buffer with that name, return nil. If
273 BUFFER-OR-NAME is a buffer, return it as given. */)
275 register Lisp_Object buffer_or_name
;
277 if (BUFFERP (buffer_or_name
))
278 return buffer_or_name
;
279 CHECK_STRING (buffer_or_name
);
281 return Fcdr (assoc_ignore_text_properties (buffer_or_name
, Vbuffer_alist
));
284 DEFUN ("get-file-buffer", Fget_file_buffer
, Sget_file_buffer
, 1, 1, 0,
285 doc
: /* Return the buffer visiting file FILENAME (a string).
286 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
287 If there is no such live buffer, return nil.
288 See also `find-buffer-visiting'. */)
290 register Lisp_Object filename
;
292 register Lisp_Object tail
, buf
, tem
;
295 CHECK_STRING (filename
);
296 filename
= Fexpand_file_name (filename
, Qnil
);
298 /* If the file name has special constructs in it,
299 call the corresponding file handler. */
300 handler
= Ffind_file_name_handler (filename
, Qget_file_buffer
);
302 return call2 (handler
, Qget_file_buffer
, filename
);
304 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
306 buf
= Fcdr (XCAR (tail
));
307 if (!BUFFERP (buf
)) continue;
308 if (!STRINGP (BUF_FILENAME (XBUFFER (buf
)))) continue;
309 tem
= Fstring_equal (BUF_FILENAME (XBUFFER (buf
)), filename
);
317 get_truename_buffer (filename
)
318 register Lisp_Object filename
;
320 register Lisp_Object tail
, buf
, tem
;
322 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
324 buf
= Fcdr (XCAR (tail
));
325 if (!BUFFERP (buf
)) continue;
326 if (!STRINGP (BUF_FILE_TRUENAME (XBUFFER (buf
)))) continue;
327 tem
= Fstring_equal (BUF_FILE_TRUENAME (XBUFFER (buf
)), filename
);
334 DEFUN ("get-buffer-create", Fget_buffer_create
, Sget_buffer_create
, 1, 1, 0,
335 doc
: /* Return the buffer specified by BUFFER-OR-NAME, creating a new one if needed.
336 If BUFFER-OR-NAME is a string and a live buffer with that name exists,
337 return that buffer. If no such buffer exists, create a new buffer with
338 that name and return it. If BUFFER-OR-NAME starts with a space, the new
339 buffer does not keep undo information.
341 If BUFFER-OR-NAME is a buffer instead of a string, return it as given,
342 even if it is dead. The return value is never nil. */)
344 register Lisp_Object buffer_or_name
;
346 register Lisp_Object buffer
, name
;
347 register struct buffer
*b
;
349 buffer
= Fget_buffer (buffer_or_name
);
353 if (SCHARS (buffer_or_name
) == 0)
354 error ("Empty string for buffer name is not allowed");
356 b
= allocate_buffer ();
358 /* An ordinary buffer uses its own struct buffer_text. */
359 b
->text
= &b
->own_text
;
362 BUF_GAP_SIZE (b
) = 20;
364 /* We allocate extra 1-byte at the tail and keep it always '\0' for
365 anchoring a search. */
366 alloc_buffer_text (b
, BUF_GAP_SIZE (b
) + 1);
368 if (! BUF_BEG_ADDR (b
))
369 buffer_memory_full ();
376 BUF_PT_BYTE (b
) = BEG_BYTE
;
377 BUF_GPT_BYTE (b
) = BEG_BYTE
;
378 BUF_BEGV_BYTE (b
) = BEG_BYTE
;
379 BUF_ZV_BYTE (b
) = BEG_BYTE
;
380 BUF_Z_BYTE (b
) = BEG_BYTE
;
382 BUF_CHARS_MODIFF (b
) = 1;
383 BUF_OVERLAY_MODIFF (b
) = 1;
384 BUF_SAVE_MODIFF (b
) = 1;
385 BUF_INTERVALS (b
) = 0;
386 BUF_UNCHANGED_MODIFIED (b
) = 1;
387 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = 1;
388 BUF_END_UNCHANGED (b
) = 0;
389 BUF_BEG_UNCHANGED (b
) = 0;
390 *(BUF_GPT_ADDR (b
)) = *(BUF_Z_ADDR (b
)) = 0; /* Put an anchor '\0'. */
392 b
->newline_cache
= 0;
393 b
->width_run_cache
= 0;
394 b
->width_table_
= Qnil
;
395 b
->prevent_redisplay_optimizations_p
= 1;
397 /* Put this on the chain of all buffers including killed ones. */
398 b
->next
= all_buffers
;
401 /* An ordinary buffer normally doesn't need markers
402 to handle BEGV and ZV. */
403 b
->pt_marker_
= Qnil
;
404 b
->begv_marker_
= Qnil
;
405 b
->zv_marker_
= Qnil
;
407 name
= Fcopy_sequence (buffer_or_name
);
408 STRING_SET_INTERVALS (name
, NULL_INTERVAL
);
411 b
->undo_list_
= (SREF (name
, 0) != ' ') ? Qnil
: Qt
;
414 reset_buffer_local_variables (b
, 1);
416 b
->mark_
= Fmake_marker ();
417 BUF_MARKERS (b
) = NULL
;
420 /* Put this in the alist of all live buffers. */
421 XSETBUFFER (buffer
, b
);
422 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buffer
), Qnil
));
424 /* An error in calling the function here (should someone redefine it)
425 can lead to infinite regress until you run out of stack. rms
426 says that's not worth protecting against. */
427 if (!NILP (Ffboundp (Qucs_set_table_for_input
)))
428 /* buffer is on buffer-alist, so no gcpro. */
429 call1 (Qucs_set_table_for_input
, buffer
);
435 /* Return a list of overlays which is a copy of the overlay list
436 LIST, but for buffer B. */
438 static struct Lisp_Overlay
*
439 copy_overlays (b
, list
)
441 struct Lisp_Overlay
*list
;
444 struct Lisp_Overlay
*result
= NULL
, *tail
= NULL
;
446 XSETBUFFER (buffer
, b
);
448 for (; list
; list
= list
->next
)
450 Lisp_Object overlay
, start
, end
, old_overlay
;
453 XSETMISC (old_overlay
, list
);
454 charpos
= marker_position (OVERLAY_START (old_overlay
));
455 start
= Fmake_marker ();
456 Fset_marker (start
, make_number (charpos
), buffer
);
457 XMARKER (start
)->insertion_type
458 = XMARKER (OVERLAY_START (old_overlay
))->insertion_type
;
460 charpos
= marker_position (OVERLAY_END (old_overlay
));
461 end
= Fmake_marker ();
462 Fset_marker (end
, make_number (charpos
), buffer
);
463 XMARKER (end
)->insertion_type
464 = XMARKER (OVERLAY_END (old_overlay
))->insertion_type
;
466 overlay
= allocate_misc ();
467 XMISCTYPE (overlay
) = Lisp_Misc_Overlay
;
468 OVERLAY_START (overlay
) = start
;
469 OVERLAY_END (overlay
) = end
;
470 OVERLAY_PLIST (overlay
) = Fcopy_sequence (OVERLAY_PLIST (old_overlay
));
471 XOVERLAY (overlay
)->next
= NULL
;
474 tail
= tail
->next
= XOVERLAY (overlay
);
476 result
= tail
= XOVERLAY (overlay
);
483 /* Clone per-buffer values of buffer FROM.
485 Buffer TO gets the same per-buffer values as FROM, with the
486 following exceptions: (1) TO's name is left untouched, (2) markers
487 are copied and made to refer to TO, and (3) overlay lists are
491 clone_per_buffer_values (from
, to
)
492 struct buffer
*from
, *to
;
494 Lisp_Object to_buffer
;
497 XSETBUFFER (to_buffer
, to
);
499 /* buffer-local Lisp variables start at `undo_list',
500 tho only the ones from `name' on are GC'd normally. */
501 for (offset
= PER_BUFFER_VAR_OFFSET (undo_list
);
503 offset
+= sizeof (Lisp_Object
))
507 /* Don't touch the `name' which should be unique for every buffer. */
508 if (offset
== PER_BUFFER_VAR_OFFSET (name
))
511 obj
= PER_BUFFER_VALUE (from
, offset
);
514 struct Lisp_Marker
*m
= XMARKER (obj
);
515 obj
= Fmake_marker ();
516 XMARKER (obj
)->insertion_type
= m
->insertion_type
;
517 set_marker_both (obj
, to_buffer
, m
->charpos
, m
->bytepos
);
520 SET_PER_BUFFER_VALUE_RAW (to
, offset
, obj
);
523 bcopy (from
->local_flags
, to
->local_flags
, sizeof to
->local_flags
);
525 to
->overlays_before
= copy_overlays (to
, from
->overlays_before
);
526 to
->overlays_after
= copy_overlays (to
, from
->overlays_after
);
528 /* Get (a copy of) the alist of Lisp-level local variables of FROM
529 and install that in TO. */
530 BUF_LOCAL_VAR_ALIST (to
) = buffer_lisp_local_variables (from
);
533 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer
, Smake_indirect_buffer
,
535 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ",
536 doc
: /* Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.
537 BASE-BUFFER should be a live buffer, or the name of an existing buffer.
538 NAME should be a string which is not the name of an existing buffer.
539 Optional argument CLONE non-nil means preserve BASE-BUFFER's state,
540 such as major and minor modes, in the indirect buffer.
541 CLONE nil means the indirect buffer's state is reset to default values. */)
542 (base_buffer
, name
, clone
)
543 Lisp_Object base_buffer
, name
, clone
;
545 Lisp_Object buf
, tem
;
549 buf
= Fget_buffer (name
);
551 error ("Buffer name `%s' is in use", SDATA (name
));
554 base_buffer
= Fget_buffer (base_buffer
);
555 if (NILP (base_buffer
))
556 error ("No such buffer: `%s'", SDATA (tem
));
557 if (NILP (BUF_NAME (XBUFFER (base_buffer
))))
558 error ("Base buffer has been killed");
560 if (SCHARS (name
) == 0)
561 error ("Empty string for buffer name is not allowed");
563 b
= allocate_buffer ();
565 b
->base_buffer
= (XBUFFER (base_buffer
)->base_buffer
566 ? XBUFFER (base_buffer
)->base_buffer
567 : XBUFFER (base_buffer
));
569 /* Use the base buffer's text object. */
570 b
->text
= b
->base_buffer
->text
;
572 BUF_BEGV (b
) = BUF_BEGV (b
->base_buffer
);
573 BUF_ZV (b
) = BUF_ZV (b
->base_buffer
);
574 BUF_PT (b
) = BUF_PT (b
->base_buffer
);
575 BUF_BEGV_BYTE (b
) = BUF_BEGV_BYTE (b
->base_buffer
);
576 BUF_ZV_BYTE (b
) = BUF_ZV_BYTE (b
->base_buffer
);
577 BUF_PT_BYTE (b
) = BUF_PT_BYTE (b
->base_buffer
);
579 b
->newline_cache
= 0;
580 b
->width_run_cache
= 0;
581 BUF_WIDTH_TABLE (b
) = Qnil
;
583 /* Put this on the chain of all buffers including killed ones. */
584 b
->next
= all_buffers
;
587 name
= Fcopy_sequence (name
);
588 STRING_SET_INTERVALS (name
, NULL_INTERVAL
);
592 reset_buffer_local_variables (b
, 1);
594 /* Put this in the alist of all live buffers. */
596 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buf
), Qnil
));
598 BUF_MARK (b
) = Fmake_marker ();
601 /* The multibyte status belongs to the base buffer. */
602 BUF_ENABLE_MULTIBYTE_CHARACTERS (b
) = BUF_ENABLE_MULTIBYTE_CHARACTERS (b
->base_buffer
);
604 /* Make sure the base buffer has markers for its narrowing. */
605 if (NILP (BUF_PT_MARKER (b
->base_buffer
)))
607 BUF_PT_MARKER (b
->base_buffer
) = Fmake_marker ();
608 set_marker_both (BUF_PT_MARKER (b
->base_buffer
), base_buffer
,
609 BUF_PT (b
->base_buffer
),
610 BUF_PT_BYTE (b
->base_buffer
));
612 if (NILP (BUF_BEGV_MARKER (b
->base_buffer
)))
614 BUF_BEGV_MARKER (b
->base_buffer
) = Fmake_marker ();
615 set_marker_both (BUF_BEGV_MARKER (b
->base_buffer
), base_buffer
,
616 BUF_BEGV (b
->base_buffer
),
617 BUF_BEGV_BYTE (b
->base_buffer
));
619 if (NILP (BUF_ZV_MARKER (b
->base_buffer
)))
621 BUF_ZV_MARKER (b
->base_buffer
) = Fmake_marker ();
622 set_marker_both (BUF_ZV_MARKER (b
->base_buffer
), base_buffer
,
623 BUF_ZV (b
->base_buffer
),
624 BUF_ZV_BYTE (b
->base_buffer
));
625 XMARKER (BUF_ZV_MARKER (b
->base_buffer
))->insertion_type
= 1;
630 /* Give the indirect buffer markers for its narrowing. */
631 BUF_PT_MARKER (b
) = Fmake_marker ();
632 set_marker_both (BUF_PT_MARKER (b
), buf
, BUF_PT (b
), BUF_PT_BYTE (b
));
633 BUF_BEGV_MARKER (b
) = Fmake_marker ();
634 set_marker_both (BUF_BEGV_MARKER (b
), buf
, BUF_BEGV (b
), BUF_BEGV_BYTE (b
));
635 BUF_ZV_MARKER (b
) = Fmake_marker ();
636 set_marker_both (BUF_ZV_MARKER (b
), buf
, BUF_ZV (b
), BUF_ZV_BYTE (b
));
637 XMARKER (BUF_ZV_MARKER (b
))->insertion_type
= 1;
641 struct buffer
*old_b
= current_buffer
;
643 clone_per_buffer_values (b
->base_buffer
, b
);
644 BUF_FILENAME (b
) = Qnil
;
645 BUF_FILE_TRUENAME (b
) = Qnil
;
646 BUF_DISPLAY_COUNT (b
) = make_number (0);
647 BUF_BACKED_UP (b
) = Qnil
;
648 BUF_AUTO_SAVE_FILE_NAME (b
) = Qnil
;
649 set_buffer_internal_1 (b
);
650 Fset (intern ("buffer-save-without-query"), Qnil
);
651 Fset (intern ("buffer-file-number"), Qnil
);
652 Fset (intern ("buffer-stale-function"), Qnil
);
653 set_buffer_internal_1 (old_b
);
660 delete_all_overlays (b
)
665 /* `reset_buffer' blindly sets the list of overlays to NULL, so we
666 have to empty the list, otherwise we end up with overlays that
667 think they belong to this buffer while the buffer doesn't know about
669 while (b
->overlays_before
)
671 XSETMISC (overlay
, b
->overlays_before
);
672 Fdelete_overlay (overlay
);
674 while (b
->overlays_after
)
676 XSETMISC (overlay
, b
->overlays_after
);
677 Fdelete_overlay (overlay
);
679 eassert (b
->overlays_before
== NULL
);
680 eassert (b
->overlays_after
== NULL
);
683 /* Reinitialize everything about a buffer except its name and contents
685 If called on an already-initialized buffer, the list of overlays
686 should be deleted before calling this function, otherwise we end up
687 with overlays that claim to belong to the buffer but the buffer
688 claims it doesn't belong to it. */
692 register struct buffer
*b
;
695 b
->file_truename_
= Qnil
;
696 b
->directory_
= (current_buffer
) ? current_buffer
->directory_
: Qnil
;
698 XSETFASTINT (b
->save_length_
, 0);
699 b
->last_window_start
= 1;
700 /* It is more conservative to start out "changed" than "unchanged". */
702 b
->prevent_redisplay_optimizations_p
= 1;
703 b
->backed_up_
= Qnil
;
704 BUF_AUTOSAVE_MODIFF (b
) = 0;
705 b
->auto_save_failure_time
= -1;
706 b
->auto_save_file_name_
= Qnil
;
707 b
->read_only_
= Qnil
;
708 b
->overlays_before
= NULL
;
709 b
->overlays_after
= NULL
;
710 b
->overlay_center
= BEG
;
711 b
->mark_active_
= Qnil
;
712 b
->point_before_scroll_
= Qnil
;
713 b
->file_format_
= Qnil
;
714 b
->auto_save_file_format_
= Qt
;
715 b
->last_selected_window_
= Qnil
;
716 XSETINT (b
->display_count_
, 0);
717 b
->display_time_
= Qnil
;
718 b
->enable_multibyte_characters_
= buffer_defaults
.enable_multibyte_characters_
;
719 b
->cursor_type_
= buffer_defaults
.cursor_type_
;
720 b
->extra_line_spacing_
= buffer_defaults
.extra_line_spacing_
;
722 b
->display_error_modiff
= 0;
725 /* Reset buffer B's local variables info.
726 Don't use this on a buffer that has already been in use;
727 it does not treat permanent locals consistently.
728 Instead, use Fkill_all_local_variables.
730 If PERMANENT_TOO is 1, then we reset permanent
731 buffer-local variables. If PERMANENT_TOO is 0,
732 we preserve those. */
735 reset_buffer_local_variables (b
, permanent_too
)
736 register struct buffer
*b
;
742 /* Reset the major mode to Fundamental, together with all the
743 things that depend on the major mode.
744 default-major-mode is handled at a higher level.
745 We ignore it here. */
746 b
->major_mode_
= Qfundamental_mode
;
748 b
->mode_name_
= QSFundamental
;
749 b
->minor_modes_
= Qnil
;
751 /* If the standard case table has been altered and invalidated,
752 fix up its insides first. */
753 if (! (CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[0])
754 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[1])
755 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[2])))
756 Fset_standard_case_table (Vascii_downcase_table
);
758 b
->downcase_table_
= Vascii_downcase_table
;
759 b
->upcase_table_
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[0];
760 b
->case_canon_table_
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[1];
761 b
->case_eqv_table_
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[2];
762 b
->invisibility_spec_
= Qt
;
764 b
->buffer_file_type_
= Qnil
;
767 /* Reset all (or most) per-buffer variables to their defaults. */
769 b
->local_var_alist_
= Qnil
;
772 Lisp_Object tmp
, prop
, last
= Qnil
;
773 for (tmp
= b
->local_var_alist_
; CONSP (tmp
); tmp
= XCDR (tmp
))
774 if (CONSP (XCAR (tmp
))
775 && SYMBOLP (XCAR (XCAR (tmp
)))
776 && !NILP (prop
= Fget (XCAR (XCAR (tmp
)), Qpermanent_local
)))
778 /* If permanent-local, keep it. */
780 if (EQ (prop
, Qpermanent_local_hook
))
782 /* This is a partially permanent hook variable.
783 Preserve only the elements that want to be preserved. */
784 Lisp_Object list
, newlist
;
785 list
= XCDR (XCAR (tmp
));
789 for (newlist
= Qnil
; CONSP (list
); list
= XCDR (list
))
791 Lisp_Object elt
= XCAR (list
);
792 /* Preserve element ELT if it's t,
793 if it is a function with a `permanent-local-hook' property,
794 or if it's not a symbol. */
797 || !NILP (Fget (elt
, Qpermanent_local_hook
)))
798 newlist
= Fcons (elt
, newlist
);
800 XSETCDR (XCAR (tmp
), Fnreverse (newlist
));
803 /* Delete this local variable. */
804 else if (NILP (last
))
805 b
->local_var_alist_
= XCDR (tmp
);
807 XSETCDR (last
, XCDR (tmp
));
810 for (i
= 0; i
< last_per_buffer_idx
; ++i
)
811 if (permanent_too
|| buffer_permanent_local_flags
[i
] == 0)
812 SET_PER_BUFFER_VALUE_P (b
, i
, 0);
814 /* For each slot that has a default value,
815 copy that into the slot. */
817 /* buffer-local Lisp variables start at `undo_list',
818 tho only the ones from `name' on are GC'd normally. */
819 for (offset
= PER_BUFFER_VAR_OFFSET (undo_list
);
821 offset
+= sizeof (Lisp_Object
))
823 int idx
= PER_BUFFER_IDX (offset
);
826 || buffer_permanent_local_flags
[idx
] == 0))
827 /* Is -2 used anywhere? */
829 SET_PER_BUFFER_VALUE_RAW (b
, offset
, PER_BUFFER_DEFAULT (offset
));
833 /* We split this away from generate-new-buffer, because rename-buffer
834 and set-visited-file-name ought to be able to use this to really
835 rename the buffer properly. */
837 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name
, Sgenerate_new_buffer_name
,
839 doc
: /* Return a string that is the name of no existing buffer based on NAME.
840 If there is no live buffer named NAME, then return NAME.
841 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
842 \(starting at 2) until an unused name is found, and then return that name.
843 Optional second argument IGNORE specifies a name that is okay to use (if
844 it is in the sequence to be tried) even if a buffer with that name exists. */)
846 register Lisp_Object name
, ignore
;
848 register Lisp_Object gentemp
, tem
;
854 tem
= Fstring_equal (name
, ignore
);
857 tem
= Fget_buffer (name
);
864 sprintf (number
, "<%d>", ++count
);
865 gentemp
= concat2 (name
, build_string (number
));
866 tem
= Fstring_equal (gentemp
, ignore
);
869 tem
= Fget_buffer (gentemp
);
876 DEFUN ("buffer-name", Fbuffer_name
, Sbuffer_name
, 0, 1, 0,
877 doc
: /* Return the name of BUFFER, as a string.
878 BUFFER defaults to the current buffer.
879 Return nil if BUFFER has been killed. */)
881 register Lisp_Object buffer
;
884 return BUF_NAME (current_buffer
);
885 CHECK_BUFFER (buffer
);
886 return BUF_NAME (XBUFFER (buffer
));
889 DEFUN ("buffer-file-name", Fbuffer_file_name
, Sbuffer_file_name
, 0, 1, 0,
890 doc
: /* Return name of file BUFFER is visiting, or nil if none.
891 No argument or nil as argument means use the current buffer. */)
893 register Lisp_Object buffer
;
896 return BUF_FILENAME (current_buffer
);
897 CHECK_BUFFER (buffer
);
898 return BUF_FILENAME (XBUFFER (buffer
));
901 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer
, Sbuffer_base_buffer
,
903 doc
: /* Return the base buffer of indirect buffer BUFFER.
904 If BUFFER is not indirect, return nil.
905 BUFFER defaults to the current buffer. */)
907 register Lisp_Object buffer
;
910 Lisp_Object base_buffer
;
913 base
= current_buffer
->base_buffer
;
916 CHECK_BUFFER (buffer
);
917 base
= XBUFFER (buffer
)->base_buffer
;
922 XSETBUFFER (base_buffer
, base
);
926 DEFUN ("buffer-local-value", Fbuffer_local_value
,
927 Sbuffer_local_value
, 2, 2, 0,
928 doc
: /* Return the value of VARIABLE in BUFFER.
929 If VARIABLE does not have a buffer-local binding in BUFFER, the value
930 is the default binding of the variable. */)
932 register Lisp_Object variable
;
933 register Lisp_Object buffer
;
935 register struct buffer
*buf
;
936 register Lisp_Object result
;
937 struct Lisp_Symbol
*sym
;
939 CHECK_SYMBOL (variable
);
940 CHECK_BUFFER (buffer
);
941 buf
= XBUFFER (buffer
);
943 sym
= indirect_variable (XSYMBOL (variable
));
944 XSETSYMBOL (variable
, sym
);
946 /* Look in local_var_list */
947 result
= Fassoc (variable
, BUF_LOCAL_VAR_ALIST (buf
));
953 /* Look in special slots */
954 /* buffer-local Lisp variables start at `undo_list',
955 tho only the ones from `name' on are GC'd normally. */
956 for (offset
= PER_BUFFER_VAR_OFFSET (undo_list
);
957 offset
< sizeof (struct buffer
);
958 /* sizeof EMACS_INT == sizeof Lisp_Object */
959 offset
+= (sizeof (EMACS_INT
)))
961 idx
= PER_BUFFER_IDX (offset
);
962 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
963 && SYMBOLP (PER_BUFFER_SYMBOL (offset
))
964 && EQ (PER_BUFFER_SYMBOL (offset
), variable
))
966 result
= PER_BUFFER_VALUE (buf
, offset
);
973 result
= Fdefault_value (variable
);
977 Lisp_Object valcontents
;
978 Lisp_Object current_alist_element
;
980 /* What binding is loaded right now? */
981 valcontents
= sym
->value
;
982 current_alist_element
983 = XCAR (BLOCAL_CDR (XBUFFER_LOCAL_VALUE (valcontents
)));
985 /* The value of the currently loaded binding is not
986 stored in it, but rather in the realvalue slot.
987 Store that value into the binding it belongs to
988 in case that is the one we are about to use. */
990 Fsetcdr (current_alist_element
,
991 do_symval_forwarding (BLOCAL_REALVALUE (XBUFFER_LOCAL_VALUE (valcontents
))));
993 /* Now get the (perhaps updated) value out of the binding. */
994 result
= XCDR (result
);
997 if (!EQ (result
, Qunbound
))
1000 xsignal1 (Qvoid_variable
, variable
);
1003 /* Return an alist of the Lisp-level buffer-local bindings of
1004 buffer BUF. That is, don't include the variables maintained
1005 in special slots in the buffer object. */
1008 buffer_lisp_local_variables (buf
)
1011 Lisp_Object result
= Qnil
;
1012 register Lisp_Object tail
;
1013 for (tail
= BUF_LOCAL_VAR_ALIST (buf
); CONSP (tail
); tail
= XCDR (tail
))
1015 Lisp_Object val
, elt
;
1019 /* Reference each variable in the alist in buf.
1020 If inquiring about the current buffer, this gets the current values,
1021 so store them into the alist so the alist is up to date.
1022 If inquiring about some other buffer, this swaps out any values
1023 for that buffer, making the alist up to date automatically. */
1024 val
= find_symbol_value (XCAR (elt
));
1025 /* Use the current buffer value only if buf is the current buffer. */
1026 if (buf
!= current_buffer
)
1029 /* If symbol is unbound, put just the symbol in the list. */
1030 if (EQ (val
, Qunbound
))
1031 result
= Fcons (XCAR (elt
), result
);
1032 /* Otherwise, put (symbol . value) in the list. */
1034 result
= Fcons (Fcons (XCAR (elt
), val
), result
);
1040 DEFUN ("buffer-local-variables", Fbuffer_local_variables
,
1041 Sbuffer_local_variables
, 0, 1, 0,
1042 doc
: /* Return an alist of variables that are buffer-local in BUFFER.
1043 Most elements look like (SYMBOL . VALUE), describing one variable.
1044 For a symbol that is locally unbound, just the symbol appears in the value.
1045 Note that storing new VALUEs in these elements doesn't change the variables.
1046 No argument or nil as argument means use current buffer as BUFFER. */)
1048 register Lisp_Object buffer
;
1050 register struct buffer
*buf
;
1051 register Lisp_Object result
;
1054 buf
= current_buffer
;
1057 CHECK_BUFFER (buffer
);
1058 buf
= XBUFFER (buffer
);
1061 result
= buffer_lisp_local_variables (buf
);
1063 /* Add on all the variables stored in special slots. */
1067 /* buffer-local Lisp variables start at `undo_list',
1068 tho only the ones from `name' on are GC'd normally. */
1069 for (offset
= PER_BUFFER_VAR_OFFSET (undo_list
);
1070 offset
< sizeof (struct buffer
);
1071 /* sizeof EMACS_INT == sizeof Lisp_Object */
1072 offset
+= (sizeof (EMACS_INT
)))
1074 idx
= PER_BUFFER_IDX (offset
);
1075 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
1076 && SYMBOLP (PER_BUFFER_SYMBOL (offset
)))
1077 result
= Fcons (Fcons (PER_BUFFER_SYMBOL (offset
),
1078 PER_BUFFER_VALUE (buf
, offset
)),
1086 DEFUN ("buffer-modified-p", Fbuffer_modified_p
, Sbuffer_modified_p
,
1088 doc
: /* Return t if BUFFER was modified since its file was last read or saved.
1089 No argument or nil as argument means use current buffer as BUFFER. */)
1091 register Lisp_Object buffer
;
1093 register struct buffer
*buf
;
1095 buf
= current_buffer
;
1098 CHECK_BUFFER (buffer
);
1099 buf
= XBUFFER (buffer
);
1102 return BUF_SAVE_MODIFF (buf
) < BUF_MODIFF (buf
) ? Qt
: Qnil
;
1105 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p
, Sset_buffer_modified_p
,
1107 doc
: /* Mark current buffer as modified or unmodified according to FLAG.
1108 A non-nil FLAG means mark the buffer modified. */)
1110 register Lisp_Object flag
;
1112 register int already
;
1113 register Lisp_Object fn
;
1114 Lisp_Object buffer
, window
;
1116 #ifdef CLASH_DETECTION
1117 /* If buffer becoming modified, lock the file.
1118 If buffer becoming unmodified, unlock the file. */
1120 fn
= BUF_FILE_TRUENAME (current_buffer
);
1121 /* Test buffer-file-name so that binding it to nil is effective. */
1122 if (!NILP (fn
) && ! NILP (BUF_FILENAME (current_buffer
)))
1124 already
= SAVE_MODIFF
< MODIFF
;
1125 if (!already
&& !NILP (flag
))
1127 else if (already
&& NILP (flag
))
1130 #endif /* CLASH_DETECTION */
1132 /* Here we have a problem. SAVE_MODIFF is used here to encode
1133 buffer-modified-p (as SAVE_MODIFF<MODIFF) as well as
1134 recent-auto-save-p (as SAVE_MODIFF<auto_save_modified). So if we
1135 modify SAVE_MODIFF to affect one, we may affect the other
1137 E.g. if FLAG is nil we need to set SAVE_MODIFF to MODIFF, but
1138 if SAVE_MODIFF<auto_save_modified that means we risk changing
1139 recent-auto-save-p from t to nil.
1140 Vice versa, if FLAG is non-nil and SAVE_MODIFF>=auto_save_modified
1141 we risk changing recent-auto-save-p from nil to t. */
1142 SAVE_MODIFF
= (NILP (flag
)
1143 /* FIXME: This unavoidably sets recent-auto-save-p to nil. */
1145 /* Let's try to preserve recent-auto-save-p. */
1146 : SAVE_MODIFF
< MODIFF
? SAVE_MODIFF
1147 /* If SAVE_MODIFF == auto_save_modified == MODIFF,
1148 we can either decrease SAVE_MODIFF and auto_save_modified
1149 or increase MODIFF. */
1152 /* Set update_mode_lines only if buffer is displayed in some window.
1153 Packages like jit-lock or lazy-lock preserve a buffer's modified
1154 state by recording/restoring the state around blocks of code.
1155 Setting update_mode_lines makes redisplay consider all windows
1156 (on all frames). Stealth fontification of buffers not displayed
1157 would incur additional redisplay costs if we'd set
1158 update_modes_lines unconditionally.
1160 Ideally, I think there should be another mechanism for fontifying
1161 buffers without "modifying" buffers, or redisplay should be
1162 smarter about updating the `*' in mode lines. --gerd */
1163 XSETBUFFER (buffer
, current_buffer
);
1164 window
= Fget_buffer_window (buffer
, Qt
);
1165 if (WINDOWP (window
))
1167 ++update_mode_lines
;
1168 current_buffer
->prevent_redisplay_optimizations_p
= 1;
1174 DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p
,
1175 Srestore_buffer_modified_p
, 1, 1, 0,
1176 doc
: /* Like `set-buffer-modified-p', with a difference concerning redisplay.
1177 It is not ensured that mode lines will be updated to show the modified
1178 state of the current buffer. Use with care. */)
1182 #ifdef CLASH_DETECTION
1185 /* If buffer becoming modified, lock the file.
1186 If buffer becoming unmodified, unlock the file. */
1188 fn
= BUF_FILE_TRUENAME (current_buffer
);
1189 /* Test buffer-file-name so that binding it to nil is effective. */
1190 if (!NILP (fn
) && ! NILP (BUF_FILENAME (current_buffer
)))
1192 int already
= SAVE_MODIFF
< MODIFF
;
1193 if (!already
&& !NILP (flag
))
1195 else if (already
&& NILP (flag
))
1198 #endif /* CLASH_DETECTION */
1200 SAVE_MODIFF
= NILP (flag
) ? MODIFF
: 0;
1204 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick
, Sbuffer_modified_tick
,
1206 doc
: /* Return BUFFER's tick counter, incremented for each change in text.
1207 Each buffer has a tick counter which is incremented each time the
1208 text in that buffer is changed. It wraps around occasionally.
1209 No argument or nil as argument means use current buffer as BUFFER. */)
1211 register Lisp_Object buffer
;
1213 register struct buffer
*buf
;
1215 buf
= current_buffer
;
1218 CHECK_BUFFER (buffer
);
1219 buf
= XBUFFER (buffer
);
1222 return make_number (BUF_MODIFF (buf
));
1225 DEFUN ("buffer-chars-modified-tick", Fbuffer_chars_modified_tick
,
1226 Sbuffer_chars_modified_tick
, 0, 1, 0,
1227 doc
: /* Return BUFFER's character-change tick counter.
1228 Each buffer has a character-change tick counter, which is set to the
1229 value of the buffer's tick counter \(see `buffer-modified-tick'), each
1230 time text in that buffer is inserted or deleted. By comparing the
1231 values returned by two individual calls of `buffer-chars-modified-tick',
1232 you can tell whether a character change occurred in that buffer in
1233 between these calls. No argument or nil as argument means use current
1234 buffer as BUFFER. */)
1236 register Lisp_Object buffer
;
1238 register struct buffer
*buf
;
1240 buf
= current_buffer
;
1243 CHECK_BUFFER (buffer
);
1244 buf
= XBUFFER (buffer
);
1247 return make_number (BUF_CHARS_MODIFF (buf
));
1250 DEFUN ("rename-buffer", Frename_buffer
, Srename_buffer
, 1, 2,
1251 "(list (read-string \"Rename buffer (to new name): \" \
1252 nil 'buffer-name-history (buffer-name (current-buffer))) \
1253 current-prefix-arg)",
1254 doc
: /* Change current buffer's name to NEWNAME (a string).
1255 If second arg UNIQUE is nil or omitted, it is an error if a
1256 buffer named NEWNAME already exists.
1257 If UNIQUE is non-nil, come up with a new name using
1258 `generate-new-buffer-name'.
1259 Interactively, you can set UNIQUE with a prefix argument.
1260 We return the name we actually gave the buffer.
1261 This does not change the name of the visited file (if any). */)
1263 register Lisp_Object newname
, unique
;
1265 register Lisp_Object tem
, buf
;
1267 CHECK_STRING (newname
);
1269 if (SCHARS (newname
) == 0)
1270 error ("Empty string is invalid as a buffer name");
1272 tem
= Fget_buffer (newname
);
1275 /* Don't short-circuit if UNIQUE is t. That is a useful way to
1276 rename the buffer automatically so you can create another
1277 with the original name. It makes UNIQUE equivalent to
1278 (rename-buffer (generate-new-buffer-name NEWNAME)). */
1279 if (NILP (unique
) && XBUFFER (tem
) == current_buffer
)
1280 return BUF_NAME (current_buffer
);
1282 newname
= Fgenerate_new_buffer_name (newname
, BUF_NAME (current_buffer
));
1284 error ("Buffer name `%s' is in use", SDATA (newname
));
1287 BUF_NAME (current_buffer
) = newname
;
1289 /* Catch redisplay's attention. Unless we do this, the mode lines for
1290 any windows displaying current_buffer will stay unchanged. */
1291 update_mode_lines
++;
1293 XSETBUFFER (buf
, current_buffer
);
1294 Fsetcar (Frassq (buf
, Vbuffer_alist
), newname
);
1295 if (NILP (BUF_FILENAME (current_buffer
))
1296 && !NILP (BUF_AUTO_SAVE_FILE_NAME (current_buffer
)))
1297 call0 (intern ("rename-auto-save-file"));
1298 /* Refetch since that last call may have done GC. */
1299 return BUF_NAME (current_buffer
);
1302 DEFUN ("other-buffer", Fother_buffer
, Sother_buffer
, 0, 3, 0,
1303 doc
: /* Return most recently selected buffer other than BUFFER.
1304 Buffers not visible in windows are preferred to visible buffers,
1305 unless optional second argument VISIBLE-OK is non-nil.
1306 If the optional third argument FRAME is non-nil, use that frame's
1307 buffer list instead of the selected frame's buffer list.
1308 If no other buffer exists, the buffer `*scratch*' is returned.
1309 If BUFFER is omitted or nil, some interesting buffer is returned. */)
1310 (buffer
, visible_ok
, frame
)
1311 register Lisp_Object buffer
, visible_ok
, frame
;
1313 Lisp_Object
Fset_buffer_major_mode ();
1314 register Lisp_Object tail
, buf
, notsogood
, tem
, pred
, add_ons
;
1318 frame
= selected_frame
;
1320 tail
= Vbuffer_alist
;
1321 pred
= frame_buffer_predicate (frame
);
1323 /* Consider buffers that have been seen in the selected frame
1324 before other buffers. */
1326 tem
= frame_buffer_list (frame
);
1330 if (BUFFERP (XCAR (tem
)))
1331 add_ons
= Fcons (Fcons (Qnil
, XCAR (tem
)), add_ons
);
1334 tail
= nconc2 (Fnreverse (add_ons
), tail
);
1336 for (; CONSP (tail
); tail
= XCDR (tail
))
1338 buf
= Fcdr (XCAR (tail
));
1339 if (EQ (buf
, buffer
))
1343 if (NILP (BUF_NAME (XBUFFER (buf
))))
1345 if (SREF (BUF_NAME (XBUFFER (buf
)), 0) == ' ')
1347 /* If the selected frame has a buffer_predicate,
1348 disregard buffers that don't fit the predicate. */
1351 tem
= call1 (pred
, buf
);
1356 if (NILP (visible_ok
))
1357 tem
= Fget_buffer_window (buf
, Qvisible
);
1362 if (NILP (notsogood
))
1365 if (!NILP (notsogood
))
1367 buf
= Fget_buffer (build_string ("*scratch*"));
1370 buf
= Fget_buffer_create (build_string ("*scratch*"));
1371 Fset_buffer_major_mode (buf
);
1376 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo
, Sbuffer_enable_undo
,
1378 doc
: /* Start keeping undo information for buffer BUFFER.
1379 No argument or nil as argument means do this for the current buffer. */)
1381 register Lisp_Object buffer
;
1383 Lisp_Object real_buffer
;
1386 XSETBUFFER (real_buffer
, current_buffer
);
1389 real_buffer
= Fget_buffer (buffer
);
1390 if (NILP (real_buffer
))
1394 if (EQ (BUF_UNDO_LIST (XBUFFER (real_buffer
)), Qt
))
1395 BUF_UNDO_LIST (XBUFFER (real_buffer
)) = Qnil
;
1401 DEFVAR_LISP ("kill-buffer-hook", no_cell, "\
1402 Hook to be run (by `run-hooks', which see) when a buffer is killed.\n\
1403 The buffer being killed will be current while the hook is running.\n\
1406 DEFUN ("kill-buffer", Fkill_buffer
, Skill_buffer
, 0, 1, "bKill buffer: ",
1407 doc
: /* Kill buffer BUFFER-OR-NAME.
1408 The argument may be a buffer or the name of an existing buffer.
1409 Argument nil or omitted means kill the current buffer. Return t if the
1410 buffer is actually killed, nil otherwise.
1412 This function calls `replace-buffer-in-windows' for cleaning up all
1413 windows currently displaying the buffer to be killed. The functions in
1414 `kill-buffer-query-functions' are called with the buffer to be killed as
1415 the current buffer. If any of them returns nil, the buffer is not
1416 killed. The hook `kill-buffer-hook' is run before the buffer is
1417 actually killed. The buffer being killed will be current while the hook
1420 Any processes that have this buffer as the `process-buffer' are killed
1423 Lisp_Object buffer_or_name
;
1426 register struct buffer
*b
;
1427 register Lisp_Object tem
;
1428 register struct Lisp_Marker
*m
;
1429 struct gcpro gcpro1
;
1431 if (NILP (buffer_or_name
))
1432 buffer
= Fcurrent_buffer ();
1434 buffer
= Fget_buffer (buffer_or_name
);
1436 nsberror (buffer_or_name
);
1438 b
= XBUFFER (buffer
);
1440 /* Avoid trouble for buffer already dead. */
1441 if (NILP (BUF_NAME (b
)))
1444 /* Query if the buffer is still modified. */
1445 if (INTERACTIVE
&& !NILP (BUF_FILENAME (b
))
1446 && BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
1449 tem
= do_yes_or_no_p (format2 ("Buffer %s modified; kill anyway? ",
1450 BUF_NAME (b
), make_number (0)));
1456 /* Run hooks with the buffer to be killed the current buffer. */
1458 int count
= SPECPDL_INDEX ();
1459 Lisp_Object arglist
[1];
1461 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1462 set_buffer_internal (b
);
1464 /* First run the query functions; if any query is answered no,
1465 don't kill the buffer. */
1466 arglist
[0] = Qkill_buffer_query_functions
;
1467 tem
= Frun_hook_with_args_until_failure (1, arglist
);
1469 return unbind_to (count
, Qnil
);
1471 /* Then run the hooks. */
1472 Frun_hooks (1, &Qkill_buffer_hook
);
1473 unbind_to (count
, Qnil
);
1476 /* We have no more questions to ask. Verify that it is valid
1477 to kill the buffer. This must be done after the questions
1478 since anything can happen within do_yes_or_no_p. */
1480 /* Don't kill the minibuffer now current. */
1481 if (EQ (buffer
, XWINDOW (minibuf_window
)->buffer
))
1484 if (NILP (BUF_NAME (b
)))
1487 /* When we kill a base buffer, kill all its indirect buffers.
1488 We do it at this stage so nothing terrible happens if they
1489 ask questions or their hooks get errors. */
1490 if (! b
->base_buffer
)
1492 struct buffer
*other
;
1496 for (other
= all_buffers
; other
; other
= other
->next
)
1497 /* all_buffers contains dead buffers too;
1498 don't re-kill them. */
1499 if (other
->base_buffer
== b
&& !NILP (BUF_NAME (other
)))
1502 XSETBUFFER (buffer
, other
);
1503 Fkill_buffer (buffer
);
1509 /* Make this buffer not be current.
1510 In the process, notice if this is the sole visible buffer
1511 and give up if so. */
1512 if (NILP (thread_notify_kill_buffer (b
)))
1515 /* Notice if the buffer to kill is the sole visible buffer
1516 when we're currently in the mini-buffer, and give up if so. */
1517 XSETBUFFER (tem
, current_buffer
);
1518 if (EQ (tem
, XWINDOW (minibuf_window
)->buffer
))
1520 tem
= Fother_buffer (buffer
, Qnil
, Qnil
);
1521 if (EQ (buffer
, tem
))
1525 /* Now there is no question: we can kill the buffer. */
1527 #ifdef CLASH_DETECTION
1528 /* Unlock this buffer's file, if it is locked. */
1530 #endif /* CLASH_DETECTION */
1533 kill_buffer_processes (buffer
);
1536 /* Killing buffer processes may run sentinels which may
1537 have called kill-buffer. */
1539 if (NILP (BUF_NAME (b
)))
1542 clear_charpos_cache (b
);
1544 tem
= Vinhibit_quit
;
1546 replace_buffer_in_all_windows (buffer
);
1547 Vbuffer_alist
= Fdelq (Frassq (buffer
, Vbuffer_alist
), Vbuffer_alist
);
1548 frames_discard_buffer (buffer
);
1549 Vinhibit_quit
= tem
;
1551 /* Delete any auto-save file, if we saved it in this session.
1552 But not if the buffer is modified. */
1553 if (STRINGP (BUF_AUTO_SAVE_FILE_NAME (b
))
1554 && BUF_AUTOSAVE_MODIFF (b
) != 0
1555 && BUF_SAVE_MODIFF (b
) < BUF_AUTOSAVE_MODIFF (b
)
1556 && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
)
1557 && NILP (Fsymbol_value (intern ("auto-save-visited-file-name"))))
1560 tem
= Fsymbol_value (intern ("delete-auto-save-files"));
1562 internal_delete_file (BUF_AUTO_SAVE_FILE_NAME (b
));
1567 /* Unchain all markers that belong to this indirect buffer.
1568 Don't unchain the markers that belong to the base buffer
1569 or its other indirect buffers. */
1570 for (m
= BUF_MARKERS (b
); m
; )
1572 struct Lisp_Marker
*next
= m
->next
;
1580 /* Unchain all markers of this buffer and its indirect buffers.
1581 and leave them pointing nowhere. */
1582 for (m
= BUF_MARKERS (b
); m
; )
1584 struct Lisp_Marker
*next
= m
->next
;
1589 BUF_MARKERS (b
) = NULL
;
1590 BUF_INTERVALS (b
) = NULL_INTERVAL
;
1592 /* Perhaps we should explicitly free the interval tree here... */
1595 /* Reset the local variables, so that this buffer's local values
1596 won't be protected from GC. They would be protected
1597 if they happened to remain encached in their symbols.
1598 This gets rid of them for certain. */
1599 swap_out_buffer_local_variables (b
);
1600 reset_buffer_local_variables (b
, 1);
1602 BUF_NAME (b
) = Qnil
;
1605 if (! b
->base_buffer
)
1606 free_buffer_text (b
);
1608 if (b
->newline_cache
)
1610 free_region_cache (b
->newline_cache
);
1611 b
->newline_cache
= 0;
1613 if (b
->width_run_cache
)
1615 free_region_cache (b
->width_run_cache
);
1616 b
->width_run_cache
= 0;
1618 BUF_WIDTH_TABLE (b
) = Qnil
;
1620 BUF_UNDO_LIST (b
) = Qnil
;
1625 /* Move the assoc for buffer BUF to the front of buffer-alist. Since
1626 we do this each time BUF is selected visibly, the more recently
1627 selected buffers are always closer to the front of the list. This
1628 means that other_buffer is more likely to choose a relevant buffer. */
1634 register Lisp_Object link
, prev
;
1636 frame
= selected_frame
;
1639 for (link
= Vbuffer_alist
; CONSP (link
); link
= XCDR (link
))
1641 if (EQ (XCDR (XCAR (link
)), buf
))
1646 /* Effectively do Vbuffer_alist = Fdelq (link, Vbuffer_alist);
1647 we cannot use Fdelq itself here because it allows quitting. */
1650 Vbuffer_alist
= XCDR (Vbuffer_alist
);
1652 XSETCDR (prev
, XCDR (XCDR (prev
)));
1654 XSETCDR (link
, Vbuffer_alist
);
1655 Vbuffer_alist
= link
;
1657 /* Effectively do a delq on buried_buffer_list. */
1660 for (link
= XFRAME (frame
)->buried_buffer_list
; CONSP (link
);
1663 if (EQ (XCAR (link
), buf
))
1666 XFRAME (frame
)->buried_buffer_list
= XCDR (link
);
1668 XSETCDR (prev
, XCDR (XCDR (prev
)));
1674 /* Now move this buffer to the front of frame_buffer_list also. */
1677 for (link
= frame_buffer_list (frame
); CONSP (link
);
1680 if (EQ (XCAR (link
), buf
))
1685 /* Effectively do delq. */
1690 set_frame_buffer_list (frame
,
1691 XCDR (frame_buffer_list (frame
)));
1693 XSETCDR (prev
, XCDR (XCDR (prev
)));
1695 XSETCDR (link
, frame_buffer_list (frame
));
1696 set_frame_buffer_list (frame
, link
);
1699 set_frame_buffer_list (frame
, Fcons (buf
, frame_buffer_list (frame
)));
1702 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode
, Sset_buffer_major_mode
, 1, 1, 0,
1703 doc
: /* Set an appropriate major mode for BUFFER.
1704 For the *scratch* buffer, use `initial-major-mode', otherwise choose a mode
1705 according to `default-major-mode'.
1706 Use this function before selecting the buffer, since it may need to inspect
1707 the current buffer's major mode. */)
1712 Lisp_Object function
;
1714 CHECK_BUFFER (buffer
);
1716 if (STRINGP (BUF_NAME (XBUFFER (buffer
)))
1717 && strcmp (SDATA (BUF_NAME (XBUFFER (buffer
))), "*scratch*") == 0)
1718 function
= find_symbol_value (intern ("initial-major-mode"));
1721 function
= BUF_MAJOR_MODE (&buffer_defaults
);
1723 && NILP (Fget (BUF_MAJOR_MODE (current_buffer
), Qmode_class
)))
1724 function
= BUF_MAJOR_MODE (current_buffer
);
1727 if (NILP (function
) || EQ (function
, Qfundamental_mode
))
1730 count
= SPECPDL_INDEX ();
1732 /* To select a nonfundamental mode,
1733 select the buffer temporarily and then call the mode function. */
1735 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1737 Fset_buffer (buffer
);
1740 return unbind_to (count
, Qnil
);
1743 /* Switch to buffer BUFFER in the selected window.
1744 If NORECORD is non-nil, don't call record_buffer. */
1747 switch_to_buffer_1 (buffer_or_name
, norecord
)
1748 Lisp_Object buffer_or_name
, norecord
;
1750 register Lisp_Object buffer
;
1752 if (NILP (buffer_or_name
))
1753 buffer
= Fother_buffer (Fcurrent_buffer (), Qnil
, Qnil
);
1756 buffer
= Fget_buffer (buffer_or_name
);
1759 buffer
= Fget_buffer_create (buffer_or_name
);
1760 Fset_buffer_major_mode (buffer
);
1763 Fset_buffer (buffer
);
1764 if (NILP (norecord
))
1765 record_buffer (buffer
);
1767 Fset_window_buffer (EQ (selected_window
, minibuf_window
)
1768 ? Fnext_window (minibuf_window
, Qnil
, Qnil
)
1775 DEFUN ("switch-to-buffer", Fswitch_to_buffer
, Sswitch_to_buffer
, 1, 2,
1776 "(list (read-buffer-to-switch \"Switch to buffer: \"))",
1777 doc
: /* Make BUFFER-OR-NAME current and display it in selected window.
1778 BUFFER-OR-NAME may be a buffer, a string \(a buffer name), or
1779 nil. Return the buffer switched to.
1781 If BUFFER-OR-NAME is a string and does not identify an existing
1782 buffer, create a new buffer with that name. Interactively, if
1783 `confirm-nonexistent-file-or-buffer' is non-nil, request
1784 confirmation before creating a new buffer. If BUFFER-OR-NAME is
1785 nil, switch to buffer returned by `other-buffer'.
1787 Optional second arg NORECORD non-nil means do not put this buffer
1788 at the front of the list of recently selected ones. This
1789 function returns the buffer it switched to as a Lisp object.
1791 If the selected window is the minibuffer window or dedicated to
1792 its buffer, use `pop-to-buffer' for displaying the buffer.
1794 WARNING: This is NOT the way to work on another buffer temporarily
1795 within a Lisp program! Use `set-buffer' instead. That avoids
1796 messing with the window-buffer correspondences. */)
1797 (buffer_or_name
, norecord
)
1798 Lisp_Object buffer_or_name
, norecord
;
1802 if (EQ (buffer_or_name
, Fwindow_buffer (selected_window
)))
1804 /* Basically a NOP. Avoid signalling an error in the case where
1805 the selected window is dedicated, or a minibuffer. */
1807 /* But do put this buffer at the front of the buffer list, unless
1808 that has been inhibited. Note that even if BUFFER-OR-NAME is
1809 at the front of the main buffer-list already, we still want to
1810 move it to the front of the frame's buffer list. */
1811 if (NILP (norecord
))
1812 record_buffer (buffer_or_name
);
1813 return Fset_buffer (buffer_or_name
);
1815 else if (EQ (minibuf_window
, selected_window
)
1816 /* If `dedicated' is neither nil nor t, it means it's
1817 dedicatedness can be overridden by an explicit request
1818 such as a call to switch-to-buffer. */
1819 || EQ (Fwindow_dedicated_p (selected_window
), Qt
))
1820 /* We can't use the selected window so let `pop-to-buffer' try some
1822 return call3 (intern ("pop-to-buffer"), buffer_or_name
, Qnil
, norecord
);
1824 return switch_to_buffer_1 (buffer_or_name
, norecord
);
1827 DEFUN ("current-buffer", Fcurrent_buffer
, Scurrent_buffer
, 0, 0, 0,
1828 doc
: /* Return the current buffer as a Lisp object. */)
1831 register Lisp_Object buf
;
1832 XSETBUFFER (buf
, current_buffer
);
1836 /* Set the current buffer to B.
1838 We previously set windows_or_buffers_changed here to invalidate
1839 global unchanged information in beg_unchanged and end_unchanged.
1840 This is no longer necessary because we now compute unchanged
1841 information on a buffer-basis. Every action affecting other
1842 windows than the selected one requires a select_window at some
1843 time, and that increments windows_or_buffers_changed. */
1846 set_buffer_internal (b
)
1847 register struct buffer
*b
;
1849 if (current_buffer
!= b
)
1850 set_buffer_internal_1 (b
);
1853 /* Set the current buffer to B, and do not set windows_or_buffers_changed.
1854 This is used by redisplay. */
1857 set_buffer_internal_1 (b
)
1858 register struct buffer
*b
;
1860 register struct buffer
*old_buf
;
1861 register Lisp_Object tail
, valcontents
;
1864 #ifdef USE_MMAP_FOR_BUFFERS
1865 if (b
->text
->beg
== NULL
)
1866 enlarge_buffer_text (b
, 0);
1867 #endif /* USE_MMAP_FOR_BUFFERS */
1869 if (current_buffer
== b
)
1872 old_buf
= current_buffer
;
1874 last_known_column_point
= -1; /* invalidate indentation cache */
1878 /* Put the undo list back in the base buffer, so that it appears
1879 that an indirect buffer shares the undo list of its base. */
1880 if (old_buf
->base_buffer
)
1881 BUF_UNDO_LIST (old_buf
->base_buffer
) = BUF_UNDO_LIST (old_buf
);
1883 /* If the old current buffer has markers to record PT, BEGV and ZV
1884 when it is not current, update them now. */
1885 if (! NILP (BUF_PT_MARKER (old_buf
)))
1888 XSETBUFFER (obuf
, old_buf
);
1889 set_marker_both (BUF_PT_MARKER (old_buf
), obuf
,
1890 BUF_PT (old_buf
), BUF_PT_BYTE (old_buf
));
1892 if (! NILP (BUF_BEGV_MARKER (old_buf
)))
1895 XSETBUFFER (obuf
, old_buf
);
1896 set_marker_both (BUF_BEGV_MARKER (old_buf
), obuf
,
1897 BUF_BEGV (old_buf
), BUF_BEGV_BYTE (old_buf
));
1899 if (! NILP (BUF_ZV_MARKER (old_buf
)))
1902 XSETBUFFER (obuf
, old_buf
);
1903 set_marker_both (BUF_ZV_MARKER (old_buf
), obuf
,
1904 BUF_ZV (old_buf
), BUF_ZV_BYTE (old_buf
));
1908 /* Get the undo list from the base buffer, so that it appears
1909 that an indirect buffer shares the undo list of its base. */
1911 BUF_UNDO_LIST (b
) = BUF_UNDO_LIST (b
->base_buffer
);
1913 /* If the new current buffer has markers to record PT, BEGV and ZV
1914 when it is not current, fetch them now. */
1915 if (! NILP (BUF_PT_MARKER (b
)))
1917 BUF_PT (b
) = marker_position (BUF_PT_MARKER (b
));
1918 BUF_PT_BYTE (b
) = marker_byte_position (BUF_PT_MARKER (b
));
1920 if (! NILP (BUF_BEGV_MARKER (b
)))
1922 BUF_BEGV (b
) = marker_position (BUF_BEGV_MARKER (b
));
1923 BUF_BEGV_BYTE (b
) = marker_byte_position (BUF_BEGV_MARKER (b
));
1925 if (! NILP (BUF_ZV_MARKER (b
)))
1927 BUF_ZV (b
) = marker_position (BUF_ZV_MARKER (b
));
1928 BUF_ZV_BYTE (b
) = marker_byte_position (BUF_ZV_MARKER (b
));
1931 /* Look down buffer's list of local Lisp variables
1932 to find and update any that forward into C variables. */
1934 for (tail
= BUF_LOCAL_VAR_ALIST (b
); CONSP (tail
); tail
= XCDR (tail
))
1936 if (CONSP (XCAR (tail
))
1937 && SYMBOLP (XCAR (XCAR (tail
)))
1938 && (valcontents
= SYMBOL_VALUE (XCAR (XCAR (tail
))),
1939 (BUFFER_LOCAL_VALUEP (valcontents
)))
1940 && (tem
= BLOCAL_REALVALUE (XBUFFER_LOCAL_VALUE (valcontents
)),
1941 (BOOLFWDP (tem
) || INTFWDP (tem
) || OBJFWDP (tem
))))
1942 /* Just reference the variable to cause it to become set for
1944 Fsymbol_value (XCAR (XCAR (tail
)));
1947 /* Do the same with any others that were local to the previous buffer */
1950 for (tail
= BUF_LOCAL_VAR_ALIST (old_buf
); CONSP (tail
); tail
= XCDR (tail
))
1953 && SYMBOLP (XCAR (XCAR (tail
)))
1954 && (valcontents
= SYMBOL_VALUE (XCAR (XCAR (tail
))),
1955 (BUFFER_LOCAL_VALUEP (valcontents
)))
1956 && (tem
= BLOCAL_REALVALUE (XBUFFER_LOCAL_VALUE (valcontents
)),
1957 (BOOLFWDP (tem
) || INTFWDP (tem
) || OBJFWDP (tem
))))
1958 /* Just reference the variable to cause it to become set for
1960 Fsymbol_value (XCAR (XCAR (tail
)));
1964 /* Switch to buffer B temporarily for redisplay purposes.
1965 This avoids certain things that don't need to be done within redisplay. */
1971 register struct buffer
*old_buf
;
1973 if (current_buffer
== b
)
1976 old_buf
= current_buffer
;
1981 /* If the old current buffer has markers to record PT, BEGV and ZV
1982 when it is not current, update them now. */
1983 if (! NILP (BUF_PT_MARKER (old_buf
)))
1986 XSETBUFFER (obuf
, old_buf
);
1987 set_marker_both (BUF_PT_MARKER (old_buf
), obuf
,
1988 BUF_PT (old_buf
), BUF_PT_BYTE (old_buf
));
1990 if (! NILP (BUF_BEGV_MARKER (old_buf
)))
1993 XSETBUFFER (obuf
, old_buf
);
1994 set_marker_both (BUF_BEGV_MARKER (old_buf
), obuf
,
1995 BUF_BEGV (old_buf
), BUF_BEGV_BYTE (old_buf
));
1997 if (! NILP (BUF_ZV_MARKER (old_buf
)))
2000 XSETBUFFER (obuf
, old_buf
);
2001 set_marker_both (BUF_ZV_MARKER (old_buf
), obuf
,
2002 BUF_ZV (old_buf
), BUF_ZV_BYTE (old_buf
));
2006 /* If the new current buffer has markers to record PT, BEGV and ZV
2007 when it is not current, fetch them now. */
2008 if (! NILP (BUF_PT_MARKER (b
)))
2010 BUF_PT (b
) = marker_position (BUF_PT_MARKER (b
));
2011 BUF_PT_BYTE (b
) = marker_byte_position (BUF_PT_MARKER (b
));
2013 if (! NILP (BUF_BEGV_MARKER (b
)))
2015 BUF_BEGV (b
) = marker_position (BUF_BEGV_MARKER (b
));
2016 BUF_BEGV_BYTE (b
) = marker_byte_position (BUF_BEGV_MARKER (b
));
2018 if (! NILP (BUF_ZV_MARKER (b
)))
2020 BUF_ZV (b
) = marker_position (BUF_ZV_MARKER (b
));
2021 BUF_ZV_BYTE (b
) = marker_byte_position (BUF_ZV_MARKER (b
));
2025 DEFUN ("set-buffer", Fset_buffer
, Sset_buffer
, 1, 1, 0,
2026 doc
: /* Make buffer BUFFER-OR-NAME current for editing operations.
2027 BUFFER-OR-NAME may be a buffer or the name of an existing buffer. See
2028 also `save-excursion' when you want to make a buffer current
2029 temporarily. This function does not display the buffer, so its effect
2030 ends when the current command terminates. Use `switch-to-buffer' or
2031 `pop-to-buffer' to switch buffers permanently. */)
2033 register Lisp_Object buffer_or_name
;
2035 register Lisp_Object buffer
;
2036 buffer
= Fget_buffer (buffer_or_name
);
2038 nsberror (buffer_or_name
);
2039 if (NILP (BUF_NAME (XBUFFER (buffer
))))
2040 error ("Selecting deleted buffer");
2041 set_buffer_internal (XBUFFER (buffer
));
2045 /* Set the current buffer to BUFFER provided it is alive. */
2048 set_buffer_if_live (buffer
)
2051 if (! NILP (BUF_NAME (XBUFFER (buffer
))))
2052 Fset_buffer (buffer
);
2056 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only
,
2057 Sbarf_if_buffer_read_only
, 0, 0, 0,
2058 doc
: /* Signal a `buffer-read-only' error if the current buffer is read-only. */)
2061 if (!NILP (BUF_READ_ONLY (current_buffer
))
2062 && NILP (Vinhibit_read_only
))
2063 xsignal1 (Qbuffer_read_only
, Fcurrent_buffer ());
2067 DEFUN ("bury-buffer", Fbury_buffer
, Sbury_buffer
, 0, 1, "",
2068 doc
: /* Put BUFFER-OR-NAME at the end of the list of all buffers.
2069 There it is the least likely candidate for `other-buffer' to return;
2070 thus, the least likely buffer for \\[switch-to-buffer] to select by
2073 The argument may be a buffer name or an actual buffer object. If
2074 BUFFER-OR-NAME is nil or omitted, bury the current buffer and remove it
2075 from the selected window if it is displayed there. If the selected
2076 window is dedicated to its buffer, delete that window if there are other
2077 windows on the same frame. If the selected window is the only window on
2078 its frame, iconify that frame. */)
2080 register Lisp_Object buffer_or_name
;
2084 /* Figure out what buffer we're going to bury. */
2085 if (NILP (buffer_or_name
))
2088 XSETBUFFER (buffer
, current_buffer
);
2090 tem
= Fwindow_buffer (selected_window
);
2091 /* If we're burying the current buffer, unshow it. */
2092 if (EQ (buffer
, tem
))
2094 if (NILP (Fwindow_dedicated_p (selected_window
)))
2095 Fswitch_to_buffer (Fother_buffer (buffer
, Qnil
, Qnil
), Qnil
);
2096 else if (NILP (XWINDOW (selected_window
)->parent
))
2097 Ficonify_frame (Fwindow_frame (selected_window
));
2099 Fdelete_window (selected_window
);
2104 buffer
= Fget_buffer (buffer_or_name
);
2106 nsberror (buffer_or_name
);
2109 /* Move buffer to the end of the buffer list. Do nothing if the
2110 buffer is killed. */
2111 if (!NILP (BUF_NAME (XBUFFER (buffer
))))
2113 Lisp_Object aelt
, link
;
2115 aelt
= Frassq (buffer
, Vbuffer_alist
);
2116 link
= Fmemq (aelt
, Vbuffer_alist
);
2117 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
2118 XSETCDR (link
, Qnil
);
2119 Vbuffer_alist
= nconc2 (Vbuffer_alist
, link
);
2121 XFRAME (selected_frame
)->buffer_list
2122 = Fdelq (buffer
, XFRAME (selected_frame
)->buffer_list
);
2123 XFRAME (selected_frame
)->buried_buffer_list
2124 = Fcons (buffer
, Fdelq (buffer
, XFRAME (selected_frame
)->buried_buffer_list
));
2130 DEFUN ("erase-buffer", Ferase_buffer
, Serase_buffer
, 0, 0, "*",
2131 doc
: /* Delete the entire contents of the current buffer.
2132 Any narrowing restriction in effect (see `narrow-to-region') is removed,
2133 so the buffer is truly empty after this. */)
2140 current_buffer
->last_window_start
= 1;
2141 /* Prevent warnings, or suspension of auto saving, that would happen
2142 if future size is less than past size. Use of erase-buffer
2143 implies that the future text is not really related to the past text. */
2144 XSETFASTINT (BUF_SAVE_LENGTH (current_buffer
), 0);
2149 validate_region (b
, e
)
2150 register Lisp_Object
*b
, *e
;
2152 CHECK_NUMBER_COERCE_MARKER (*b
);
2153 CHECK_NUMBER_COERCE_MARKER (*e
);
2155 if (XINT (*b
) > XINT (*e
))
2158 tem
= *b
; *b
= *e
; *e
= tem
;
2161 if (!(BEGV
<= XINT (*b
) && XINT (*b
) <= XINT (*e
)
2162 && XINT (*e
) <= ZV
))
2163 args_out_of_range (*b
, *e
);
2166 /* Advance BYTE_POS up to a character boundary
2167 and return the adjusted position. */
2170 advance_to_char_boundary (byte_pos
)
2175 if (byte_pos
== BEG
)
2176 /* Beginning of buffer is always a character boundary. */
2179 c
= FETCH_BYTE (byte_pos
);
2180 if (! CHAR_HEAD_P (c
))
2182 /* We should advance BYTE_POS only when C is a constituent of a
2183 multibyte sequence. */
2184 int orig_byte_pos
= byte_pos
;
2189 c
= FETCH_BYTE (byte_pos
);
2191 while (! CHAR_HEAD_P (c
) && byte_pos
> BEG
);
2193 if (byte_pos
< orig_byte_pos
)
2194 byte_pos
= orig_byte_pos
;
2195 /* If C is a constituent of a multibyte sequence, BYTE_POS was
2196 surely advance to the correct character boundary. If C is
2197 not, BYTE_POS was unchanged. */
2204 extern void r_alloc_reset_variable
P_ ((POINTER_TYPE
*, POINTER_TYPE
*));
2205 #endif /* REL_ALLOC */
2207 DEFUN ("buffer-swap-text", Fbuffer_swap_text
, Sbuffer_swap_text
,
2209 doc
: /* Swap the text between current buffer and BUFFER. */)
2213 struct buffer
*other_buffer
;
2214 CHECK_BUFFER (buffer
);
2215 other_buffer
= XBUFFER (buffer
);
2217 if (NILP (BUF_NAME (other_buffer
)))
2218 error ("Cannot swap a dead buffer's text");
2220 /* Actually, it probably works just fine.
2221 * if (other_buffer == current_buffer)
2222 * error ("Cannot swap a buffer's text with itself"); */
2224 /* Actually, this may be workable as well, tho probably only if they're
2226 if (other_buffer
->base_buffer
2227 || current_buffer
->base_buffer
)
2228 error ("Cannot swap indirect buffers's text");
2230 { /* This is probably harder to make work. */
2231 struct buffer
*other
;
2232 for (other
= all_buffers
; other
; other
= other
->next
)
2233 if (other
->base_buffer
== other_buffer
2234 || other
->base_buffer
== current_buffer
)
2235 error ("One of the buffers to swap has indirect buffers");
2238 #define swapfield(field, type) \
2240 type tmp##field = other_buffer->field; \
2241 other_buffer->field = current_buffer->field; \
2242 current_buffer->field = tmp##field; \
2244 #define swapfield_(field, type) \
2246 type tmp##field = other_buffer->field ## _; \
2247 other_buffer->field ## _ = current_buffer->field ## _; \
2248 current_buffer->field ## _ = tmp##field; \
2251 swapfield (own_text
, struct buffer_text
);
2252 eassert (current_buffer
->text
== ¤t_buffer
->own_text
);
2253 eassert (other_buffer
->text
== &other_buffer
->own_text
);
2255 r_alloc_reset_variable ((POINTER_TYPE
**) ¤t_buffer
->own_text
.beg
,
2256 (POINTER_TYPE
**) &other_buffer
->own_text
.beg
);
2257 r_alloc_reset_variable ((POINTER_TYPE
**) &other_buffer
->own_text
.beg
,
2258 (POINTER_TYPE
**) ¤t_buffer
->own_text
.beg
);
2259 #endif /* REL_ALLOC */
2261 swapfield (pt
, EMACS_INT
);
2262 swapfield (pt_byte
, EMACS_INT
);
2263 swapfield (begv
, EMACS_INT
);
2264 swapfield (begv_byte
, EMACS_INT
);
2265 swapfield (zv
, EMACS_INT
);
2266 swapfield (zv_byte
, EMACS_INT
);
2267 eassert (!current_buffer
->base_buffer
);
2268 eassert (!other_buffer
->base_buffer
);
2269 current_buffer
->clip_changed
= 1; other_buffer
->clip_changed
= 1;
2270 swapfield (newline_cache
, struct region_cache
*);
2271 swapfield (width_run_cache
, struct region_cache
*);
2272 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2273 other_buffer
->prevent_redisplay_optimizations_p
= 1;
2274 swapfield (overlays_before
, struct Lisp_Overlay
*);
2275 swapfield (overlays_after
, struct Lisp_Overlay
*);
2276 swapfield (overlay_center
, EMACS_INT
);
2277 swapfield_ (undo_list
, Lisp_Object
);
2278 swapfield_ (mark
, Lisp_Object
);
2279 swapfield_ (enable_multibyte_characters
, Lisp_Object
);
2280 /* FIXME: Not sure what we should do with these *_marker fields.
2281 Hopefully they're just nil anyway. */
2282 swapfield_ (pt_marker
, Lisp_Object
);
2283 swapfield_ (begv_marker
, Lisp_Object
);
2284 swapfield_ (zv_marker
, Lisp_Object
);
2285 BUF_POINT_BEFORE_SCROLL (current_buffer
) = Qnil
;
2286 BUF_POINT_BEFORE_SCROLL (other_buffer
) = Qnil
;
2288 current_buffer
->text
->modiff
++; other_buffer
->text
->modiff
++;
2289 current_buffer
->text
->chars_modiff
++; other_buffer
->text
->chars_modiff
++;
2290 current_buffer
->text
->overlay_modiff
++; other_buffer
->text
->overlay_modiff
++;
2291 current_buffer
->text
->beg_unchanged
= current_buffer
->text
->gpt
;
2292 current_buffer
->text
->end_unchanged
= current_buffer
->text
->gpt
;
2293 other_buffer
->text
->beg_unchanged
= other_buffer
->text
->gpt
;
2294 other_buffer
->text
->end_unchanged
= other_buffer
->text
->gpt
;
2296 struct Lisp_Marker
*m
;
2297 for (m
= BUF_MARKERS (current_buffer
); m
; m
= m
->next
)
2298 if (m
->buffer
== other_buffer
)
2299 m
->buffer
= current_buffer
;
2301 /* Since there's no indirect buffer in sight, markers on
2302 BUF_MARKERS(buf) should either be for `buf' or dead. */
2303 eassert (!m
->buffer
);
2304 for (m
= BUF_MARKERS (other_buffer
); m
; m
= m
->next
)
2305 if (m
->buffer
== current_buffer
)
2306 m
->buffer
= other_buffer
;
2308 /* Since there's no indirect buffer in sight, markers on
2309 BUF_MARKERS(buf) should either be for `buf' or dead. */
2310 eassert (!m
->buffer
);
2312 { /* Some of the C code expects that w->buffer == w->pointm->buffer.
2313 So since we just swapped the markers between the two buffers, we need
2314 to undo the effect of this swap for window markers. */
2315 Lisp_Object w
= Fselected_window (), ws
= Qnil
;
2316 Lisp_Object buf1
, buf2
;
2317 XSETBUFFER (buf1
, current_buffer
); XSETBUFFER (buf2
, other_buffer
);
2319 while (NILP (Fmemq (w
, ws
)))
2322 if (MARKERP (XWINDOW (w
)->pointm
)
2323 && (EQ (XWINDOW (w
)->buffer
, buf1
)
2324 || EQ (XWINDOW (w
)->buffer
, buf2
)))
2325 Fset_marker (XWINDOW (w
)->pointm
,
2326 make_number (BUF_BEGV (XBUFFER (XWINDOW (w
)->buffer
))),
2327 XWINDOW (w
)->buffer
);
2328 w
= Fnext_window (w
, Qt
, Qt
);
2332 if (current_buffer
->text
->intervals
)
2333 (eassert (EQ (current_buffer
->text
->intervals
->up
.obj
, buffer
)),
2334 XSETBUFFER (current_buffer
->text
->intervals
->up
.obj
, current_buffer
));
2335 if (other_buffer
->text
->intervals
)
2336 (eassert (EQ (other_buffer
->text
->intervals
->up
.obj
, Fcurrent_buffer ())),
2337 XSETBUFFER (other_buffer
->text
->intervals
->up
.obj
, other_buffer
));
2342 DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte
, Sset_buffer_multibyte
,
2344 doc
: /* Set the multibyte flag of the current buffer to FLAG.
2345 If FLAG is t, this makes the buffer a multibyte buffer.
2346 If FLAG is nil, this makes the buffer a single-byte buffer.
2347 In these cases, the buffer contents remain unchanged as a sequence of
2348 bytes but the contents viewed as characters do change.
2349 If FLAG is `to', this makes the buffer a multibyte buffer by changing
2350 all eight-bit bytes to eight-bit characters.
2351 If the multibyte flag was really changed, undo information of the
2352 current buffer is cleared. */)
2356 struct Lisp_Marker
*tail
, *markers
;
2357 struct buffer
*other
;
2359 int narrowed
= (BEG
!= BEGV
|| Z
!= ZV
);
2360 int modified_p
= !NILP (Fbuffer_modified_p (Qnil
));
2361 Lisp_Object old_undo
= BUF_UNDO_LIST (current_buffer
);
2362 struct gcpro gcpro1
;
2364 if (current_buffer
->base_buffer
)
2365 error ("Cannot do `set-buffer-multibyte' on an indirect buffer");
2367 /* Do nothing if nothing actually changes. */
2368 if (NILP (flag
) == NILP (BUF_ENABLE_MULTIBYTE_CHARACTERS (current_buffer
)))
2373 /* Don't record these buffer changes. We will put a special undo entry
2375 BUF_UNDO_LIST (current_buffer
) = Qt
;
2377 /* If the cached position is for this buffer, clear it out. */
2378 clear_charpos_cache (current_buffer
);
2381 begv
= BEGV_BYTE
, zv
= ZV_BYTE
;
2383 begv
= BEGV
, zv
= ZV
;
2393 /* Do this first, so it can use CHAR_TO_BYTE
2394 to calculate the old correspondences. */
2395 set_intervals_multibyte (0);
2397 BUF_ENABLE_MULTIBYTE_CHARACTERS (current_buffer
) = Qnil
;
2403 TEMP_SET_PT_BOTH (PT_BYTE
, PT_BYTE
);
2406 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
2407 tail
->charpos
= tail
->bytepos
;
2409 /* Convert multibyte form of 8-bit characters to unibyte. */
2424 if (ASCII_BYTE_P (*p
))
2426 else if (CHAR_BYTE8_HEAD_P (*p
))
2428 c
= STRING_CHAR_AND_LENGTH (p
, bytes
);
2429 /* Delete all bytes for this 8-bit character but the
2430 last one, and change the last one to the charcter
2433 del_range_2 (pos
, pos
, pos
+ bytes
, pos
+ bytes
, 0);
2445 bytes
= BYTES_BY_CHAR_HEAD (*p
);
2446 p
+= bytes
, pos
+= bytes
;
2450 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2456 unsigned char *p
, *pend
;
2458 /* Be sure not to have a multibyte sequence striding over the GAP.
2459 Ex: We change this: "...abc\302 _GAP_ \241def..."
2460 to: "...abc _GAP_ \302\241def..." */
2463 && GPT_BYTE
> 1 && GPT_BYTE
< Z_BYTE
2464 && ! CHAR_HEAD_P (*(GAP_END_ADDR
)))
2466 unsigned char *p
= GPT_ADDR
- 1;
2468 while (! CHAR_HEAD_P (*p
) && p
> BEG_ADDR
) p
--;
2469 if (BASE_LEADING_CODE_P (*p
))
2471 int new_gpt
= GPT_BYTE
- (GPT_ADDR
- p
);
2473 move_gap_both (new_gpt
, new_gpt
);
2477 /* Make the buffer contents valid as multibyte by converting
2478 8-bit characters to multibyte form. */
2496 if (ASCII_BYTE_P (*p
))
2498 else if (EQ (flag
, Qt
)
2499 && ! CHAR_BYTE8_HEAD_P (*p
)
2500 && (bytes
= MULTIBYTE_LENGTH (p
, pend
)) > 0)
2501 p
+= bytes
, pos
+= bytes
;
2504 unsigned char tmp
[MAX_MULTIBYTE_LENGTH
];
2507 c
= BYTE8_TO_CHAR (*p
);
2508 bytes
= CHAR_STRING (c
, tmp
);
2510 TEMP_SET_PT_BOTH (pos
+ 1, pos
+ 1);
2512 insert_1_both (tmp
+ 1, bytes
, bytes
, 1, 0, 0);
2513 /* Now the gap is after the just inserted data. */
2531 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2533 /* Do this first, so that chars_in_text asks the right question.
2534 set_intervals_multibyte needs it too. */
2535 BUF_ENABLE_MULTIBYTE_CHARACTERS (current_buffer
) = Qt
;
2537 GPT_BYTE
= advance_to_char_boundary (GPT_BYTE
);
2538 GPT
= chars_in_text (BEG_ADDR
, GPT_BYTE
- BEG_BYTE
) + BEG
;
2540 Z
= chars_in_text (GAP_END_ADDR
, Z_BYTE
- GPT_BYTE
) + GPT
;
2542 BEGV_BYTE
= advance_to_char_boundary (BEGV_BYTE
);
2543 if (BEGV_BYTE
> GPT_BYTE
)
2544 BEGV
= chars_in_text (GAP_END_ADDR
, BEGV_BYTE
- GPT_BYTE
) + GPT
;
2546 BEGV
= chars_in_text (BEG_ADDR
, BEGV_BYTE
- BEG_BYTE
) + BEG
;
2548 ZV_BYTE
= advance_to_char_boundary (ZV_BYTE
);
2549 if (ZV_BYTE
> GPT_BYTE
)
2550 ZV
= chars_in_text (GAP_END_ADDR
, ZV_BYTE
- GPT_BYTE
) + GPT
;
2552 ZV
= chars_in_text (BEG_ADDR
, ZV_BYTE
- BEG_BYTE
) + BEG
;
2555 int pt_byte
= advance_to_char_boundary (PT_BYTE
);
2558 if (pt_byte
> GPT_BYTE
)
2559 pt
= chars_in_text (GAP_END_ADDR
, pt_byte
- GPT_BYTE
) + GPT
;
2561 pt
= chars_in_text (BEG_ADDR
, pt_byte
- BEG_BYTE
) + BEG
;
2562 TEMP_SET_PT_BOTH (pt
, pt_byte
);
2565 tail
= markers
= BUF_MARKERS (current_buffer
);
2567 /* This prevents BYTE_TO_CHAR (that is, buf_bytepos_to_charpos) from
2568 getting confused by the markers that have not yet been updated.
2569 It is also a signal that it should never create a marker. */
2570 BUF_MARKERS (current_buffer
) = NULL
;
2572 for (; tail
; tail
= tail
->next
)
2574 tail
->bytepos
= advance_to_char_boundary (tail
->bytepos
);
2575 tail
->charpos
= BYTE_TO_CHAR (tail
->bytepos
);
2578 /* Make sure no markers were put on the chain
2579 while the chain value was incorrect. */
2580 if (BUF_MARKERS (current_buffer
))
2583 BUF_MARKERS (current_buffer
) = markers
;
2585 /* Do this last, so it can calculate the new correspondences
2586 between chars and bytes. */
2587 set_intervals_multibyte (1);
2590 if (!EQ (old_undo
, Qt
))
2592 /* Represent all the above changes by a special undo entry. */
2593 extern Lisp_Object Qapply
;
2594 BUF_UNDO_LIST (current_buffer
) = Fcons (list3 (Qapply
,
2595 intern ("set-buffer-multibyte"),
2596 NILP (flag
) ? Qt
: Qnil
),
2602 /* Changing the multibyteness of a buffer means that all windows
2603 showing that buffer must be updated thoroughly. */
2604 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2605 ++windows_or_buffers_changed
;
2607 /* Copy this buffer's new multibyte status
2608 into all of its indirect buffers. */
2609 for (other
= all_buffers
; other
; other
= other
->next
)
2610 if (other
->base_buffer
== current_buffer
&& !NILP (BUF_NAME (other
)))
2612 BUF_ENABLE_MULTIBYTE_CHARACTERS (other
)
2613 = BUF_ENABLE_MULTIBYTE_CHARACTERS (current_buffer
);
2614 other
->prevent_redisplay_optimizations_p
= 1;
2617 /* Restore the modifiedness of the buffer. */
2618 if (!modified_p
&& !NILP (Fbuffer_modified_p (Qnil
)))
2619 Fset_buffer_modified_p (Qnil
);
2622 /* Update coding systems of this buffer's process (if any). */
2624 Lisp_Object process
;
2626 process
= Fget_buffer_process (Fcurrent_buffer ());
2627 if (PROCESSP (process
))
2628 setup_process_coding_systems (process
);
2630 #endif /* subprocesses */
2635 DEFUN ("kill-all-local-variables", Fkill_all_local_variables
, Skill_all_local_variables
,
2637 doc
: /* Switch to Fundamental mode by killing current buffer's local variables.
2638 Most local variable bindings are eliminated so that the default values
2639 become effective once more. Also, the syntax table is set from
2640 `standard-syntax-table', the local keymap is set to nil,
2641 and the abbrev table from `fundamental-mode-abbrev-table'.
2642 This function also forces redisplay of the mode line.
2644 Every function to select a new major mode starts by
2645 calling this function.
2647 As a special exception, local variables whose names have
2648 a non-nil `permanent-local' property are not eliminated by this function.
2650 The first thing this function does is run
2651 the normal hook `change-major-mode-hook'. */)
2654 if (!NILP (Vrun_hooks
))
2655 call1 (Vrun_hooks
, Qchange_major_mode_hook
);
2657 /* Make sure none of the bindings in local_var_alist
2658 remain swapped in, in their symbols. */
2660 swap_out_buffer_local_variables (current_buffer
);
2662 /* Actually eliminate all local bindings of this buffer. */
2664 reset_buffer_local_variables (current_buffer
, 0);
2666 /* Force mode-line redisplay. Useful here because all major mode
2667 commands call this function. */
2668 update_mode_lines
++;
2673 /* Make sure no local variables remain set up with buffer B
2674 for their current values. */
2677 swap_out_buffer_local_variables (b
)
2680 Lisp_Object oalist
, alist
, sym
, buffer
;
2682 XSETBUFFER (buffer
, b
);
2683 oalist
= BUF_LOCAL_VAR_ALIST (b
);
2685 for (alist
= oalist
; CONSP (alist
); alist
= XCDR (alist
))
2687 if (CONSP (XCAR (alist
))
2688 && (sym
= XCAR (XCAR (alist
)), SYMBOLP (sym
))
2689 && (blocal_get_thread_data (XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
)),
2691 /* Need not do anything if some other buffer's binding is
2693 && EQ (BLOCAL_BUFFER (XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))),
2696 /* Symbol is set up for this buffer's old local value:
2698 swap_in_global_binding (sym
);
2703 /* Find all the overlays in the current buffer that contain position POS.
2704 Return the number found, and store them in a vector in *VEC_PTR.
2705 Store in *LEN_PTR the size allocated for the vector.
2706 Store in *NEXT_PTR the next position after POS where an overlay starts,
2707 or ZV if there are no more overlays between POS and ZV.
2708 Store in *PREV_PTR the previous position before POS where an overlay ends,
2709 or where an overlay starts which ends at or after POS;
2710 or BEGV if there are no such overlays from BEGV to POS.
2711 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2713 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2714 when this function is called.
2716 If EXTEND is non-zero, we make the vector bigger if necessary.
2717 If EXTEND is zero, we never extend the vector,
2718 and we store only as many overlays as will fit.
2719 But we still return the total number of overlays.
2721 If CHANGE_REQ is true, then any position written into *PREV_PTR or
2722 *NEXT_PTR is guaranteed to be not equal to POS, unless it is the
2723 default (BEGV or ZV). */
2726 overlays_at (pos
, extend
, vec_ptr
, len_ptr
, next_ptr
, prev_ptr
, change_req
)
2729 Lisp_Object
**vec_ptr
;
2731 EMACS_INT
*next_ptr
;
2732 EMACS_INT
*prev_ptr
;
2735 Lisp_Object overlay
, start
, end
;
2736 struct Lisp_Overlay
*tail
;
2739 Lisp_Object
*vec
= *vec_ptr
;
2742 int inhibit_storing
= 0;
2744 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2746 int startpos
, endpos
;
2748 XSETMISC (overlay
, tail
);
2750 start
= OVERLAY_START (overlay
);
2751 end
= OVERLAY_END (overlay
);
2752 endpos
= OVERLAY_POSITION (end
);
2759 startpos
= OVERLAY_POSITION (start
);
2760 /* This one ends at or after POS
2761 so its start counts for PREV_PTR if it's before POS. */
2762 if (prev
< startpos
&& startpos
< pos
)
2766 if (startpos
<= pos
)
2770 /* The supplied vector is full.
2771 Either make it bigger, or don't store any more in it. */
2774 /* Make it work with an initial len == 0. */
2779 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2783 inhibit_storing
= 1;
2786 if (!inhibit_storing
)
2788 /* Keep counting overlays even if we can't return them all. */
2791 else if (startpos
< next
)
2795 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2797 int startpos
, endpos
;
2799 XSETMISC (overlay
, tail
);
2801 start
= OVERLAY_START (overlay
);
2802 end
= OVERLAY_END (overlay
);
2803 startpos
= OVERLAY_POSITION (start
);
2806 if (startpos
< next
)
2810 endpos
= OVERLAY_POSITION (end
);
2817 /* Make it work with an initial len == 0. */
2822 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2826 inhibit_storing
= 1;
2829 if (!inhibit_storing
)
2833 if (startpos
< pos
&& startpos
> prev
)
2836 else if (endpos
< pos
&& endpos
> prev
)
2838 else if (endpos
== pos
&& startpos
> prev
2839 && (!change_req
|| startpos
< pos
))
2850 /* Find all the overlays in the current buffer that overlap the range
2851 BEG-END, or are empty at BEG, or are empty at END provided END
2852 denotes the position at the end of the current buffer.
2854 Return the number found, and store them in a vector in *VEC_PTR.
2855 Store in *LEN_PTR the size allocated for the vector.
2856 Store in *NEXT_PTR the next position after POS where an overlay starts,
2857 or ZV if there are no more overlays.
2858 Store in *PREV_PTR the previous position before POS where an overlay ends,
2859 or BEGV if there are no previous overlays.
2860 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2862 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2863 when this function is called.
2865 If EXTEND is non-zero, we make the vector bigger if necessary.
2866 If EXTEND is zero, we never extend the vector,
2867 and we store only as many overlays as will fit.
2868 But we still return the total number of overlays. */
2871 overlays_in (beg
, end
, extend
, vec_ptr
, len_ptr
, next_ptr
, prev_ptr
)
2874 Lisp_Object
**vec_ptr
;
2879 Lisp_Object overlay
, ostart
, oend
;
2880 struct Lisp_Overlay
*tail
;
2883 Lisp_Object
*vec
= *vec_ptr
;
2886 int inhibit_storing
= 0;
2887 int end_is_Z
= end
== Z
;
2889 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2891 int startpos
, endpos
;
2893 XSETMISC (overlay
, tail
);
2895 ostart
= OVERLAY_START (overlay
);
2896 oend
= OVERLAY_END (overlay
);
2897 endpos
= OVERLAY_POSITION (oend
);
2904 startpos
= OVERLAY_POSITION (ostart
);
2905 /* Count an interval if it overlaps the range, is empty at the
2906 start of the range, or is empty at END provided END denotes the
2907 end of the buffer. */
2908 if ((beg
< endpos
&& startpos
< end
)
2909 || (startpos
== endpos
2910 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
2914 /* The supplied vector is full.
2915 Either make it bigger, or don't store any more in it. */
2918 /* Make it work with an initial len == 0. */
2923 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2927 inhibit_storing
= 1;
2930 if (!inhibit_storing
)
2932 /* Keep counting overlays even if we can't return them all. */
2935 else if (startpos
< next
)
2939 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2941 int startpos
, endpos
;
2943 XSETMISC (overlay
, tail
);
2945 ostart
= OVERLAY_START (overlay
);
2946 oend
= OVERLAY_END (overlay
);
2947 startpos
= OVERLAY_POSITION (ostart
);
2950 if (startpos
< next
)
2954 endpos
= OVERLAY_POSITION (oend
);
2955 /* Count an interval if it overlaps the range, is empty at the
2956 start of the range, or is empty at END provided END denotes the
2957 end of the buffer. */
2958 if ((beg
< endpos
&& startpos
< end
)
2959 || (startpos
== endpos
2960 && (beg
== endpos
|| (end_is_Z
&& endpos
== end
))))
2966 /* Make it work with an initial len == 0. */
2971 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2975 inhibit_storing
= 1;
2978 if (!inhibit_storing
)
2982 else if (endpos
< beg
&& endpos
> prev
)
2994 /* Return non-zero if there exists an overlay with a non-nil
2995 `mouse-face' property overlapping OVERLAY. */
2998 mouse_face_overlay_overlaps (overlay
)
2999 Lisp_Object overlay
;
3001 int start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3002 int end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3004 Lisp_Object
*v
, tem
;
3007 v
= (Lisp_Object
*) alloca (size
* sizeof *v
);
3008 n
= overlays_in (start
, end
, 0, &v
, &size
, NULL
, NULL
);
3011 v
= (Lisp_Object
*) alloca (n
* sizeof *v
);
3012 overlays_in (start
, end
, 0, &v
, &n
, NULL
, NULL
);
3015 for (i
= 0; i
< n
; ++i
)
3016 if (!EQ (v
[i
], overlay
)
3017 && (tem
= Foverlay_get (overlay
, Qmouse_face
),
3026 /* Fast function to just test if we're at an overlay boundary. */
3028 overlay_touches_p (pos
)
3031 Lisp_Object overlay
;
3032 struct Lisp_Overlay
*tail
;
3034 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
3038 XSETMISC (overlay
,tail
);
3039 if (!OVERLAYP (overlay
))
3042 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3045 if (endpos
== pos
|| OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
)
3049 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
3053 XSETMISC (overlay
, tail
);
3054 if (!OVERLAYP (overlay
))
3057 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3060 if (startpos
== pos
|| OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
)
3068 Lisp_Object overlay
;
3074 compare_overlays (v1
, v2
)
3075 const void *v1
, *v2
;
3077 const struct sortvec
*s1
= (const struct sortvec
*) v1
;
3078 const struct sortvec
*s2
= (const struct sortvec
*) v2
;
3079 if (s1
->priority
!= s2
->priority
)
3080 return s1
->priority
- s2
->priority
;
3081 if (s1
->beg
!= s2
->beg
)
3082 return s1
->beg
- s2
->beg
;
3083 if (s1
->end
!= s2
->end
)
3084 return s2
->end
- s1
->end
;
3088 /* Sort an array of overlays by priority. The array is modified in place.
3089 The return value is the new size; this may be smaller than the original
3090 size if some of the overlays were invalid or were window-specific. */
3092 sort_overlays (overlay_vec
, noverlays
, w
)
3093 Lisp_Object
*overlay_vec
;
3098 struct sortvec
*sortvec
;
3099 sortvec
= (struct sortvec
*) alloca (noverlays
* sizeof (struct sortvec
));
3101 /* Put the valid and relevant overlays into sortvec. */
3103 for (i
= 0, j
= 0; i
< noverlays
; i
++)
3106 Lisp_Object overlay
;
3108 overlay
= overlay_vec
[i
];
3109 if (OVERLAY_VALID (overlay
)
3110 && OVERLAY_POSITION (OVERLAY_START (overlay
)) > 0
3111 && OVERLAY_POSITION (OVERLAY_END (overlay
)) > 0)
3113 /* If we're interested in a specific window, then ignore
3114 overlays that are limited to some other window. */
3119 window
= Foverlay_get (overlay
, Qwindow
);
3120 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3124 /* This overlay is good and counts: put it into sortvec. */
3125 sortvec
[j
].overlay
= overlay
;
3126 sortvec
[j
].beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3127 sortvec
[j
].end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3128 tem
= Foverlay_get (overlay
, Qpriority
);
3130 sortvec
[j
].priority
= XINT (tem
);
3132 sortvec
[j
].priority
= 0;
3138 /* Sort the overlays into the proper order: increasing priority. */
3141 qsort (sortvec
, noverlays
, sizeof (struct sortvec
), compare_overlays
);
3143 for (i
= 0; i
< noverlays
; i
++)
3144 overlay_vec
[i
] = sortvec
[i
].overlay
;
3150 Lisp_Object string
, string2
;
3157 struct sortstr
*buf
; /* An array that expands as needed; never freed. */
3158 int size
; /* Allocated length of that array. */
3159 int used
; /* How much of the array is currently in use. */
3160 int bytes
; /* Total length of the strings in buf. */
3163 /* Buffers for storing information about the overlays touching a given
3164 position. These could be automatic variables in overlay_strings, but
3165 it's more efficient to hold onto the memory instead of repeatedly
3166 allocating and freeing it. */
3167 static struct sortstrlist overlay_heads
, overlay_tails
;
3168 static unsigned char *overlay_str_buf
;
3170 /* Allocated length of overlay_str_buf. */
3171 static int overlay_str_len
;
3173 /* A comparison function suitable for passing to qsort. */
3175 cmp_for_strings (as1
, as2
)
3178 struct sortstr
*s1
= (struct sortstr
*)as1
;
3179 struct sortstr
*s2
= (struct sortstr
*)as2
;
3180 if (s1
->size
!= s2
->size
)
3181 return s2
->size
- s1
->size
;
3182 if (s1
->priority
!= s2
->priority
)
3183 return s1
->priority
- s2
->priority
;
3188 record_overlay_string (ssl
, str
, str2
, pri
, size
)
3189 struct sortstrlist
*ssl
;
3190 Lisp_Object str
, str2
, pri
;
3195 if (ssl
->used
== ssl
->size
)
3201 ssl
->buf
= ((struct sortstr
*)
3202 xrealloc (ssl
->buf
, ssl
->size
* sizeof (struct sortstr
)));
3204 ssl
->buf
[ssl
->used
].string
= str
;
3205 ssl
->buf
[ssl
->used
].string2
= str2
;
3206 ssl
->buf
[ssl
->used
].size
= size
;
3207 ssl
->buf
[ssl
->used
].priority
= (INTEGERP (pri
) ? XINT (pri
) : 0);
3210 if (NILP (BUF_ENABLE_MULTIBYTE_CHARACTERS (current_buffer
)))
3211 nbytes
= SCHARS (str
);
3212 else if (! STRING_MULTIBYTE (str
))
3213 nbytes
= count_size_as_multibyte (SDATA (str
),
3216 nbytes
= SBYTES (str
);
3218 ssl
->bytes
+= nbytes
;
3222 if (NILP (BUF_ENABLE_MULTIBYTE_CHARACTERS (current_buffer
)))
3223 nbytes
= SCHARS (str2
);
3224 else if (! STRING_MULTIBYTE (str2
))
3225 nbytes
= count_size_as_multibyte (SDATA (str2
),
3228 nbytes
= SBYTES (str2
);
3230 ssl
->bytes
+= nbytes
;
3234 /* Return the concatenation of the strings associated with overlays that
3235 begin or end at POS, ignoring overlays that are specific to a window
3236 other than W. The strings are concatenated in the appropriate order:
3237 shorter overlays nest inside longer ones, and higher priority inside
3238 lower. Normally all of the after-strings come first, but zero-sized
3239 overlays have their after-strings ride along with the before-strings
3240 because it would look strange to print them inside-out.
3242 Returns the string length, and stores the contents indirectly through
3243 PSTR, if that variable is non-null. The string may be overwritten by
3244 subsequent calls. */
3247 overlay_strings (pos
, w
, pstr
)
3250 unsigned char **pstr
;
3252 Lisp_Object overlay
, window
, str
;
3253 struct Lisp_Overlay
*ov
;
3254 int startpos
, endpos
;
3255 int multibyte
= ! NILP (BUF_ENABLE_MULTIBYTE_CHARACTERS (current_buffer
));
3257 overlay_heads
.used
= overlay_heads
.bytes
= 0;
3258 overlay_tails
.used
= overlay_tails
.bytes
= 0;
3259 for (ov
= current_buffer
->overlays_before
; ov
; ov
= ov
->next
)
3261 XSETMISC (overlay
, ov
);
3262 eassert (OVERLAYP (overlay
));
3264 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3265 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3268 if (endpos
!= pos
&& startpos
!= pos
)
3270 window
= Foverlay_get (overlay
, Qwindow
);
3271 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3274 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3275 record_overlay_string (&overlay_heads
, str
,
3277 ? Foverlay_get (overlay
, Qafter_string
)
3279 Foverlay_get (overlay
, Qpriority
),
3281 else if (endpos
== pos
3282 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3283 record_overlay_string (&overlay_tails
, str
, Qnil
,
3284 Foverlay_get (overlay
, Qpriority
),
3287 for (ov
= current_buffer
->overlays_after
; ov
; ov
= ov
->next
)
3289 XSETMISC (overlay
, ov
);
3290 eassert (OVERLAYP (overlay
));
3292 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3293 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3296 if (endpos
!= pos
&& startpos
!= pos
)
3298 window
= Foverlay_get (overlay
, Qwindow
);
3299 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3302 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3303 record_overlay_string (&overlay_heads
, str
,
3305 ? Foverlay_get (overlay
, Qafter_string
)
3307 Foverlay_get (overlay
, Qpriority
),
3309 else if (endpos
== pos
3310 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3311 record_overlay_string (&overlay_tails
, str
, Qnil
,
3312 Foverlay_get (overlay
, Qpriority
),
3315 if (overlay_tails
.used
> 1)
3316 qsort (overlay_tails
.buf
, overlay_tails
.used
, sizeof (struct sortstr
),
3318 if (overlay_heads
.used
> 1)
3319 qsort (overlay_heads
.buf
, overlay_heads
.used
, sizeof (struct sortstr
),
3321 if (overlay_heads
.bytes
|| overlay_tails
.bytes
)
3326 int total
= overlay_heads
.bytes
+ overlay_tails
.bytes
;
3328 if (total
> overlay_str_len
)
3330 overlay_str_len
= total
;
3331 overlay_str_buf
= (unsigned char *)xrealloc (overlay_str_buf
,
3334 p
= overlay_str_buf
;
3335 for (i
= overlay_tails
.used
; --i
>= 0;)
3338 tem
= overlay_tails
.buf
[i
].string
;
3339 nbytes
= copy_text (SDATA (tem
), p
,
3341 STRING_MULTIBYTE (tem
), multibyte
);
3344 for (i
= 0; i
< overlay_heads
.used
; ++i
)
3347 tem
= overlay_heads
.buf
[i
].string
;
3348 nbytes
= copy_text (SDATA (tem
), p
,
3350 STRING_MULTIBYTE (tem
), multibyte
);
3352 tem
= overlay_heads
.buf
[i
].string2
;
3355 nbytes
= copy_text (SDATA (tem
), p
,
3357 STRING_MULTIBYTE (tem
), multibyte
);
3361 if (p
!= overlay_str_buf
+ total
)
3364 *pstr
= overlay_str_buf
;
3370 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
3373 recenter_overlay_lists (buf
, pos
)
3377 Lisp_Object overlay
, beg
, end
;
3378 struct Lisp_Overlay
*prev
, *tail
, *next
;
3380 /* See if anything in overlays_before should move to overlays_after. */
3382 /* We don't strictly need prev in this loop; it should always be nil.
3383 But we use it for symmetry and in case that should cease to be true
3384 with some future change. */
3386 for (tail
= buf
->overlays_before
; tail
; prev
= tail
, tail
= next
)
3389 XSETMISC (overlay
, tail
);
3391 /* If the overlay is not valid, get rid of it. */
3392 if (!OVERLAY_VALID (overlay
))
3397 /* Splice the cons cell TAIL out of overlays_before. */
3401 buf
->overlays_before
= next
;
3407 beg
= OVERLAY_START (overlay
);
3408 end
= OVERLAY_END (overlay
);
3410 if (OVERLAY_POSITION (end
) > pos
)
3412 /* OVERLAY needs to be moved. */
3413 int where
= OVERLAY_POSITION (beg
);
3414 struct Lisp_Overlay
*other
, *other_prev
;
3416 /* Splice the cons cell TAIL out of overlays_before. */
3420 buf
->overlays_before
= next
;
3422 /* Search thru overlays_after for where to put it. */
3424 for (other
= buf
->overlays_after
; other
;
3425 other_prev
= other
, other
= other
->next
)
3427 Lisp_Object otherbeg
, otheroverlay
;
3429 XSETMISC (otheroverlay
, other
);
3430 eassert (OVERLAY_VALID (otheroverlay
));
3432 otherbeg
= OVERLAY_START (otheroverlay
);
3433 if (OVERLAY_POSITION (otherbeg
) >= where
)
3437 /* Add TAIL to overlays_after before OTHER. */
3440 other_prev
->next
= tail
;
3442 buf
->overlays_after
= tail
;
3446 /* We've reached the things that should stay in overlays_before.
3447 All the rest of overlays_before must end even earlier,
3452 /* See if anything in overlays_after should be in overlays_before. */
3454 for (tail
= buf
->overlays_after
; tail
; prev
= tail
, tail
= next
)
3457 XSETMISC (overlay
, tail
);
3459 /* If the overlay is not valid, get rid of it. */
3460 if (!OVERLAY_VALID (overlay
))
3465 /* Splice the cons cell TAIL out of overlays_after. */
3469 buf
->overlays_after
= next
;
3475 beg
= OVERLAY_START (overlay
);
3476 end
= OVERLAY_END (overlay
);
3478 /* Stop looking, when we know that nothing further
3479 can possibly end before POS. */
3480 if (OVERLAY_POSITION (beg
) > pos
)
3483 if (OVERLAY_POSITION (end
) <= pos
)
3485 /* OVERLAY needs to be moved. */
3486 int where
= OVERLAY_POSITION (end
);
3487 struct Lisp_Overlay
*other
, *other_prev
;
3489 /* Splice the cons cell TAIL out of overlays_after. */
3493 buf
->overlays_after
= next
;
3495 /* Search thru overlays_before for where to put it. */
3497 for (other
= buf
->overlays_before
; other
;
3498 other_prev
= other
, other
= other
->next
)
3500 Lisp_Object otherend
, otheroverlay
;
3502 XSETMISC (otheroverlay
, other
);
3503 eassert (OVERLAY_VALID (otheroverlay
));
3505 otherend
= OVERLAY_END (otheroverlay
);
3506 if (OVERLAY_POSITION (otherend
) <= where
)
3510 /* Add TAIL to overlays_before before OTHER. */
3513 other_prev
->next
= tail
;
3515 buf
->overlays_before
= tail
;
3520 buf
->overlay_center
= pos
;
3524 adjust_overlays_for_insert (pos
, length
)
3528 /* After an insertion, the lists are still sorted properly,
3529 but we may need to update the value of the overlay center. */
3530 if (current_buffer
->overlay_center
>= pos
)
3531 current_buffer
->overlay_center
+= length
;
3535 adjust_overlays_for_delete (pos
, length
)
3539 if (current_buffer
->overlay_center
< pos
)
3540 /* The deletion was to our right. No change needed; the before- and
3541 after-lists are still consistent. */
3543 else if (current_buffer
->overlay_center
> pos
+ length
)
3544 /* The deletion was to our left. We need to adjust the center value
3545 to account for the change in position, but the lists are consistent
3546 given the new value. */
3547 current_buffer
->overlay_center
-= length
;
3549 /* We're right in the middle. There might be things on the after-list
3550 that now belong on the before-list. Recentering will move them,
3551 and also update the center point. */
3552 recenter_overlay_lists (current_buffer
, pos
);
3555 /* Fix up overlays that were garbled as a result of permuting markers
3556 in the range START through END. Any overlay with at least one
3557 endpoint in this range will need to be unlinked from the overlay
3558 list and reinserted in its proper place.
3559 Such an overlay might even have negative size at this point.
3560 If so, we'll make the overlay empty. */
3562 fix_start_end_in_overlays (start
, end
)
3563 register int start
, end
;
3565 Lisp_Object overlay
;
3566 struct Lisp_Overlay
*before_list
, *after_list
;
3567 /* These are either nil, indicating that before_list or after_list
3568 should be assigned, or the cons cell the cdr of which should be
3570 struct Lisp_Overlay
*beforep
= NULL
, *afterp
= NULL
;
3571 /* 'Parent', likewise, indicates a cons cell or
3572 current_buffer->overlays_before or overlays_after, depending
3573 which loop we're in. */
3574 struct Lisp_Overlay
*tail
, *parent
;
3575 int startpos
, endpos
;
3577 /* This algorithm shifts links around instead of consing and GCing.
3578 The loop invariant is that before_list (resp. after_list) is a
3579 well-formed list except that its last element, the CDR of beforep
3580 (resp. afterp) if beforep (afterp) isn't nil or before_list
3581 (after_list) if it is, is still uninitialized. So it's not a bug
3582 that before_list isn't initialized, although it may look
3584 for (parent
= NULL
, tail
= current_buffer
->overlays_before
; tail
;)
3586 XSETMISC (overlay
, tail
);
3588 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3589 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3591 /* If the overlay is backwards, make it empty. */
3592 if (endpos
< startpos
)
3595 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3603 || (startpos
>= start
&& startpos
< end
))
3605 /* Add it to the end of the wrong list. Later on,
3606 recenter_overlay_lists will move it to the right place. */
3607 if (endpos
< current_buffer
->overlay_center
)
3612 afterp
->next
= tail
;
3620 beforep
->next
= tail
;
3624 current_buffer
->overlays_before
= tail
->next
;
3626 parent
->next
= tail
->next
;
3630 parent
= tail
, tail
= parent
->next
;
3632 for (parent
= NULL
, tail
= current_buffer
->overlays_after
; tail
;)
3634 XSETMISC (overlay
, tail
);
3636 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3637 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3639 /* If the overlay is backwards, make it empty. */
3640 if (endpos
< startpos
)
3643 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3647 if (startpos
>= end
)
3650 if (startpos
>= start
3651 || (endpos
>= start
&& endpos
< end
))
3653 if (endpos
< current_buffer
->overlay_center
)
3658 afterp
->next
= tail
;
3666 beforep
->next
= tail
;
3670 current_buffer
->overlays_after
= tail
->next
;
3672 parent
->next
= tail
->next
;
3676 parent
= tail
, tail
= parent
->next
;
3679 /* Splice the constructed (wrong) lists into the buffer's lists,
3680 and let the recenter function make it sane again. */
3683 beforep
->next
= current_buffer
->overlays_before
;
3684 current_buffer
->overlays_before
= before_list
;
3686 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3690 afterp
->next
= current_buffer
->overlays_after
;
3691 current_buffer
->overlays_after
= after_list
;
3693 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3696 /* We have two types of overlay: the one whose ending marker is
3697 after-insertion-marker (this is the usual case) and the one whose
3698 ending marker is before-insertion-marker. When `overlays_before'
3699 contains overlays of the latter type and the former type in this
3700 order and both overlays end at inserting position, inserting a text
3701 increases only the ending marker of the latter type, which results
3702 in incorrect ordering of `overlays_before'.
3704 This function fixes ordering of overlays in the slot
3705 `overlays_before' of the buffer *BP. Before the insertion, `point'
3706 was at PREV, and now is at POS. */
3709 fix_overlays_before (bp
, prev
, pos
)
3711 EMACS_INT prev
, pos
;
3713 /* If parent is nil, replace overlays_before; otherwise, parent->next. */
3714 struct Lisp_Overlay
*tail
= bp
->overlays_before
, *parent
= NULL
, *right_pair
;
3718 /* After the insertion, the several overlays may be in incorrect
3719 order. The possibility is that, in the list `overlays_before',
3720 an overlay which ends at POS appears after an overlay which ends
3721 at PREV. Since POS is greater than PREV, we must fix the
3722 ordering of these overlays, by moving overlays ends at POS before
3723 the overlays ends at PREV. */
3725 /* At first, find a place where disordered overlays should be linked
3726 in. It is where an overlay which end before POS exists. (i.e. an
3727 overlay whose ending marker is after-insertion-marker if disorder
3730 && (XSETMISC (tem
, tail
),
3731 (end
= OVERLAY_POSITION (OVERLAY_END (tem
))) >= pos
))
3737 /* If we don't find such an overlay,
3738 or the found one ends before PREV,
3739 or the found one is the last one in the list,
3740 we don't have to fix anything. */
3741 if (!tail
|| end
< prev
|| !tail
->next
)
3744 right_pair
= parent
;
3748 /* Now, end position of overlays in the list TAIL should be before
3749 or equal to PREV. In the loop, an overlay which ends at POS is
3750 moved ahead to the place indicated by the CDR of RIGHT_PAIR. If
3751 we found an overlay which ends before PREV, the remaining
3752 overlays are in correct order. */
3755 XSETMISC (tem
, tail
);
3756 end
= OVERLAY_POSITION (OVERLAY_END (tem
));
3759 { /* This overlay is disordered. */
3760 struct Lisp_Overlay
*found
= tail
;
3762 /* Unlink the found overlay. */
3764 parent
->next
= tail
;
3765 /* Move an overlay at RIGHT_PLACE to the next of the found one,
3766 and link it into the right place. */
3769 found
->next
= bp
->overlays_before
;
3770 bp
->overlays_before
= found
;
3774 found
->next
= right_pair
->next
;
3775 right_pair
->next
= found
;
3778 else if (end
== prev
)
3783 else /* No more disordered overlay. */
3788 DEFUN ("overlayp", Foverlayp
, Soverlayp
, 1, 1, 0,
3789 doc
: /* Return t if OBJECT is an overlay. */)
3793 return (OVERLAYP (object
) ? Qt
: Qnil
);
3796 DEFUN ("make-overlay", Fmake_overlay
, Smake_overlay
, 2, 5, 0,
3797 doc
: /* Create a new overlay with range BEG to END in BUFFER.
3798 If omitted, BUFFER defaults to the current buffer.
3799 BEG and END may be integers or markers.
3800 The fourth arg FRONT-ADVANCE, if non-nil, makes the marker
3801 for the front of the overlay advance when text is inserted there
3802 \(which means the text *is not* included in the overlay).
3803 The fifth arg REAR-ADVANCE, if non-nil, makes the marker
3804 for the rear of the overlay advance when text is inserted there
3805 \(which means the text *is* included in the overlay). */)
3806 (beg
, end
, buffer
, front_advance
, rear_advance
)
3807 Lisp_Object beg
, end
, buffer
;
3808 Lisp_Object front_advance
, rear_advance
;
3810 Lisp_Object overlay
;
3814 XSETBUFFER (buffer
, current_buffer
);
3816 CHECK_BUFFER (buffer
);
3818 && ! EQ (Fmarker_buffer (beg
), buffer
))
3819 error ("Marker points into wrong buffer");
3821 && ! EQ (Fmarker_buffer (end
), buffer
))
3822 error ("Marker points into wrong buffer");
3824 CHECK_NUMBER_COERCE_MARKER (beg
);
3825 CHECK_NUMBER_COERCE_MARKER (end
);
3827 if (XINT (beg
) > XINT (end
))
3830 temp
= beg
; beg
= end
; end
= temp
;
3833 b
= XBUFFER (buffer
);
3835 beg
= Fset_marker (Fmake_marker (), beg
, buffer
);
3836 end
= Fset_marker (Fmake_marker (), end
, buffer
);
3838 if (!NILP (front_advance
))
3839 XMARKER (beg
)->insertion_type
= 1;
3840 if (!NILP (rear_advance
))
3841 XMARKER (end
)->insertion_type
= 1;
3843 overlay
= allocate_misc ();
3844 XMISCTYPE (overlay
) = Lisp_Misc_Overlay
;
3845 XOVERLAY (overlay
)->start
= beg
;
3846 XOVERLAY (overlay
)->end
= end
;
3847 XOVERLAY (overlay
)->plist
= Qnil
;
3848 XOVERLAY (overlay
)->next
= NULL
;
3850 /* Put the new overlay on the wrong list. */
3851 end
= OVERLAY_END (overlay
);
3852 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
3854 if (b
->overlays_after
)
3855 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3856 b
->overlays_after
= XOVERLAY (overlay
);
3860 if (b
->overlays_before
)
3861 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3862 b
->overlays_before
= XOVERLAY (overlay
);
3865 /* This puts it in the right list, and in the right order. */
3866 recenter_overlay_lists (b
, b
->overlay_center
);
3868 /* We don't need to redisplay the region covered by the overlay, because
3869 the overlay has no properties at the moment. */
3874 /* Mark a section of BUF as needing redisplay because of overlays changes. */
3877 modify_overlay (buf
, start
, end
)
3879 EMACS_INT start
, end
;
3888 BUF_COMPUTE_UNCHANGED (buf
, start
, end
);
3890 /* If this is a buffer not in the selected window,
3891 we must do other windows. */
3892 if (buf
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
3893 windows_or_buffers_changed
= 1;
3894 /* If multiple windows show this buffer, we must do other windows. */
3895 else if (buffer_shared
> 1)
3896 windows_or_buffers_changed
= 1;
3897 /* If we modify an overlay at the end of the buffer, we cannot
3898 be sure that window end is still valid. */
3899 else if (end
>= ZV
&& start
<= ZV
)
3900 windows_or_buffers_changed
= 1;
3902 ++BUF_OVERLAY_MODIFF (buf
);
3906 Lisp_Object
Fdelete_overlay ();
3908 static struct Lisp_Overlay
*
3909 unchain_overlay (list
, overlay
)
3910 struct Lisp_Overlay
*list
, *overlay
;
3912 struct Lisp_Overlay
*tmp
, *prev
;
3913 for (tmp
= list
, prev
= NULL
; tmp
; prev
= tmp
, tmp
= tmp
->next
)
3917 prev
->next
= tmp
->next
;
3920 overlay
->next
= NULL
;
3926 DEFUN ("move-overlay", Fmove_overlay
, Smove_overlay
, 3, 4, 0,
3927 doc
: /* Set the endpoints of OVERLAY to BEG and END in BUFFER.
3928 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.
3929 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current
3931 (overlay
, beg
, end
, buffer
)
3932 Lisp_Object overlay
, beg
, end
, buffer
;
3934 struct buffer
*b
, *ob
;
3935 Lisp_Object obuffer
;
3936 int count
= SPECPDL_INDEX ();
3938 CHECK_OVERLAY (overlay
);
3940 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3942 XSETBUFFER (buffer
, current_buffer
);
3943 CHECK_BUFFER (buffer
);
3946 && ! EQ (Fmarker_buffer (beg
), buffer
))
3947 error ("Marker points into wrong buffer");
3949 && ! EQ (Fmarker_buffer (end
), buffer
))
3950 error ("Marker points into wrong buffer");
3952 CHECK_NUMBER_COERCE_MARKER (beg
);
3953 CHECK_NUMBER_COERCE_MARKER (end
);
3955 if (XINT (beg
) == XINT (end
) && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
3956 return Fdelete_overlay (overlay
);
3958 if (XINT (beg
) > XINT (end
))
3961 temp
= beg
; beg
= end
; end
= temp
;
3964 specbind (Qinhibit_quit
, Qt
);
3966 obuffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3967 b
= XBUFFER (buffer
);
3968 ob
= BUFFERP (obuffer
) ? XBUFFER (obuffer
) : (struct buffer
*) 0;
3970 /* If the overlay has changed buffers, do a thorough redisplay. */
3971 if (!EQ (buffer
, obuffer
))
3973 /* Redisplay where the overlay was. */
3974 if (!NILP (obuffer
))
3979 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3980 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3982 modify_overlay (ob
, o_beg
, o_end
);
3985 /* Redisplay where the overlay is going to be. */
3986 modify_overlay (b
, XINT (beg
), XINT (end
));
3989 /* Redisplay the area the overlay has just left, or just enclosed. */
3993 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3994 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3996 if (o_beg
== XINT (beg
))
3997 modify_overlay (b
, o_end
, XINT (end
));
3998 else if (o_end
== XINT (end
))
3999 modify_overlay (b
, o_beg
, XINT (beg
));
4002 if (XINT (beg
) < o_beg
) o_beg
= XINT (beg
);
4003 if (XINT (end
) > o_end
) o_end
= XINT (end
);
4004 modify_overlay (b
, o_beg
, o_end
);
4008 if (!NILP (obuffer
))
4011 = unchain_overlay (ob
->overlays_before
, XOVERLAY (overlay
));
4013 = unchain_overlay (ob
->overlays_after
, XOVERLAY (overlay
));
4014 eassert (XOVERLAY (overlay
)->next
== NULL
);
4017 Fset_marker (OVERLAY_START (overlay
), beg
, buffer
);
4018 Fset_marker (OVERLAY_END (overlay
), end
, buffer
);
4020 /* Put the overlay on the wrong list. */
4021 end
= OVERLAY_END (overlay
);
4022 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
4024 XOVERLAY (overlay
)->next
= b
->overlays_after
;
4025 b
->overlays_after
= XOVERLAY (overlay
);
4029 XOVERLAY (overlay
)->next
= b
->overlays_before
;
4030 b
->overlays_before
= XOVERLAY (overlay
);
4033 /* This puts it in the right list, and in the right order. */
4034 recenter_overlay_lists (b
, b
->overlay_center
);
4036 return unbind_to (count
, overlay
);
4039 DEFUN ("delete-overlay", Fdelete_overlay
, Sdelete_overlay
, 1, 1, 0,
4040 doc
: /* Delete the overlay OVERLAY from its buffer. */)
4042 Lisp_Object overlay
;
4046 int count
= SPECPDL_INDEX ();
4048 CHECK_OVERLAY (overlay
);
4050 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4054 b
= XBUFFER (buffer
);
4055 specbind (Qinhibit_quit
, Qt
);
4057 b
->overlays_before
= unchain_overlay (b
->overlays_before
,XOVERLAY (overlay
));
4058 b
->overlays_after
= unchain_overlay (b
->overlays_after
, XOVERLAY (overlay
));
4059 eassert (XOVERLAY (overlay
)->next
== NULL
);
4061 marker_position (OVERLAY_START (overlay
)),
4062 marker_position (OVERLAY_END (overlay
)));
4063 Fset_marker (OVERLAY_START (overlay
), Qnil
, Qnil
);
4064 Fset_marker (OVERLAY_END (overlay
), Qnil
, Qnil
);
4066 /* When deleting an overlay with before or after strings, turn off
4067 display optimizations for the affected buffer, on the basis that
4068 these strings may contain newlines. This is easier to do than to
4069 check for that situation during redisplay. */
4070 if (!windows_or_buffers_changed
4071 && (!NILP (Foverlay_get (overlay
, Qbefore_string
))
4072 || !NILP (Foverlay_get (overlay
, Qafter_string
))))
4073 b
->prevent_redisplay_optimizations_p
= 1;
4075 return unbind_to (count
, Qnil
);
4078 /* Overlay dissection functions. */
4080 DEFUN ("overlay-start", Foverlay_start
, Soverlay_start
, 1, 1, 0,
4081 doc
: /* Return the position at which OVERLAY starts. */)
4083 Lisp_Object overlay
;
4085 CHECK_OVERLAY (overlay
);
4087 return (Fmarker_position (OVERLAY_START (overlay
)));
4090 DEFUN ("overlay-end", Foverlay_end
, Soverlay_end
, 1, 1, 0,
4091 doc
: /* Return the position at which OVERLAY ends. */)
4093 Lisp_Object overlay
;
4095 CHECK_OVERLAY (overlay
);
4097 return (Fmarker_position (OVERLAY_END (overlay
)));
4100 DEFUN ("overlay-buffer", Foverlay_buffer
, Soverlay_buffer
, 1, 1, 0,
4101 doc
: /* Return the buffer OVERLAY belongs to.
4102 Return nil if OVERLAY has been deleted. */)
4104 Lisp_Object overlay
;
4106 CHECK_OVERLAY (overlay
);
4108 return Fmarker_buffer (OVERLAY_START (overlay
));
4111 DEFUN ("overlay-properties", Foverlay_properties
, Soverlay_properties
, 1, 1, 0,
4112 doc
: /* Return a list of the properties on OVERLAY.
4113 This is a copy of OVERLAY's plist; modifying its conses has no effect on
4116 Lisp_Object overlay
;
4118 CHECK_OVERLAY (overlay
);
4120 return Fcopy_sequence (XOVERLAY (overlay
)->plist
);
4124 DEFUN ("overlays-at", Foverlays_at
, Soverlays_at
, 1, 1, 0,
4125 doc
: /* Return a list of the overlays that contain the character at POS. */)
4130 Lisp_Object
*overlay_vec
;
4134 CHECK_NUMBER_COERCE_MARKER (pos
);
4137 /* We can't use alloca here because overlays_at can call xrealloc. */
4138 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
4140 /* Put all the overlays we want in a vector in overlay_vec.
4141 Store the length in len. */
4142 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4143 (EMACS_INT
*) 0, (EMACS_INT
*) 0, 0);
4145 /* Make a list of them all. */
4146 result
= Flist (noverlays
, overlay_vec
);
4148 xfree (overlay_vec
);
4152 DEFUN ("overlays-in", Foverlays_in
, Soverlays_in
, 2, 2, 0,
4153 doc
: /* Return a list of the overlays that overlap the region BEG ... END.
4154 Overlap means that at least one character is contained within the overlay
4155 and also contained within the specified region.
4156 Empty overlays are included in the result if they are located at BEG,
4157 between BEG and END, or at END provided END denotes the position at the
4158 end of the buffer. */)
4160 Lisp_Object beg
, end
;
4163 Lisp_Object
*overlay_vec
;
4167 CHECK_NUMBER_COERCE_MARKER (beg
);
4168 CHECK_NUMBER_COERCE_MARKER (end
);
4171 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
4173 /* Put all the overlays we want in a vector in overlay_vec.
4174 Store the length in len. */
4175 noverlays
= overlays_in (XINT (beg
), XINT (end
), 1, &overlay_vec
, &len
,
4176 (int *) 0, (int *) 0);
4178 /* Make a list of them all. */
4179 result
= Flist (noverlays
, overlay_vec
);
4181 xfree (overlay_vec
);
4185 DEFUN ("next-overlay-change", Fnext_overlay_change
, Snext_overlay_change
,
4187 doc
: /* Return the next position after POS where an overlay starts or ends.
4188 If there are no overlay boundaries from POS to (point-max),
4189 the value is (point-max). */)
4195 Lisp_Object
*overlay_vec
;
4199 CHECK_NUMBER_COERCE_MARKER (pos
);
4202 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
4204 /* Put all the overlays we want in a vector in overlay_vec.
4205 Store the length in len.
4206 endpos gets the position where the next overlay starts. */
4207 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4208 &endpos
, (EMACS_INT
*) 0, 1);
4210 /* If any of these overlays ends before endpos,
4211 use its ending point instead. */
4212 for (i
= 0; i
< noverlays
; i
++)
4217 oend
= OVERLAY_END (overlay_vec
[i
]);
4218 oendpos
= OVERLAY_POSITION (oend
);
4219 if (oendpos
< endpos
)
4223 xfree (overlay_vec
);
4224 return make_number (endpos
);
4227 DEFUN ("previous-overlay-change", Fprevious_overlay_change
,
4228 Sprevious_overlay_change
, 1, 1, 0,
4229 doc
: /* Return the previous position before POS where an overlay starts or ends.
4230 If there are no overlay boundaries from (point-min) to POS,
4231 the value is (point-min). */)
4237 Lisp_Object
*overlay_vec
;
4240 CHECK_NUMBER_COERCE_MARKER (pos
);
4242 /* At beginning of buffer, we know the answer;
4243 avoid bug subtracting 1 below. */
4244 if (XINT (pos
) == BEGV
)
4248 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
4250 /* Put all the overlays we want in a vector in overlay_vec.
4251 Store the length in len.
4252 prevpos gets the position of the previous change. */
4253 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4254 (EMACS_INT
*) 0, &prevpos
, 1);
4256 xfree (overlay_vec
);
4257 return make_number (prevpos
);
4260 /* These functions are for debugging overlays. */
4262 DEFUN ("overlay-lists", Foverlay_lists
, Soverlay_lists
, 0, 0, 0,
4263 doc
: /* Return a pair of lists giving all the overlays of the current buffer.
4264 The car has all the overlays before the overlay center;
4265 the cdr has all the overlays after the overlay center.
4266 Recentering overlays moves overlays between these lists.
4267 The lists you get are copies, so that changing them has no effect.
4268 However, the overlays you get are the real objects that the buffer uses. */)
4271 struct Lisp_Overlay
*ol
;
4272 Lisp_Object before
= Qnil
, after
= Qnil
, tmp
;
4273 for (ol
= current_buffer
->overlays_before
; ol
; ol
= ol
->next
)
4276 before
= Fcons (tmp
, before
);
4278 for (ol
= current_buffer
->overlays_after
; ol
; ol
= ol
->next
)
4281 after
= Fcons (tmp
, after
);
4283 return Fcons (Fnreverse (before
), Fnreverse (after
));
4286 DEFUN ("overlay-recenter", Foverlay_recenter
, Soverlay_recenter
, 1, 1, 0,
4287 doc
: /* Recenter the overlays of the current buffer around position POS.
4288 That makes overlay lookup faster for positions near POS (but perhaps slower
4289 for positions far away from POS). */)
4293 CHECK_NUMBER_COERCE_MARKER (pos
);
4295 recenter_overlay_lists (current_buffer
, XINT (pos
));
4299 DEFUN ("overlay-get", Foverlay_get
, Soverlay_get
, 2, 2, 0,
4300 doc
: /* Get the property of overlay OVERLAY with property name PROP. */)
4302 Lisp_Object overlay
, prop
;
4304 CHECK_OVERLAY (overlay
);
4305 return lookup_char_property (XOVERLAY (overlay
)->plist
, prop
, 0);
4308 DEFUN ("overlay-put", Foverlay_put
, Soverlay_put
, 3, 3, 0,
4309 doc
: /* Set one property of overlay OVERLAY: give property PROP value VALUE. */)
4310 (overlay
, prop
, value
)
4311 Lisp_Object overlay
, prop
, value
;
4313 Lisp_Object tail
, buffer
;
4316 CHECK_OVERLAY (overlay
);
4318 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4320 for (tail
= XOVERLAY (overlay
)->plist
;
4321 CONSP (tail
) && CONSP (XCDR (tail
));
4322 tail
= XCDR (XCDR (tail
)))
4323 if (EQ (XCAR (tail
), prop
))
4325 changed
= !EQ (XCAR (XCDR (tail
)), value
);
4326 XSETCAR (XCDR (tail
), value
);
4329 /* It wasn't in the list, so add it to the front. */
4330 changed
= !NILP (value
);
4331 XOVERLAY (overlay
)->plist
4332 = Fcons (prop
, Fcons (value
, XOVERLAY (overlay
)->plist
));
4334 if (! NILP (buffer
))
4337 modify_overlay (XBUFFER (buffer
),
4338 marker_position (OVERLAY_START (overlay
)),
4339 marker_position (OVERLAY_END (overlay
)));
4340 if (EQ (prop
, Qevaporate
) && ! NILP (value
)
4341 && (OVERLAY_POSITION (OVERLAY_START (overlay
))
4342 == OVERLAY_POSITION (OVERLAY_END (overlay
))))
4343 Fdelete_overlay (overlay
);
4349 /* Subroutine of report_overlay_modification. */
4351 /* Lisp vector holding overlay hook functions to call.
4352 Vector elements come in pairs.
4353 Each even-index element is a list of hook functions.
4354 The following odd-index element is the overlay they came from.
4356 Before the buffer change, we fill in this vector
4357 as we call overlay hook functions.
4358 After the buffer change, we get the functions to call from this vector.
4359 This way we always call the same functions before and after the change. */
4360 static Lisp_Object last_overlay_modification_hooks
;
4362 /* Number of elements actually used in last_overlay_modification_hooks. */
4363 static int last_overlay_modification_hooks_used
;
4365 /* Add one functionlist/overlay pair
4366 to the end of last_overlay_modification_hooks. */
4369 add_overlay_mod_hooklist (functionlist
, overlay
)
4370 Lisp_Object functionlist
, overlay
;
4372 int oldsize
= XVECTOR (last_overlay_modification_hooks
)->size
;
4374 if (last_overlay_modification_hooks_used
== oldsize
)
4375 last_overlay_modification_hooks
= larger_vector
4376 (last_overlay_modification_hooks
, oldsize
* 2, Qnil
);
4377 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4378 functionlist
); last_overlay_modification_hooks_used
++;
4379 ASET (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
,
4380 overlay
); last_overlay_modification_hooks_used
++;
4383 /* Run the modification-hooks of overlays that include
4384 any part of the text in START to END.
4385 If this change is an insertion, also
4386 run the insert-before-hooks of overlay starting at END,
4387 and the insert-after-hooks of overlay ending at START.
4389 This is called both before and after the modification.
4390 AFTER is nonzero when we call after the modification.
4392 ARG1, ARG2, ARG3 are arguments to pass to the hook functions.
4393 When AFTER is nonzero, they are the start position,
4394 the position after the inserted new text,
4395 and the length of deleted or replaced old text. */
4398 report_overlay_modification (start
, end
, after
, arg1
, arg2
, arg3
)
4399 Lisp_Object start
, end
;
4401 Lisp_Object arg1
, arg2
, arg3
;
4403 Lisp_Object prop
, overlay
;
4404 struct Lisp_Overlay
*tail
;
4405 /* 1 if this change is an insertion. */
4406 int insertion
= (after
? XFASTINT (arg3
) == 0 : EQ (start
, end
));
4407 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4412 /* We used to run the functions as soon as we found them and only register
4413 them in last_overlay_modification_hooks for the purpose of the `after'
4414 case. But running elisp code as we traverse the list of overlays is
4415 painful because the list can be modified by the elisp code so we had to
4416 copy at several places. We now simply do a read-only traversal that
4417 only collects the functions to run and we run them afterwards. It's
4418 simpler, especially since all the code was already there. -stef */
4422 /* We are being called before a change.
4423 Scan the overlays to find the functions to call. */
4424 last_overlay_modification_hooks_used
= 0;
4425 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4427 int startpos
, endpos
;
4428 Lisp_Object ostart
, oend
;
4430 XSETMISC (overlay
, tail
);
4432 ostart
= OVERLAY_START (overlay
);
4433 oend
= OVERLAY_END (overlay
);
4434 endpos
= OVERLAY_POSITION (oend
);
4435 if (XFASTINT (start
) > endpos
)
4437 startpos
= OVERLAY_POSITION (ostart
);
4438 if (insertion
&& (XFASTINT (start
) == startpos
4439 || XFASTINT (end
) == startpos
))
4441 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4443 add_overlay_mod_hooklist (prop
, overlay
);
4445 if (insertion
&& (XFASTINT (start
) == endpos
4446 || XFASTINT (end
) == endpos
))
4448 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4450 add_overlay_mod_hooklist (prop
, overlay
);
4452 /* Test for intersecting intervals. This does the right thing
4453 for both insertion and deletion. */
4454 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4456 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4458 add_overlay_mod_hooklist (prop
, overlay
);
4462 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4464 int startpos
, endpos
;
4465 Lisp_Object ostart
, oend
;
4467 XSETMISC (overlay
, tail
);
4469 ostart
= OVERLAY_START (overlay
);
4470 oend
= OVERLAY_END (overlay
);
4471 startpos
= OVERLAY_POSITION (ostart
);
4472 endpos
= OVERLAY_POSITION (oend
);
4473 if (XFASTINT (end
) < startpos
)
4475 if (insertion
&& (XFASTINT (start
) == startpos
4476 || XFASTINT (end
) == startpos
))
4478 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4480 add_overlay_mod_hooklist (prop
, overlay
);
4482 if (insertion
&& (XFASTINT (start
) == endpos
4483 || XFASTINT (end
) == endpos
))
4485 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4487 add_overlay_mod_hooklist (prop
, overlay
);
4489 /* Test for intersecting intervals. This does the right thing
4490 for both insertion and deletion. */
4491 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4493 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4495 add_overlay_mod_hooklist (prop
, overlay
);
4500 GCPRO4 (overlay
, arg1
, arg2
, arg3
);
4502 /* Call the functions recorded in last_overlay_modification_hooks.
4503 First copy the vector contents, in case some of these hooks
4504 do subsequent modification of the buffer. */
4505 int size
= last_overlay_modification_hooks_used
;
4506 Lisp_Object
*copy
= (Lisp_Object
*) alloca (size
* sizeof (Lisp_Object
));
4509 bcopy (XVECTOR (last_overlay_modification_hooks
)->contents
,
4510 copy
, size
* sizeof (Lisp_Object
));
4512 gcpro1
.nvars
= size
;
4514 for (i
= 0; i
< size
;)
4516 Lisp_Object prop
, overlay
;
4518 overlay
= copy
[i
++];
4519 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
4526 call_overlay_mod_hooks (list
, overlay
, after
, arg1
, arg2
, arg3
)
4527 Lisp_Object list
, overlay
;
4529 Lisp_Object arg1
, arg2
, arg3
;
4531 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4533 GCPRO4 (list
, arg1
, arg2
, arg3
);
4535 while (CONSP (list
))
4538 call4 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
);
4540 call5 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
, arg3
);
4546 /* Delete any zero-sized overlays at position POS, if the `evaporate'
4549 evaporate_overlays (pos
)
4552 Lisp_Object overlay
, hit_list
;
4553 struct Lisp_Overlay
*tail
;
4556 if (pos
<= current_buffer
->overlay_center
)
4557 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4560 XSETMISC (overlay
, tail
);
4561 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4564 if (endpos
== pos
&& OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
4565 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4566 hit_list
= Fcons (overlay
, hit_list
);
4569 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4572 XSETMISC (overlay
, tail
);
4573 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4576 if (startpos
== pos
&& OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
4577 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4578 hit_list
= Fcons (overlay
, hit_list
);
4580 for (; CONSP (hit_list
); hit_list
= XCDR (hit_list
))
4581 Fdelete_overlay (XCAR (hit_list
));
4584 /* Somebody has tried to store a value with an unacceptable type
4585 in the slot with offset OFFSET. */
4588 buffer_slot_type_mismatch (newval
, type
)
4592 Lisp_Object predicate
;
4596 case_Lisp_Int
: predicate
= Qintegerp
; break;
4597 case Lisp_String
: predicate
= Qstringp
; break;
4598 case Lisp_Symbol
: predicate
= Qsymbolp
; break;
4602 wrong_type_argument (predicate
, newval
);
4606 /***********************************************************************
4607 Allocation with mmap
4608 ***********************************************************************/
4610 #ifdef USE_MMAP_FOR_BUFFERS
4612 #include <sys/types.h>
4613 #include <sys/mman.h>
4616 #ifdef MAP_ANONYMOUS
4617 #define MAP_ANON MAP_ANONYMOUS
4624 #define MAP_FAILED ((void *) -1)
4637 /* Memory is allocated in regions which are mapped using mmap(2).
4638 The current implementation lets the system select mapped
4639 addresses; we're not using MAP_FIXED in general, except when
4640 trying to enlarge regions.
4642 Each mapped region starts with a mmap_region structure, the user
4643 area starts after that structure, aligned to MEM_ALIGN.
4645 +-----------------------+
4646 | struct mmap_info + |
4648 +-----------------------+
4652 +-----------------------+ */
4656 /* User-specified size. */
4657 size_t nbytes_specified
;
4659 /* Number of bytes mapped */
4660 size_t nbytes_mapped
;
4662 /* Pointer to the location holding the address of the memory
4663 allocated with the mmap'd block. The variable actually points
4664 after this structure. */
4667 /* Next and previous in list of all mmap'd regions. */
4668 struct mmap_region
*next
, *prev
;
4671 /* Doubly-linked list of mmap'd regions. */
4673 static struct mmap_region
*mmap_regions
;
4675 /* File descriptor for mmap. If we don't have anonymous mapping,
4676 /dev/zero will be opened on it. */
4680 /* Temporary storage for mmap_set_vars, see there. */
4682 static struct mmap_region
*mmap_regions_1
;
4683 static int mmap_fd_1
;
4685 /* Page size on this system. */
4687 static int mmap_page_size
;
4689 /* 1 means mmap has been intialized. */
4691 static int mmap_initialized_p
;
4693 /* Value is X rounded up to the next multiple of N. */
4695 #define ROUND(X, N) (((X) + (N) - 1) / (N) * (N))
4697 /* Size of mmap_region structure plus padding. */
4699 #define MMAP_REGION_STRUCT_SIZE \
4700 ROUND (sizeof (struct mmap_region), MEM_ALIGN)
4702 /* Given a pointer P to the start of the user-visible part of a mapped
4703 region, return a pointer to the start of the region. */
4705 #define MMAP_REGION(P) \
4706 ((struct mmap_region *) ((char *) (P) - MMAP_REGION_STRUCT_SIZE))
4708 /* Given a pointer P to the start of a mapped region, return a pointer
4709 to the start of the user-visible part of the region. */
4711 #define MMAP_USER_AREA(P) \
4712 ((POINTER_TYPE *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
4714 #define MEM_ALIGN sizeof (double)
4716 /* Predicate returning true if part of the address range [START .. END]
4717 is currently mapped. Used to prevent overwriting an existing
4720 Default is to conservativly assume the address range is occupied by
4721 something else. This can be overridden by system configuration
4722 files if system-specific means to determine this exists. */
4724 #ifndef MMAP_ALLOCATED_P
4725 #define MMAP_ALLOCATED_P(start, end) 1
4728 /* Function prototypes. */
4730 static int mmap_free_1
P_ ((struct mmap_region
*));
4731 static int mmap_enlarge
P_ ((struct mmap_region
*, int));
4732 static struct mmap_region
*mmap_find
P_ ((POINTER_TYPE
*, POINTER_TYPE
*));
4733 static POINTER_TYPE
*mmap_alloc
P_ ((POINTER_TYPE
**, size_t));
4734 static POINTER_TYPE
*mmap_realloc
P_ ((POINTER_TYPE
**, size_t));
4735 static void mmap_free
P_ ((POINTER_TYPE
**ptr
));
4736 static void mmap_init
P_ ((void));
4739 /* Return a region overlapping address range START...END, or null if
4740 none. END is not including, i.e. the last byte in the range
4743 static struct mmap_region
*
4744 mmap_find (start
, end
)
4745 POINTER_TYPE
*start
, *end
;
4747 struct mmap_region
*r
;
4748 char *s
= (char *) start
, *e
= (char *) end
;
4750 for (r
= mmap_regions
; r
; r
= r
->next
)
4752 char *rstart
= (char *) r
;
4753 char *rend
= rstart
+ r
->nbytes_mapped
;
4755 if (/* First byte of range, i.e. START, in this region? */
4756 (s
>= rstart
&& s
< rend
)
4757 /* Last byte of range, i.e. END - 1, in this region? */
4758 || (e
> rstart
&& e
<= rend
)
4759 /* First byte of this region in the range? */
4760 || (rstart
>= s
&& rstart
< e
)
4761 /* Last byte of this region in the range? */
4762 || (rend
> s
&& rend
<= e
))
4770 /* Unmap a region. P is a pointer to the start of the user-araa of
4771 the region. Value is non-zero if successful. */
4775 struct mmap_region
*r
;
4778 r
->next
->prev
= r
->prev
;
4780 r
->prev
->next
= r
->next
;
4782 mmap_regions
= r
->next
;
4784 if (munmap ((POINTER_TYPE
*) r
, r
->nbytes_mapped
) == -1)
4786 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4794 /* Enlarge region R by NPAGES pages. NPAGES < 0 means shrink R.
4795 Value is non-zero if successful. */
4798 mmap_enlarge (r
, npages
)
4799 struct mmap_region
*r
;
4802 char *region_end
= (char *) r
+ r
->nbytes_mapped
;
4808 /* Unmap pages at the end of the region. */
4809 nbytes
= - npages
* mmap_page_size
;
4810 if (munmap (region_end
- nbytes
, nbytes
) == -1)
4811 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4814 r
->nbytes_mapped
-= nbytes
;
4818 else if (npages
> 0)
4820 nbytes
= npages
* mmap_page_size
;
4822 /* Try to map additional pages at the end of the region. We
4823 cannot do this if the address range is already occupied by
4824 something else because mmap deletes any previous mapping.
4825 I'm not sure this is worth doing, let's see. */
4826 if (!MMAP_ALLOCATED_P (region_end
, region_end
+ nbytes
))
4830 p
= mmap (region_end
, nbytes
, PROT_READ
| PROT_WRITE
,
4831 MAP_ANON
| MAP_PRIVATE
| MAP_FIXED
, mmap_fd
, 0);
4832 if (p
== MAP_FAILED
)
4833 ; /* fprintf (stderr, "mmap: %s\n", emacs_strerror (errno)); */
4834 else if (p
!= (POINTER_TYPE
*) region_end
)
4836 /* Kernels are free to choose a different address. In
4837 that case, unmap what we've mapped above; we have
4839 if (munmap (p
, nbytes
) == -1)
4840 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4844 r
->nbytes_mapped
+= nbytes
;
4854 /* Set or reset variables holding references to mapped regions. If
4855 RESTORE_P is zero, set all variables to null. If RESTORE_P is
4856 non-zero, set all variables to the start of the user-areas
4859 This function is called from Fdump_emacs to ensure that the dumped
4860 Emacs doesn't contain references to memory that won't be mapped
4861 when Emacs starts. */
4864 mmap_set_vars (restore_p
)
4867 struct mmap_region
*r
;
4871 mmap_regions
= mmap_regions_1
;
4872 mmap_fd
= mmap_fd_1
;
4873 for (r
= mmap_regions
; r
; r
= r
->next
)
4874 *r
->var
= MMAP_USER_AREA (r
);
4878 for (r
= mmap_regions
; r
; r
= r
->next
)
4880 mmap_regions_1
= mmap_regions
;
4881 mmap_regions
= NULL
;
4882 mmap_fd_1
= mmap_fd
;
4888 /* Allocate a block of storage large enough to hold NBYTES bytes of
4889 data. A pointer to the data is returned in *VAR. VAR is thus the
4890 address of some variable which will use the data area.
4892 The allocation of 0 bytes is valid.
4894 If we can't allocate the necessary memory, set *VAR to null, and
4897 static POINTER_TYPE
*
4898 mmap_alloc (var
, nbytes
)
4907 map
= ROUND (nbytes
+ MMAP_REGION_STRUCT_SIZE
, mmap_page_size
);
4908 p
= mmap (NULL
, map
, PROT_READ
| PROT_WRITE
, MAP_ANON
| MAP_PRIVATE
,
4911 if (p
== MAP_FAILED
)
4913 if (errno
!= ENOMEM
)
4914 fprintf (stderr
, "mmap: %s\n", emacs_strerror (errno
));
4919 struct mmap_region
*r
= (struct mmap_region
*) p
;
4921 r
->nbytes_specified
= nbytes
;
4922 r
->nbytes_mapped
= map
;
4925 r
->next
= mmap_regions
;
4930 p
= MMAP_USER_AREA (p
);
4937 /* Given a pointer at address VAR to data allocated with mmap_alloc,
4938 resize it to size NBYTES. Change *VAR to reflect the new block,
4939 and return this value. If more memory cannot be allocated, then
4940 leave *VAR unchanged, and return null. */
4942 static POINTER_TYPE
*
4943 mmap_realloc (var
, nbytes
)
4947 POINTER_TYPE
*result
;
4952 result
= mmap_alloc (var
, nbytes
);
4953 else if (nbytes
== 0)
4956 result
= mmap_alloc (var
, nbytes
);
4960 struct mmap_region
*r
= MMAP_REGION (*var
);
4961 size_t room
= r
->nbytes_mapped
- MMAP_REGION_STRUCT_SIZE
;
4966 POINTER_TYPE
*old_ptr
= *var
;
4968 /* Try to map additional pages at the end of the region.
4969 If that fails, allocate a new region, copy data
4970 from the old region, then free it. */
4971 if (mmap_enlarge (r
, (ROUND (nbytes
- room
, mmap_page_size
)
4974 r
->nbytes_specified
= nbytes
;
4975 *var
= result
= old_ptr
;
4977 else if (mmap_alloc (var
, nbytes
))
4979 bcopy (old_ptr
, *var
, r
->nbytes_specified
);
4980 mmap_free_1 (MMAP_REGION (old_ptr
));
4982 r
= MMAP_REGION (result
);
4983 r
->nbytes_specified
= nbytes
;
4991 else if (room
- nbytes
>= mmap_page_size
)
4993 /* Shrinking by at least a page. Let's give some
4994 memory back to the system.
4996 The extra parens are to make the division happens first,
4997 on positive values, so we know it will round towards
4999 mmap_enlarge (r
, - ((room
- nbytes
) / mmap_page_size
));
5001 r
->nbytes_specified
= nbytes
;
5005 /* Leave it alone. */
5007 r
->nbytes_specified
= nbytes
;
5015 /* Free a block of relocatable storage whose data is pointed to by
5016 PTR. Store 0 in *PTR to show there's no block allocated. */
5026 mmap_free_1 (MMAP_REGION (*var
));
5032 /* Perform necessary intializations for the use of mmap. */
5038 /* The value of mmap_fd is initially 0 in temacs, and -1
5039 in a dumped Emacs. */
5042 /* No anonymous mmap -- we need the file descriptor. */
5043 mmap_fd
= open ("/dev/zero", O_RDONLY
);
5045 fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno
));
5047 #endif /* MAP_ANON == 0 */
5049 if (mmap_initialized_p
)
5051 mmap_initialized_p
= 1;
5057 mmap_page_size
= getpagesize ();
5060 #endif /* USE_MMAP_FOR_BUFFERS */
5064 /***********************************************************************
5065 Buffer-text Allocation
5066 ***********************************************************************/
5069 extern POINTER_TYPE
*r_alloc
P_ ((POINTER_TYPE
**, size_t));
5070 extern POINTER_TYPE
*r_re_alloc
P_ ((POINTER_TYPE
**, size_t));
5071 extern void r_alloc_free
P_ ((POINTER_TYPE
**ptr
));
5072 #endif /* REL_ALLOC */
5075 /* Allocate NBYTES bytes for buffer B's text buffer. */
5078 alloc_buffer_text (b
, nbytes
)
5085 #if defined USE_MMAP_FOR_BUFFERS
5086 p
= mmap_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
5087 #elif defined REL_ALLOC
5088 p
= r_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
5090 p
= xmalloc (nbytes
);
5099 b
->text
->beg
= (unsigned char *) p
;
5103 /* Enlarge buffer B's text buffer by DELTA bytes. DELTA < 0 means
5107 enlarge_buffer_text (struct buffer
*b
, EMACS_INT delta
)
5110 size_t nbytes
= (BUF_Z_BYTE (b
) - BUF_BEG_BYTE (b
) + BUF_GAP_SIZE (b
) + 1
5113 #if defined USE_MMAP_FOR_BUFFERS
5114 p
= mmap_realloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
5115 #elif defined REL_ALLOC
5116 p
= r_re_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
5118 p
= xrealloc (b
->text
->beg
, nbytes
);
5127 BUF_BEG_ADDR (b
) = (unsigned char *) p
;
5132 /* Free buffer B's text buffer. */
5135 free_buffer_text (b
)
5140 #if defined USE_MMAP_FOR_BUFFERS
5141 mmap_free ((POINTER_TYPE
**) &b
->text
->beg
);
5142 #elif defined REL_ALLOC
5143 r_alloc_free ((POINTER_TYPE
**) &b
->text
->beg
);
5145 xfree (b
->text
->beg
);
5148 BUF_BEG_ADDR (b
) = NULL
;
5154 /***********************************************************************
5156 ***********************************************************************/
5163 bzero (buffer_permanent_local_flags
, sizeof buffer_permanent_local_flags
);
5165 /* Make sure all markable slots in buffer_defaults
5166 are initialized reasonably, so mark_buffer won't choke. */
5167 reset_buffer (&buffer_defaults
);
5168 reset_buffer_local_variables (&buffer_defaults
, 1);
5169 reset_buffer (&buffer_local_symbols
);
5170 reset_buffer_local_variables (&buffer_local_symbols
, 1);
5171 /* Prevent GC from getting confused. */
5172 buffer_defaults
.text
= &buffer_defaults
.own_text
;
5173 buffer_local_symbols
.text
= &buffer_local_symbols
.own_text
;
5174 BUF_INTERVALS (&buffer_defaults
) = 0;
5175 BUF_INTERVALS (&buffer_local_symbols
) = 0;
5176 XSETPVECTYPE (&buffer_defaults
, PVEC_BUFFER
);
5177 XSETBUFFER (Vbuffer_defaults
, &buffer_defaults
);
5178 XSETPVECTYPE (&buffer_local_symbols
, PVEC_BUFFER
);
5179 XSETBUFFER (Vbuffer_local_symbols
, &buffer_local_symbols
);
5181 /* Set up the default values of various buffer slots. */
5182 /* Must do these before making the first buffer! */
5184 /* real setup is done in bindings.el */
5185 BUF_MODE_LINE_FORMAT (&buffer_defaults
) = build_string ("%-");
5186 BUF_HEADER_LINE_FORMAT (&buffer_defaults
) = Qnil
;
5187 BUF_ABBREV_MODE (&buffer_defaults
) = Qnil
;
5188 BUF_OVERWRITE_MODE (&buffer_defaults
) = Qnil
;
5189 BUF_CASE_FOLD_SEARCH (&buffer_defaults
) = Qt
;
5190 BUF_AUTO_FILL_FUNCTION (&buffer_defaults
) = Qnil
;
5191 BUF_SELECTIVE_DISPLAY (&buffer_defaults
) = Qnil
;
5193 BUF_SELECTIVE_DISPLAY_ELLIPSES (&buffer_defaults
) = Qt
;
5195 BUF_ABBREV_TABLE (&buffer_defaults
) = Qnil
;
5196 BUF_DISPLAY_TABLE (&buffer_defaults
) = Qnil
;
5197 BUF_UNDO_LIST (&buffer_defaults
) = Qnil
;
5198 BUF_MARK_ACTIVE (&buffer_defaults
) = Qnil
;
5199 BUF_FILE_FORMAT (&buffer_defaults
) = Qnil
;
5200 BUF_AUTO_SAVE_FILE_FORMAT (&buffer_defaults
) = Qt
;
5201 buffer_defaults
.overlays_before
= NULL
;
5202 buffer_defaults
.overlays_after
= NULL
;
5203 buffer_defaults
.overlay_center
= BEG
;
5205 XSETFASTINT (BUF_TAB_WIDTH (&buffer_defaults
), 8);
5206 BUF_TRUNCATE_LINES (&buffer_defaults
) = Qnil
;
5207 BUF_WORD_WRAP (&buffer_defaults
) = Qnil
;
5208 BUF_CTL_ARROW (&buffer_defaults
) = Qt
;
5209 BUF_DIRECTION_REVERSED (&buffer_defaults
) = Qnil
;
5210 BUF_CURSOR_TYPE (&buffer_defaults
) = Qt
;
5211 BUF_EXTRA_LINE_SPACING (&buffer_defaults
) = Qnil
;
5212 BUF_CURSOR_IN_NON_SELECTED_WINDOWS (&buffer_defaults
) = Qt
;
5215 buffer_defaults
.buffer_file_type
= Qnil
; /* TEXT */
5217 BUF_ENABLE_MULTIBYTE_CHARACTERS (&buffer_defaults
) = Qt
;
5218 BUF_BUFFER_FILE_CODING_SYSTEM (&buffer_defaults
) = Qnil
;
5219 XSETFASTINT (BUF_FILL_COLUMN (&buffer_defaults
), 70);
5220 XSETFASTINT (BUF_LEFT_MARGIN (&buffer_defaults
), 0);
5221 BUF_CACHE_LONG_LINE_SCANS (&buffer_defaults
) = Qnil
;
5222 BUF_FILE_TRUENAME (&buffer_defaults
) = Qnil
;
5223 XSETFASTINT (BUF_DISPLAY_COUNT (&buffer_defaults
), 0);
5224 XSETFASTINT (BUF_LEFT_MARGIN_COLS (&buffer_defaults
), 0);
5225 XSETFASTINT (BUF_RIGHT_MARGIN_COLS (&buffer_defaults
), 0);
5226 BUF_LEFT_FRINGE_WIDTH (&buffer_defaults
) = Qnil
;
5227 BUF_RIGHT_FRINGE_WIDTH (&buffer_defaults
) = Qnil
;
5228 BUF_FRINGES_OUTSIDE_MARGINS (&buffer_defaults
) = Qnil
;
5229 BUF_SCROLL_BAR_WIDTH (&buffer_defaults
) = Qnil
;
5230 BUF_VERTICAL_SCROLL_BAR_TYPE (&buffer_defaults
) = Qt
;
5231 BUF_INDICATE_EMPTY_LINES (&buffer_defaults
) = Qnil
;
5232 BUF_INDICATE_BUFFER_BOUNDARIES (&buffer_defaults
) = Qnil
;
5233 BUF_FRINGE_INDICATOR_ALIST (&buffer_defaults
) = Qnil
;
5234 BUF_FRINGE_CURSOR_ALIST (&buffer_defaults
) = Qnil
;
5235 BUF_SCROLL_UP_AGGRESSIVELY (&buffer_defaults
) = Qnil
;
5236 BUF_SCROLL_DOWN_AGGRESSIVELY (&buffer_defaults
) = Qnil
;
5237 BUF_DISPLAY_TIME (&buffer_defaults
) = Qnil
;
5239 /* Assign the local-flags to the slots that have default values.
5240 The local flag is a bit that is used in the buffer
5241 to say that it has its own local value for the slot.
5242 The local flag bits are in the local_var_flags slot of the buffer. */
5244 /* Nothing can work if this isn't true */
5245 if (sizeof (EMACS_INT
) != sizeof (Lisp_Object
)) abort ();
5247 /* 0 means not a lisp var, -1 means always local, else mask */
5248 bzero (&buffer_local_flags
, sizeof buffer_local_flags
);
5249 XSETINT (BUF_FILENAME (&buffer_local_flags
), -1);
5250 XSETINT (BUF_DIRECTORY (&buffer_local_flags
), -1);
5251 XSETINT (BUF_BACKED_UP (&buffer_local_flags
), -1);
5252 XSETINT (BUF_SAVE_LENGTH (&buffer_local_flags
), -1);
5253 XSETINT (BUF_AUTO_SAVE_FILE_NAME (&buffer_local_flags
), -1);
5254 XSETINT (BUF_READ_ONLY (&buffer_local_flags
), -1);
5255 XSETINT (BUF_MAJOR_MODE (&buffer_local_flags
), -1);
5256 XSETINT (BUF_MODE_NAME (&buffer_local_flags
), -1);
5257 XSETINT (BUF_UNDO_LIST (&buffer_local_flags
), -1);
5258 XSETINT (BUF_MARK_ACTIVE (&buffer_local_flags
), -1);
5259 XSETINT (BUF_POINT_BEFORE_SCROLL (&buffer_local_flags
), -1);
5260 XSETINT (BUF_FILE_TRUENAME (&buffer_local_flags
), -1);
5261 XSETINT (BUF_INVISIBILITY_SPEC (&buffer_local_flags
), -1);
5262 XSETINT (BUF_FILE_FORMAT (&buffer_local_flags
), -1);
5263 XSETINT (BUF_AUTO_SAVE_FILE_FORMAT (&buffer_local_flags
), -1);
5264 XSETINT (BUF_DISPLAY_COUNT (&buffer_local_flags
), -1);
5265 XSETINT (BUF_DISPLAY_TIME (&buffer_local_flags
), -1);
5266 XSETINT (BUF_ENABLE_MULTIBYTE_CHARACTERS (&buffer_local_flags
), -1);
5269 XSETFASTINT (BUF_MODE_LINE_FORMAT (&buffer_local_flags
), idx
); ++idx
;
5270 XSETFASTINT (BUF_ABBREV_MODE (&buffer_local_flags
), idx
); ++idx
;
5271 XSETFASTINT (BUF_OVERWRITE_MODE (&buffer_local_flags
), idx
); ++idx
;
5272 XSETFASTINT (BUF_CASE_FOLD_SEARCH (&buffer_local_flags
), idx
); ++idx
;
5273 XSETFASTINT (BUF_AUTO_FILL_FUNCTION (&buffer_local_flags
), idx
); ++idx
;
5274 XSETFASTINT (BUF_SELECTIVE_DISPLAY (&buffer_local_flags
), idx
); ++idx
;
5276 XSETFASTINT (BUF_SELECTIVE_DISPLAY_ELLIPSES (&buffer_local_flags
), idx
); ++idx
;
5278 XSETFASTINT (BUF_TAB_WIDTH (&buffer_local_flags
), idx
); ++idx
;
5279 XSETFASTINT (BUF_TRUNCATE_LINES (&buffer_local_flags
), idx
); ++idx
;
5280 XSETFASTINT (BUF_WORD_WRAP (&buffer_local_flags
), idx
); ++idx
;
5281 XSETFASTINT (BUF_CTL_ARROW (&buffer_local_flags
), idx
); ++idx
;
5282 XSETFASTINT (BUF_FILL_COLUMN (&buffer_local_flags
), idx
); ++idx
;
5283 XSETFASTINT (BUF_LEFT_MARGIN (&buffer_local_flags
), idx
); ++idx
;
5284 XSETFASTINT (BUF_ABBREV_TABLE (&buffer_local_flags
), idx
); ++idx
;
5285 XSETFASTINT (BUF_DISPLAY_TABLE (&buffer_local_flags
), idx
); ++idx
;
5287 XSETFASTINT (buffer_local_flags
.buffer_file_type
, idx
);
5288 /* Make this one a permanent local. */
5289 buffer_permanent_local_flags
[idx
++] = 1;
5291 XSETFASTINT (BUF_SYNTAX_TABLE (&buffer_local_flags
), idx
); ++idx
;
5292 XSETFASTINT (BUF_CACHE_LONG_LINE_SCANS (&buffer_local_flags
), idx
); ++idx
;
5293 XSETFASTINT (BUF_CATEGORY_TABLE (&buffer_local_flags
), idx
); ++idx
;
5294 XSETFASTINT (BUF_DIRECTION_REVERSED (&buffer_local_flags
), idx
); ++idx
;
5295 XSETFASTINT (BUF_BUFFER_FILE_CODING_SYSTEM (&buffer_local_flags
), idx
);
5296 /* Make this one a permanent local. */
5297 buffer_permanent_local_flags
[idx
++] = 1;
5298 XSETFASTINT (BUF_LEFT_MARGIN_COLS (&buffer_local_flags
), idx
); ++idx
;
5299 XSETFASTINT (BUF_RIGHT_MARGIN_COLS (&buffer_local_flags
), idx
); ++idx
;
5300 XSETFASTINT (BUF_LEFT_FRINGE_WIDTH (&buffer_local_flags
), idx
); ++idx
;
5301 XSETFASTINT (BUF_RIGHT_FRINGE_WIDTH (&buffer_local_flags
), idx
); ++idx
;
5302 XSETFASTINT (BUF_FRINGES_OUTSIDE_MARGINS (&buffer_local_flags
), idx
); ++idx
;
5303 XSETFASTINT (BUF_SCROLL_BAR_WIDTH (&buffer_local_flags
), idx
); ++idx
;
5304 XSETFASTINT (BUF_VERTICAL_SCROLL_BAR_TYPE (&buffer_local_flags
), idx
); ++idx
;
5305 XSETFASTINT (BUF_INDICATE_EMPTY_LINES (&buffer_local_flags
), idx
); ++idx
;
5306 XSETFASTINT (BUF_INDICATE_BUFFER_BOUNDARIES (&buffer_local_flags
), idx
); ++idx
;
5307 XSETFASTINT (BUF_FRINGE_INDICATOR_ALIST (&buffer_local_flags
), idx
); ++idx
;
5308 XSETFASTINT (BUF_FRINGE_CURSOR_ALIST (&buffer_local_flags
), idx
); ++idx
;
5309 XSETFASTINT (BUF_SCROLL_UP_AGGRESSIVELY (&buffer_local_flags
), idx
); ++idx
;
5310 XSETFASTINT (BUF_SCROLL_DOWN_AGGRESSIVELY (&buffer_local_flags
), idx
); ++idx
;
5311 XSETFASTINT (BUF_HEADER_LINE_FORMAT (&buffer_local_flags
), idx
); ++idx
;
5312 XSETFASTINT (BUF_CURSOR_TYPE (&buffer_local_flags
), idx
); ++idx
;
5313 XSETFASTINT (BUF_EXTRA_LINE_SPACING (&buffer_local_flags
), idx
); ++idx
;
5314 XSETFASTINT (BUF_CURSOR_IN_NON_SELECTED_WINDOWS (&buffer_local_flags
), idx
); ++idx
;
5316 /* Need more room? */
5317 if (idx
>= MAX_PER_BUFFER_VARS
)
5319 last_per_buffer_idx
= idx
;
5321 Vbuffer_alist
= Qnil
;
5325 QSFundamental
= make_pure_c_string ("Fundamental");
5327 Qfundamental_mode
= intern ("fundamental-mode");
5328 BUF_MAJOR_MODE (&buffer_defaults
) = Qfundamental_mode
;
5330 Qmode_class
= intern_c_string ("mode-class");
5332 Qprotected_field
= intern_c_string ("protected-field");
5334 Qpermanent_local
= intern_c_string ("permanent-local");
5336 Qkill_buffer_hook
= intern_c_string ("kill-buffer-hook");
5337 Fput (Qkill_buffer_hook
, Qpermanent_local
, Qt
);
5339 Qucs_set_table_for_input
= intern_c_string ("ucs-set-table-for-input");
5341 /* super-magic invisible buffer */
5342 Vprin1_to_string_buffer
= Fget_buffer_create (make_pure_c_string (" prin1"));
5343 Vbuffer_alist
= Qnil
;
5345 Fset_buffer (Fget_buffer_create (make_pure_c_string ("*scratch*")));
5347 inhibit_modification_hooks
= 0;
5357 #ifdef USE_MMAP_FOR_BUFFERS
5359 /* When using the ralloc implementation based on mmap(2), buffer
5360 text pointers will have been set to null in the dumped Emacs.
5364 for (b
= all_buffers
; b
; b
= b
->next
)
5365 if (b
->text
->beg
== NULL
)
5366 enlarge_buffer_text (b
, 0);
5368 #endif /* USE_MMAP_FOR_BUFFERS */
5370 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
5371 if (NILP (BUF_ENABLE_MULTIBYTE_CHARACTERS (&buffer_defaults
)))
5372 Fset_buffer_multibyte (Qnil
);
5374 pwd
= get_current_dir_name ();
5377 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5379 /* Maybe this should really use some standard subroutine
5380 whose definition is filename syntax dependent. */
5382 if (!(IS_DIRECTORY_SEP (pwd
[len
- 1])))
5384 /* Grow buffer to add directory separator and '\0'. */
5385 pwd
= (char *) realloc (pwd
, len
+ 2);
5387 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5388 pwd
[len
] = DIRECTORY_SEP
;
5389 pwd
[len
+ 1] = '\0';
5392 BUF_DIRECTORY (current_buffer
) = make_unibyte_string (pwd
, strlen (pwd
));
5393 if (! NILP (BUF_ENABLE_MULTIBYTE_CHARACTERS (&buffer_defaults
)))
5394 /* At this moment, we still don't know how to decode the
5395 directory name. So, we keep the bytes in multibyte form so
5396 that ENCODE_FILE correctly gets the original bytes. */
5397 BUF_DIRECTORY (current_buffer
)
5398 = string_to_multibyte (BUF_DIRECTORY (current_buffer
));
5400 /* Add /: to the front of the name
5401 if it would otherwise be treated as magic. */
5402 temp
= Ffind_file_name_handler (BUF_DIRECTORY (current_buffer
), Qt
);
5404 /* If the default dir is just /, TEMP is non-nil
5405 because of the ange-ftp completion handler.
5406 However, it is not necessary to turn / into /:/.
5407 So avoid doing that. */
5408 && strcmp ("/", SDATA (BUF_DIRECTORY (current_buffer
))))
5409 BUF_DIRECTORY (current_buffer
)
5410 = concat2 (build_string ("/:"), BUF_DIRECTORY (current_buffer
));
5412 temp
= get_minibuffer (0);
5413 BUF_DIRECTORY (XBUFFER (temp
)) = BUF_DIRECTORY (current_buffer
);
5418 /* Similar to defvar_lisp but define a variable whose value is the Lisp
5419 Object stored in the current buffer. address is the address of the slot
5420 in the buffer that is current now. */
5422 /* TYPE is nil for a general Lisp variable.
5423 An integer specifies a type; then only LIsp values
5424 with that type code are allowed (except that nil is allowed too).
5425 LNAME is the LIsp-level variable name.
5426 VNAME is the name of the buffer slot.
5427 DOC is a dummy where you write the doc string as a comment. */
5428 #define DEFVAR_PER_BUFFER(lname, vname, type, doc) \
5429 defvar_per_buffer (lname, vname, type, 0)
5432 defvar_per_buffer (namestring
, address
, type
, doc
)
5434 Lisp_Object
*address
;
5438 Lisp_Object sym
, val
;
5441 sym
= intern (namestring
);
5442 val
= allocate_misc ();
5443 offset
= (char *)address
- (char *)current_buffer
;
5445 XMISCTYPE (val
) = Lisp_Misc_Buffer_Objfwd
;
5446 XBUFFER_OBJFWD (val
)->offset
= offset
;
5447 XBUFFER_OBJFWD (val
)->slottype
= type
;
5448 SET_SYMBOL_VALUE (sym
, val
);
5449 PER_BUFFER_SYMBOL (offset
) = sym
;
5451 if (PER_BUFFER_IDX (offset
) == 0)
5452 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
5453 slot of buffer_local_flags */
5458 /* initialize the buffer routines */
5462 staticpro (&last_overlay_modification_hooks
);
5463 last_overlay_modification_hooks
5464 = Fmake_vector (make_number (10), Qnil
);
5466 staticpro (&Vbuffer_defaults
);
5467 staticpro (&Vbuffer_local_symbols
);
5468 staticpro (&Qfundamental_mode
);
5469 staticpro (&Qmode_class
);
5470 staticpro (&QSFundamental
);
5471 staticpro (&Vbuffer_alist
);
5472 staticpro (&Qprotected_field
);
5473 staticpro (&Qpermanent_local
);
5474 Qpermanent_local_hook
= intern_c_string ("permanent-local-hook");
5475 staticpro (&Qpermanent_local_hook
);
5476 staticpro (&Qkill_buffer_hook
);
5477 Qoverlayp
= intern_c_string ("overlayp");
5478 staticpro (&Qoverlayp
);
5479 Qevaporate
= intern_c_string ("evaporate");
5480 staticpro (&Qevaporate
);
5481 Qmodification_hooks
= intern_c_string ("modification-hooks");
5482 staticpro (&Qmodification_hooks
);
5483 Qinsert_in_front_hooks
= intern_c_string ("insert-in-front-hooks");
5484 staticpro (&Qinsert_in_front_hooks
);
5485 Qinsert_behind_hooks
= intern_c_string ("insert-behind-hooks");
5486 staticpro (&Qinsert_behind_hooks
);
5487 Qget_file_buffer
= intern_c_string ("get-file-buffer");
5488 staticpro (&Qget_file_buffer
);
5489 Qpriority
= intern_c_string ("priority");
5490 staticpro (&Qpriority
);
5491 Qwindow
= intern_c_string ("window");
5492 staticpro (&Qwindow
);
5493 Qbefore_string
= intern_c_string ("before-string");
5494 staticpro (&Qbefore_string
);
5495 Qafter_string
= intern_c_string ("after-string");
5496 staticpro (&Qafter_string
);
5497 Qfirst_change_hook
= intern_c_string ("first-change-hook");
5498 staticpro (&Qfirst_change_hook
);
5499 Qbefore_change_functions
= intern_c_string ("before-change-functions");
5500 staticpro (&Qbefore_change_functions
);
5501 Qafter_change_functions
= intern_c_string ("after-change-functions");
5502 staticpro (&Qafter_change_functions
);
5503 /* The next one is initialized in init_buffer_once. */
5504 staticpro (&Qucs_set_table_for_input
);
5506 Qkill_buffer_query_functions
= intern_c_string ("kill-buffer-query-functions");
5507 staticpro (&Qkill_buffer_query_functions
);
5509 Fput (Qprotected_field
, Qerror_conditions
,
5510 pure_cons (Qprotected_field
, pure_cons (Qerror
, Qnil
)));
5511 Fput (Qprotected_field
, Qerror_message
,
5512 make_pure_c_string ("Attempt to modify a protected field"));
5514 /* All these use DEFVAR_LISP_NOPRO because the slots in
5515 buffer_defaults will all be marked via Vbuffer_defaults. */
5517 DEFVAR_LISP_NOPRO ("default-mode-line-format",
5518 &buffer_defaults
.mode_line_format_
,
5519 doc
: /* Default value of `mode-line-format' for buffers that don't override it.
5520 This is the same as (default-value 'mode-line-format). */);
5522 DEFVAR_LISP_NOPRO ("default-header-line-format",
5523 &buffer_defaults
.header_line_format_
,
5524 doc
: /* Default value of `header-line-format' for buffers that don't override it.
5525 This is the same as (default-value 'header-line-format). */);
5527 DEFVAR_LISP_NOPRO ("default-cursor-type", &buffer_defaults
.cursor_type_
,
5528 doc
: /* Default value of `cursor-type' for buffers that don't override it.
5529 This is the same as (default-value 'cursor-type). */);
5531 DEFVAR_LISP_NOPRO ("default-line-spacing",
5532 &buffer_defaults
.extra_line_spacing_
,
5533 doc
: /* Default value of `line-spacing' for buffers that don't override it.
5534 This is the same as (default-value 'line-spacing). */);
5536 DEFVAR_LISP_NOPRO ("default-cursor-in-non-selected-windows",
5537 &buffer_defaults
.cursor_in_non_selected_windows_
,
5538 doc
: /* Default value of `cursor-in-non-selected-windows'.
5539 This is the same as (default-value 'cursor-in-non-selected-windows). */);
5541 DEFVAR_LISP_NOPRO ("default-abbrev-mode",
5542 &buffer_defaults
.abbrev_mode_
,
5543 doc
: /* Default value of `abbrev-mode' for buffers that do not override it.
5544 This is the same as (default-value 'abbrev-mode). */);
5546 DEFVAR_LISP_NOPRO ("default-ctl-arrow",
5547 &buffer_defaults
.ctl_arrow_
,
5548 doc
: /* Default value of `ctl-arrow' for buffers that do not override it.
5549 This is the same as (default-value 'ctl-arrow). */);
5551 DEFVAR_LISP_NOPRO ("default-direction-reversed",
5552 &buffer_defaults
.direction_reversed_
,
5553 doc
: /* Default value of `direction-reversed' for buffers that do not override it.
5554 This is the same as (default-value 'direction-reversed). */);
5556 DEFVAR_LISP_NOPRO ("default-enable-multibyte-characters",
5557 &buffer_defaults
.enable_multibyte_characters_
,
5558 doc
: /* *Default value of `enable-multibyte-characters' for buffers not overriding it.
5559 This is the same as (default-value 'enable-multibyte-characters). */);
5561 DEFVAR_LISP_NOPRO ("default-buffer-file-coding-system",
5562 &buffer_defaults
.buffer_file_coding_system_
,
5563 doc
: /* Default value of `buffer-file-coding-system' for buffers not overriding it.
5564 This is the same as (default-value 'buffer-file-coding-system). */);
5566 DEFVAR_LISP_NOPRO ("default-truncate-lines",
5567 &buffer_defaults
.truncate_lines_
,
5568 doc
: /* Default value of `truncate-lines' for buffers that do not override it.
5569 This is the same as (default-value 'truncate-lines). */);
5571 DEFVAR_LISP_NOPRO ("default-fill-column",
5572 &buffer_defaults
.fill_column_
,
5573 doc
: /* Default value of `fill-column' for buffers that do not override it.
5574 This is the same as (default-value 'fill-column). */);
5576 DEFVAR_LISP_NOPRO ("default-left-margin",
5577 &buffer_defaults
.left_margin_
,
5578 doc
: /* Default value of `left-margin' for buffers that do not override it.
5579 This is the same as (default-value 'left-margin). */);
5581 DEFVAR_LISP_NOPRO ("default-tab-width",
5582 &buffer_defaults
.tab_width_
,
5583 doc
: /* Default value of `tab-width' for buffers that do not override it.
5584 This is the same as (default-value 'tab-width). */);
5586 DEFVAR_LISP_NOPRO ("default-case-fold-search",
5587 &buffer_defaults
.case_fold_search_
,
5588 doc
: /* Default value of `case-fold-search' for buffers that don't override it.
5589 This is the same as (default-value 'case-fold-search). */);
5592 DEFVAR_LISP_NOPRO ("default-buffer-file-type",
5593 &buffer_defaults
.buffer_file_type
,
5594 doc
: /* Default file type for buffers that do not override it.
5595 This is the same as (default-value 'buffer-file-type).
5596 The file type is nil for text, t for binary. */);
5599 DEFVAR_LISP_NOPRO ("default-left-margin-width",
5600 &buffer_defaults
.left_margin_cols_
,
5601 doc
: /* Default value of `left-margin-width' for buffers that don't override it.
5602 This is the same as (default-value 'left-margin-width). */);
5604 DEFVAR_LISP_NOPRO ("default-right-margin-width",
5605 &buffer_defaults
.right_margin_cols_
,
5606 doc
: /* Default value of `right-margin-width' for buffers that don't override it.
5607 This is the same as (default-value 'right-margin-width). */);
5609 DEFVAR_LISP_NOPRO ("default-left-fringe-width",
5610 &buffer_defaults
.left_fringe_width_
,
5611 doc
: /* Default value of `left-fringe-width' for buffers that don't override it.
5612 This is the same as (default-value 'left-fringe-width). */);
5614 DEFVAR_LISP_NOPRO ("default-right-fringe-width",
5615 &buffer_defaults
.right_fringe_width_
,
5616 doc
: /* Default value of `right-fringe-width' for buffers that don't override it.
5617 This is the same as (default-value 'right-fringe-width). */);
5619 DEFVAR_LISP_NOPRO ("default-fringes-outside-margins",
5620 &buffer_defaults
.fringes_outside_margins_
,
5621 doc
: /* Default value of `fringes-outside-margins' for buffers that don't override it.
5622 This is the same as (default-value 'fringes-outside-margins). */);
5624 DEFVAR_LISP_NOPRO ("default-scroll-bar-width",
5625 &buffer_defaults
.scroll_bar_width_
,
5626 doc
: /* Default value of `scroll-bar-width' for buffers that don't override it.
5627 This is the same as (default-value 'scroll-bar-width). */);
5629 DEFVAR_LISP_NOPRO ("default-vertical-scroll-bar",
5630 &buffer_defaults
.vertical_scroll_bar_type_
,
5631 doc
: /* Default value of `vertical-scroll-bar' for buffers that don't override it.
5632 This is the same as (default-value 'vertical-scroll-bar). */);
5634 DEFVAR_LISP_NOPRO ("default-indicate-empty-lines",
5635 &buffer_defaults
.indicate_empty_lines_
,
5636 doc
: /* Default value of `indicate-empty-lines' for buffers that don't override it.
5637 This is the same as (default-value 'indicate-empty-lines). */);
5639 DEFVAR_LISP_NOPRO ("default-indicate-buffer-boundaries",
5640 &buffer_defaults
.indicate_buffer_boundaries_
,
5641 doc
: /* Default value of `indicate-buffer-boundaries' for buffers that don't override it.
5642 This is the same as (default-value 'indicate-buffer-boundaries). */);
5644 DEFVAR_LISP_NOPRO ("default-fringe-indicator-alist",
5645 &buffer_defaults
.fringe_indicator_alist_
,
5646 doc
: /* Default value of `fringe-indicator-alist' for buffers that don't override it.
5647 This is the same as (default-value 'fringe-indicator-alist'). */);
5649 DEFVAR_LISP_NOPRO ("default-fringe-cursor-alist",
5650 &buffer_defaults
.fringe_cursor_alist_
,
5651 doc
: /* Default value of `fringe-cursor-alist' for buffers that don't override it.
5652 This is the same as (default-value 'fringe-cursor-alist'). */);
5654 DEFVAR_LISP_NOPRO ("default-scroll-up-aggressively",
5655 &buffer_defaults
.scroll_up_aggressively_
,
5656 doc
: /* Default value of `scroll-up-aggressively'.
5657 This value applies in buffers that don't have their own local values.
5658 This is the same as (default-value 'scroll-up-aggressively). */);
5660 DEFVAR_LISP_NOPRO ("default-scroll-down-aggressively",
5661 &buffer_defaults
.scroll_down_aggressively_
,
5662 doc
: /* Default value of `scroll-down-aggressively'.
5663 This value applies in buffers that don't have their own local values.
5664 This is the same as (default-value 'scroll-down-aggressively). */);
5666 DEFVAR_PER_BUFFER ("header-line-format",
5667 ¤t_buffer
->header_line_format_
,
5669 doc
: /* Analogous to `mode-line-format', but controls the header line.
5670 The header line appears, optionally, at the top of a window;
5671 the mode line appears at the bottom. */);
5673 DEFVAR_PER_BUFFER ("mode-line-format", ¤t_buffer
->mode_line_format_
,
5675 doc
: /* Template for displaying mode line for current buffer.
5676 Each buffer has its own value of this variable.
5677 Value may be nil, a string, a symbol or a list or cons cell.
5678 A value of nil means don't display a mode line.
5679 For a symbol, its value is used (but it is ignored if t or nil).
5680 A string appearing directly as the value of a symbol is processed verbatim
5681 in that the %-constructs below are not recognized.
5682 Note that unless the symbol is marked as a `risky-local-variable', all
5683 properties in any strings, as well as all :eval and :propertize forms
5684 in the value of that symbol will be ignored.
5685 For a list of the form `(:eval FORM)', FORM is evaluated and the result
5686 is used as a mode line element. Be careful--FORM should not load any files,
5687 because that can cause an infinite recursion.
5688 For a list of the form `(:propertize ELT PROPS...)', ELT is displayed
5689 with the specified properties PROPS applied.
5690 For a list whose car is a symbol, the symbol's value is taken,
5691 and if that is non-nil, the cadr of the list is processed recursively.
5692 Otherwise, the caddr of the list (if there is one) is processed.
5693 For a list whose car is a string or list, each element is processed
5694 recursively and the results are effectively concatenated.
5695 For a list whose car is an integer, the cdr of the list is processed
5696 and padded (if the number is positive) or truncated (if negative)
5697 to the width specified by that number.
5698 A string is printed verbatim in the mode line except for %-constructs:
5699 (%-constructs are allowed when the string is the entire mode-line-format
5700 or when it is found in a cons-cell or a list)
5701 %b -- print buffer name. %f -- print visited file name.
5702 %F -- print frame name.
5703 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
5704 %& is like %*, but ignore read-only-ness.
5705 % means buffer is read-only and * means it is modified.
5706 For a modified read-only buffer, %* gives % and %+ gives *.
5707 %s -- print process status. %l -- print the current line number.
5708 %c -- print the current column number (this makes editing slower).
5709 To make the column number update correctly in all cases,
5710 `column-number-mode' must be non-nil.
5711 %i -- print the size of the buffer.
5712 %I -- like %i, but use k, M, G, etc., to abbreviate.
5713 %p -- print percent of buffer above top of window, or Top, Bot or All.
5714 %P -- print percent of buffer above bottom of window, perhaps plus Top,
5715 or print Bottom or All.
5716 %n -- print Narrow if appropriate.
5717 %t -- visited file is text or binary (if OS supports this distinction).
5718 %z -- print mnemonics of keyboard, terminal, and buffer coding systems.
5719 %Z -- like %z, but including the end-of-line format.
5720 %e -- print error message about full memory.
5721 %@ -- print @ or hyphen. @ means that default-directory is on a
5723 %[ -- print one [ for each recursive editing level. %] similar.
5724 %% -- print %. %- -- print infinitely many dashes.
5725 Decimal digits after the % specify field width to which to pad. */);
5727 DEFVAR_LISP_NOPRO ("default-major-mode", &buffer_defaults
.major_mode_
,
5728 doc
: /* *Value of `major-mode' for new buffers. */);
5730 DEFVAR_PER_BUFFER ("major-mode", ¤t_buffer
->major_mode_
,
5731 make_number (Lisp_Symbol
),
5732 doc
: /* Symbol for current buffer's major mode.
5733 The default value (normally `fundamental-mode') affects new buffers.
5734 A value of nil means to use the current buffer's major mode, provided
5735 it is not marked as "special".
5737 When a mode is used by default, `find-file' switches to it before it
5738 reads the contents into the buffer and before it finishes setting up
5739 the buffer. Thus, the mode and its hooks should not expect certain
5740 variables such as `buffer-read-only' and `buffer-file-coding-system'
5743 DEFVAR_PER_BUFFER ("mode-name", ¤t_buffer
->mode_name_
,
5745 doc
: /* Pretty name of current buffer's major mode.
5746 Usually a string, but can use any of the constructs for `mode-line-format',
5748 Format with `format-mode-line' to produce a string value. */);
5750 DEFVAR_PER_BUFFER ("local-abbrev-table", ¤t_buffer
->abbrev_table_
, Qnil
,
5751 doc
: /* Local (mode-specific) abbrev table of current buffer. */);
5753 DEFVAR_PER_BUFFER ("abbrev-mode", ¤t_buffer
->abbrev_mode_
, Qnil
,
5754 doc
: /* Non-nil turns on automatic expansion of abbrevs as they are inserted. */);
5756 DEFVAR_PER_BUFFER ("case-fold-search", ¤t_buffer
->case_fold_search_
,
5758 doc
: /* *Non-nil if searches and matches should ignore case. */);
5760 DEFVAR_PER_BUFFER ("fill-column", ¤t_buffer
->fill_column_
,
5761 make_number (LISP_INT_TAG
),
5762 doc
: /* *Column beyond which automatic line-wrapping should happen.
5763 Interactively, you can set the buffer local value using \\[set-fill-column]. */);
5765 DEFVAR_PER_BUFFER ("left-margin", ¤t_buffer
->left_margin_
,
5766 make_number (LISP_INT_TAG
),
5767 doc
: /* *Column for the default `indent-line-function' to indent to.
5768 Linefeed indents to this column in Fundamental mode. */);
5770 DEFVAR_PER_BUFFER ("tab-width", ¤t_buffer
->tab_width_
,
5771 make_number (LISP_INT_TAG
),
5772 doc
: /* *Distance between tab stops (for display of tab characters), in columns. */);
5774 DEFVAR_PER_BUFFER ("ctl-arrow", ¤t_buffer
->ctl_arrow_
, Qnil
,
5775 doc
: /* *Non-nil means display control chars with uparrow.
5776 A value of nil means use backslash and octal digits.
5777 This variable does not apply to characters whose display is specified
5778 in the current display table (if there is one). */);
5780 DEFVAR_PER_BUFFER ("enable-multibyte-characters",
5781 ¤t_buffer
->enable_multibyte_characters_
,
5783 doc
: /* Non-nil means the buffer contents are regarded as multi-byte characters.
5784 Otherwise they are regarded as unibyte. This affects the display,
5785 file I/O and the behavior of various editing commands.
5787 This variable is buffer-local but you cannot set it directly;
5788 use the function `set-buffer-multibyte' to change a buffer's representation.
5789 Changing its default value with `setq-default' is supported.
5790 See also variable `default-enable-multibyte-characters' and Info node
5791 `(elisp)Text Representations'. */);
5792 XSYMBOL (intern_c_string ("enable-multibyte-characters"))->constant
= 1;
5794 DEFVAR_PER_BUFFER ("buffer-file-coding-system",
5795 ¤t_buffer
->buffer_file_coding_system_
, Qnil
,
5796 doc
: /* Coding system to be used for encoding the buffer contents on saving.
5797 This variable applies to saving the buffer, and also to `write-region'
5798 and other functions that use `write-region'.
5799 It does not apply to sending output to subprocesses, however.
5801 If this is nil, the buffer is saved without any code conversion
5802 unless some coding system is specified in `file-coding-system-alist'
5803 for the buffer file.
5805 If the text to be saved cannot be encoded as specified by this variable,
5806 an alternative encoding is selected by `select-safe-coding-system', which see.
5808 The variable `coding-system-for-write', if non-nil, overrides this variable.
5810 This variable is never applied to a way of decoding a file while reading it. */);
5812 DEFVAR_PER_BUFFER ("direction-reversed", ¤t_buffer
->direction_reversed_
,
5814 doc
: /* *Non-nil means lines in the buffer are displayed right to left. */);
5816 DEFVAR_PER_BUFFER ("truncate-lines", ¤t_buffer
->truncate_lines_
, Qnil
,
5817 doc
: /* *Non-nil means do not display continuation lines.
5818 Instead, give each line of text just one screen line.
5820 Note that this is overridden by the variable
5821 `truncate-partial-width-windows' if that variable is non-nil
5822 and this buffer is not full-frame width. */);
5824 DEFVAR_PER_BUFFER ("word-wrap", ¤t_buffer
->word_wrap_
, Qnil
,
5825 doc
: /* *Non-nil means to use word-wrapping for continuation lines.
5826 When word-wrapping is on, continuation lines are wrapped at the space
5827 or tab character nearest to the right window edge.
5828 If nil, continuation lines are wrapped at the right screen edge.
5830 This variable has no effect if long lines are truncated (see
5831 `truncate-lines' and `truncate-partial-width-windows'). If you use
5832 word-wrapping, you might want to reduce the value of
5833 `truncate-partial-width-windows', since wrapping can make text readable
5834 in narrower windows. */);
5837 DEFVAR_PER_BUFFER ("buffer-file-type", ¤t_buffer
->buffer_file_type
,
5839 doc
: /* Non-nil if the visited file is a binary file.
5840 This variable is meaningful on MS-DOG and Windows NT.
5841 On those systems, it is automatically local in every buffer.
5842 On other systems, this variable is normally always nil. */);
5845 DEFVAR_PER_BUFFER ("default-directory", ¤t_buffer
->directory_
,
5846 make_number (Lisp_String
),
5847 doc
: /* Name of default directory of current buffer. Should end with slash.
5848 To interactively change the default directory, use command `cd'. */);
5850 DEFVAR_PER_BUFFER ("auto-fill-function", ¤t_buffer
->auto_fill_function_
,
5852 doc
: /* Function called (if non-nil) to perform auto-fill.
5853 It is called after self-inserting any character specified in
5854 the `auto-fill-chars' table.
5855 NOTE: This variable is not a hook;
5856 its value may not be a list of functions. */);
5858 DEFVAR_PER_BUFFER ("buffer-file-name", ¤t_buffer
->filename_
,
5859 make_number (Lisp_String
),
5860 doc
: /* Name of file visited in current buffer, or nil if not visiting a file. */);
5862 DEFVAR_PER_BUFFER ("buffer-file-truename", ¤t_buffer
->file_truename_
,
5863 make_number (Lisp_String
),
5864 doc
: /* Abbreviated truename of file visited in current buffer, or nil if none.
5865 The truename of a file is calculated by `file-truename'
5866 and then abbreviated with `abbreviate-file-name'. */);
5868 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
5869 ¤t_buffer
->auto_save_file_name_
,
5870 make_number (Lisp_String
),
5871 doc
: /* Name of file for auto-saving current buffer.
5872 If it is nil, that means don't auto-save this buffer. */);
5874 DEFVAR_PER_BUFFER ("buffer-read-only", ¤t_buffer
->read_only_
, Qnil
,
5875 doc
: /* Non-nil if this buffer is read-only. */);
5877 DEFVAR_PER_BUFFER ("buffer-backed-up", ¤t_buffer
->backed_up_
, Qnil
,
5878 doc
: /* Non-nil if this buffer's file has been backed up.
5879 Backing up is done before the first time the file is saved. */);
5881 DEFVAR_PER_BUFFER ("buffer-saved-size", ¤t_buffer
->save_length_
,
5882 make_number (LISP_INT_TAG
),
5883 doc
: /* Length of current buffer when last read in, saved or auto-saved.
5885 -1 means auto-saving turned off until next real save.
5887 If you set this to -2, that means don't turn off auto-saving in this buffer
5888 if its text size shrinks. If you use `buffer-swap-text' on a buffer,
5889 you probably should set this to -2 in that buffer. */);
5891 DEFVAR_PER_BUFFER ("selective-display", ¤t_buffer
->selective_display_
,
5893 doc
: /* Non-nil enables selective display.
5894 An integer N as value means display only lines
5895 that start with less than N columns of space.
5896 A value of t means that the character ^M makes itself and
5897 all the rest of the line invisible; also, when saving the buffer
5898 in a file, save the ^M as a newline. */);
5901 DEFVAR_PER_BUFFER ("selective-display-ellipses",
5902 ¤t_buffer
->selective_display_ellipses_
,
5904 doc
: /* Non-nil means display ... on previous line when a line is invisible. */);
5907 DEFVAR_PER_BUFFER ("overwrite-mode", ¤t_buffer
->overwrite_mode_
, Qnil
,
5908 doc
: /* Non-nil if self-insertion should replace existing text.
5909 The value should be one of `overwrite-mode-textual',
5910 `overwrite-mode-binary', or nil.
5911 If it is `overwrite-mode-textual', self-insertion still
5912 inserts at the end of a line, and inserts when point is before a tab,
5913 until the tab is filled in.
5914 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too. */);
5916 DEFVAR_PER_BUFFER ("buffer-display-table", ¤t_buffer
->display_table_
,
5918 doc
: /* Display table that controls display of the contents of current buffer.
5920 If this variable is nil, the value of `standard-display-table' is used.
5921 Each window can have its own, overriding display table, see
5922 `set-window-display-table' and `window-display-table'.
5924 The display table is a char-table created with `make-display-table'.
5925 A char-table is an array indexed by character codes. Normal array
5926 primitives `aref' and `aset' can be used to access elements of a char-table.
5928 Each of the char-table elements control how to display the corresponding
5929 text character: the element at index C in the table says how to display
5930 the character whose code is C. Each element should be a vector of
5931 characters or nil. The value nil means display the character in the
5932 default fashion; otherwise, the characters from the vector are delivered
5933 to the screen instead of the original character.
5935 For example, (aset buffer-display-table ?X [?Y]) tells Emacs
5936 to display a capital Y instead of each X character.
5938 In addition, a char-table has six extra slots to control the display of:
5940 the end of a truncated screen line (extra-slot 0, a single character);
5941 the end of a continued line (extra-slot 1, a single character);
5942 the escape character used to display character codes in octal
5943 (extra-slot 2, a single character);
5944 the character used as an arrow for control characters (extra-slot 3,
5945 a single character);
5946 the decoration indicating the presence of invisible lines (extra-slot 4,
5947 a vector of characters);
5948 the character used to draw the border between side-by-side windows
5949 (extra-slot 5, a single character).
5951 See also the functions `display-table-slot' and `set-display-table-slot'. */);
5953 DEFVAR_PER_BUFFER ("left-margin-width", ¤t_buffer
->left_margin_cols_
,
5955 doc
: /* *Width of left marginal area for display of a buffer.
5956 A value of nil means no marginal area. */);
5958 DEFVAR_PER_BUFFER ("right-margin-width", ¤t_buffer
->right_margin_cols_
,
5960 doc
: /* *Width of right marginal area for display of a buffer.
5961 A value of nil means no marginal area. */);
5963 DEFVAR_PER_BUFFER ("left-fringe-width", ¤t_buffer
->left_fringe_width_
,
5965 doc
: /* *Width of this buffer's left fringe (in pixels).
5966 A value of 0 means no left fringe is shown in this buffer's window.
5967 A value of nil means to use the left fringe width from the window's frame. */);
5969 DEFVAR_PER_BUFFER ("right-fringe-width", ¤t_buffer
->right_fringe_width_
,
5971 doc
: /* *Width of this buffer's right fringe (in pixels).
5972 A value of 0 means no right fringe is shown in this buffer's window.
5973 A value of nil means to use the right fringe width from the window's frame. */);
5975 DEFVAR_PER_BUFFER ("fringes-outside-margins", ¤t_buffer
->fringes_outside_margins_
,
5977 doc
: /* *Non-nil means to display fringes outside display margins.
5978 A value of nil means to display fringes between margins and buffer text. */);
5980 DEFVAR_PER_BUFFER ("scroll-bar-width", ¤t_buffer
->scroll_bar_width_
,
5982 doc
: /* *Width of this buffer's scroll bars in pixels.
5983 A value of nil means to use the scroll bar width from the window's frame. */);
5985 DEFVAR_PER_BUFFER ("vertical-scroll-bar", ¤t_buffer
->vertical_scroll_bar_type_
,
5987 doc
: /* *Position of this buffer's vertical scroll bar.
5988 The value takes effect whenever you tell a window to display this buffer;
5989 for instance, with `set-window-buffer' or when `display-buffer' displays it.
5991 A value of `left' or `right' means put the vertical scroll bar at that side
5992 of the window; a value of nil means don't show any vertical scroll bars.
5993 A value of t (the default) means do whatever the window's frame specifies. */);
5995 DEFVAR_PER_BUFFER ("indicate-empty-lines",
5996 ¤t_buffer
->indicate_empty_lines_
, Qnil
,
5997 doc
: /* *Visually indicate empty lines after the buffer end.
5998 If non-nil, a bitmap is displayed in the left fringe of a window on
5999 window-systems. */);
6001 DEFVAR_PER_BUFFER ("indicate-buffer-boundaries",
6002 ¤t_buffer
->indicate_buffer_boundaries_
, Qnil
,
6003 doc
: /* *Visually indicate buffer boundaries and scrolling.
6004 If non-nil, the first and last line of the buffer are marked in the fringe
6005 of a window on window-systems with angle bitmaps, or if the window can be
6006 scrolled, the top and bottom line of the window are marked with up and down
6009 If value is a symbol `left' or `right', both angle and arrow bitmaps
6010 are displayed in the left or right fringe, resp. Any other value
6011 that doesn't look like an alist means display the angle bitmaps in
6012 the left fringe but no arrows.
6014 You can exercise more precise control by using an alist as the
6015 value. Each alist element (INDICATOR . POSITION) specifies
6016 where to show one of the indicators. INDICATOR is one of `top',
6017 `bottom', `up', `down', or t, which specifies the default position,
6018 and POSITION is one of `left', `right', or nil, meaning do not show
6021 For example, ((top . left) (t . right)) places the top angle bitmap in
6022 left fringe, the bottom angle bitmap in right fringe, and both arrow
6023 bitmaps in right fringe. To show just the angle bitmaps in the left
6024 fringe, but no arrow bitmaps, use ((top . left) (bottom . left)). */);
6026 DEFVAR_PER_BUFFER ("fringe-indicator-alist",
6027 ¤t_buffer
->fringe_indicator_alist_
, Qnil
,
6028 doc
: /* *Mapping from logical to physical fringe indicator bitmaps.
6029 The value is an alist where each element (INDICATOR . BITMAPS)
6030 specifies the fringe bitmaps used to display a specific logical
6033 INDICATOR specifies the logical indicator type which is one of the
6034 following symbols: `truncation' , `continuation', `overlay-arrow',
6035 `top', `bottom', `up', `down', `one-line', `empty-line', or `unknown'.
6037 BITMAPS is list of symbols (LEFT RIGHT [LEFT1 RIGHT1]) which specifies
6038 the actual bitmap shown in the left or right fringe for the logical
6039 indicator. LEFT and RIGHT are the bitmaps shown in the left and/or
6040 right fringe for the specific indicator. The LEFT1 or RIGHT1 bitmaps
6041 are used only for the `bottom' and `one-line' indicators when the last
6042 \(only) line in has no final newline. BITMAPS may also be a single
6043 symbol which is used in both left and right fringes. */);
6045 DEFVAR_PER_BUFFER ("fringe-cursor-alist",
6046 ¤t_buffer
->fringe_cursor_alist_
, Qnil
,
6047 doc
: /* *Mapping from logical to physical fringe cursor bitmaps.
6048 The value is an alist where each element (CURSOR . BITMAP)
6049 specifies the fringe bitmaps used to display a specific logical
6050 cursor type in the fringe.
6052 CURSOR specifies the logical cursor type which is one of the following
6053 symbols: `box' , `hollow', `bar', `hbar', or `hollow-small'. The last
6054 one is used to show a hollow cursor on narrow lines display lines
6055 where the normal hollow cursor will not fit.
6057 BITMAP is the corresponding fringe bitmap shown for the logical
6060 DEFVAR_PER_BUFFER ("scroll-up-aggressively",
6061 ¤t_buffer
->scroll_up_aggressively_
, Qnil
,
6062 doc
: /* How far to scroll windows upward.
6063 If you move point off the bottom, the window scrolls automatically.
6064 This variable controls how far it scrolls. The value nil, the default,
6065 means scroll to center point. A fraction means scroll to put point
6066 that fraction of the window's height from the bottom of the window.
6067 When the value is 0.0, point goes at the bottom line, which in the
6068 simple case that you moved off with C-f means scrolling just one line.
6069 1.0 means point goes at the top, so that in that simple case, the
6070 window scrolls by a full window height. Meaningful values are
6071 between 0.0 and 1.0, inclusive. */);
6073 DEFVAR_PER_BUFFER ("scroll-down-aggressively",
6074 ¤t_buffer
->scroll_down_aggressively_
, Qnil
,
6075 doc
: /* How far to scroll windows downward.
6076 If you move point off the top, the window scrolls automatically.
6077 This variable controls how far it scrolls. The value nil, the default,
6078 means scroll to center point. A fraction means scroll to put point
6079 that fraction of the window's height from the top of the window.
6080 When the value is 0.0, point goes at the top line, which in the
6081 simple case that you moved off with C-b means scrolling just one line.
6082 1.0 means point goes at the bottom, so that in that simple case, the
6083 window scrolls by a full window height. Meaningful values are
6084 between 0.0 and 1.0, inclusive. */);
6086 /*DEFVAR_LISP ("debug-check-symbol", &Vcheck_symbol,
6090 DEFVAR_LISP ("before-change-functions", &Vbefore_change_functions
,
6091 doc
: /* List of functions to call before each text change.
6092 Two arguments are passed to each function: the positions of
6093 the beginning and end of the range of old text to be changed.
6094 \(For an insertion, the beginning and end are at the same place.)
6095 No information is given about the length of the text after the change.
6097 Buffer changes made while executing the `before-change-functions'
6098 don't call any before-change or after-change functions.
6099 That's because these variables are temporarily set to nil.
6100 As a result, a hook function cannot straightforwardly alter the
6101 value of these variables. See the Emacs Lisp manual for a way of
6102 accomplishing an equivalent result by using other variables.
6104 If an unhandled error happens in running these functions,
6105 the variable's value remains nil. That prevents the error
6106 from happening repeatedly and making Emacs nonfunctional. */);
6107 Vbefore_change_functions
= Qnil
;
6109 DEFVAR_LISP ("after-change-functions", &Vafter_change_functions
,
6110 doc
: /* List of functions to call after each text change.
6111 Three arguments are passed to each function: the positions of
6112 the beginning and end of the range of changed text,
6113 and the length in bytes of the pre-change text replaced by that range.
6114 \(For an insertion, the pre-change length is zero;
6115 for a deletion, that length is the number of bytes deleted,
6116 and the post-change beginning and end are at the same place.)
6118 Buffer changes made while executing the `after-change-functions'
6119 don't call any before-change or after-change functions.
6120 That's because these variables are temporarily set to nil.
6121 As a result, a hook function cannot straightforwardly alter the
6122 value of these variables. See the Emacs Lisp manual for a way of
6123 accomplishing an equivalent result by using other variables.
6125 If an unhandled error happens in running these functions,
6126 the variable's value remains nil. That prevents the error
6127 from happening repeatedly and making Emacs nonfunctional. */);
6128 Vafter_change_functions
= Qnil
;
6130 DEFVAR_LISP ("first-change-hook", &Vfirst_change_hook
,
6131 doc
: /* A list of functions to call before changing a buffer which is unmodified.
6132 The functions are run using the `run-hooks' function. */);
6133 Vfirst_change_hook
= Qnil
;
6135 DEFVAR_PER_BUFFER ("buffer-undo-list", ¤t_buffer
->undo_list_
, Qnil
,
6136 doc
: /* List of undo entries in current buffer.
6137 Recent changes come first; older changes follow newer.
6139 An entry (BEG . END) represents an insertion which begins at
6140 position BEG and ends at position END.
6142 An entry (TEXT . POSITION) represents the deletion of the string TEXT
6143 from (abs POSITION). If POSITION is positive, point was at the front
6144 of the text being deleted; if negative, point was at the end.
6146 An entry (t HIGH . LOW) indicates that the buffer previously had
6147 \"unmodified\" status. HIGH and LOW are the high and low 16-bit portions
6148 of the visited file's modification time, as of that time. If the
6149 modification time of the most recent save is different, this entry is
6152 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
6153 was modified between BEG and END. PROPERTY is the property name,
6154 and VALUE is the old value.
6156 An entry (apply FUN-NAME . ARGS) means undo the change with
6157 \(apply FUN-NAME ARGS).
6159 An entry (apply DELTA BEG END FUN-NAME . ARGS) supports selective undo
6160 in the active region. BEG and END is the range affected by this entry
6161 and DELTA is the number of bytes added or deleted in that range by
6164 An entry (MARKER . DISTANCE) indicates that the marker MARKER
6165 was adjusted in position by the offset DISTANCE (an integer).
6167 An entry of the form POSITION indicates that point was at the buffer
6168 location given by the integer. Undoing an entry of this form places
6171 Entries with value `nil' mark undo boundaries. The undo command treats
6172 the changes between two undo boundaries as a single step to be undone.
6174 If the value of the variable is t, undo information is not recorded. */);
6176 DEFVAR_PER_BUFFER ("mark-active", ¤t_buffer
->mark_active_
, Qnil
,
6177 doc
: /* Non-nil means the mark and region are currently active in this buffer. */);
6179 DEFVAR_PER_BUFFER ("cache-long-line-scans", ¤t_buffer
->cache_long_line_scans_
, Qnil
,
6180 doc
: /* Non-nil means that Emacs should use caches to handle long lines more quickly.
6182 Normally, the line-motion functions work by scanning the buffer for
6183 newlines. Columnar operations (like `move-to-column' and
6184 `compute-motion') also work by scanning the buffer, summing character
6185 widths as they go. This works well for ordinary text, but if the
6186 buffer's lines are very long (say, more than 500 characters), these
6187 motion functions will take longer to execute. Emacs may also take
6188 longer to update the display.
6190 If `cache-long-line-scans' is non-nil, these motion functions cache the
6191 results of their scans, and consult the cache to avoid rescanning
6192 regions of the buffer until the text is modified. The caches are most
6193 beneficial when they prevent the most searching---that is, when the
6194 buffer contains long lines and large regions of characters with the
6195 same, fixed screen width.
6197 When `cache-long-line-scans' is non-nil, processing short lines will
6198 become slightly slower (because of the overhead of consulting the
6199 cache), and the caches will use memory roughly proportional to the
6200 number of newlines and characters whose screen width varies.
6202 The caches require no explicit maintenance; their accuracy is
6203 maintained internally by the Emacs primitives. Enabling or disabling
6204 the cache should not affect the behavior of any of the motion
6205 functions; it should only affect their performance. */);
6207 DEFVAR_PER_BUFFER ("point-before-scroll", ¤t_buffer
->point_before_scroll_
, Qnil
,
6208 doc
: /* Value of point before the last series of scroll operations, or nil. */);
6210 DEFVAR_PER_BUFFER ("buffer-file-format", ¤t_buffer
->file_format_
, Qnil
,
6211 doc
: /* List of formats to use when saving this buffer.
6212 Formats are defined by `format-alist'. This variable is
6213 set when a file is visited. */);
6215 DEFVAR_PER_BUFFER ("buffer-auto-save-file-format",
6216 ¤t_buffer
->auto_save_file_format_
, Qnil
,
6217 doc
: /* *Format in which to write auto-save files.
6218 Should be a list of symbols naming formats that are defined in `format-alist'.
6219 If it is t, which is the default, auto-save files are written in the
6220 same format as a regular save would use. */);
6222 DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
6223 ¤t_buffer
->invisibility_spec_
, Qnil
,
6224 doc
: /* Invisibility spec of this buffer.
6225 The default is t, which means that text is invisible
6226 if it has a non-nil `invisible' property.
6227 If the value is a list, a text character is invisible if its `invisible'
6228 property is an element in that list (or is a list with members in common).
6229 If an element is a cons cell of the form (PROP . ELLIPSIS),
6230 then characters with property value PROP are invisible,
6231 and they have an ellipsis as well if ELLIPSIS is non-nil. */);
6233 DEFVAR_PER_BUFFER ("buffer-display-count",
6234 ¤t_buffer
->display_count_
, Qnil
,
6235 doc
: /* A number incremented each time this buffer is displayed in a window.
6236 The function `set-window-buffer' increments it. */);
6238 DEFVAR_PER_BUFFER ("buffer-display-time",
6239 ¤t_buffer
->display_time_
, Qnil
,
6240 doc
: /* Time stamp updated each time this buffer is displayed in a window.
6241 The function `set-window-buffer' updates this variable
6242 to the value obtained by calling `current-time'.
6243 If the buffer has never been shown in a window, the value is nil. */);
6245 DEFVAR_LISP ("transient-mark-mode", &Vtransient_mark_mode
,
6247 Vtransient_mark_mode
= Qnil
;
6248 /* The docstring is in simple.el. If we put it here, it would be
6249 overwritten when transient-mark-mode is defined using
6250 define-minor-mode. */
6252 DEFVAR_LISP ("inhibit-read-only", &Vinhibit_read_only
,
6253 doc
: /* *Non-nil means disregard read-only status of buffers or characters.
6254 If the value is t, disregard `buffer-read-only' and all `read-only'
6255 text properties. If the value is a list, disregard `buffer-read-only'
6256 and disregard a `read-only' text property if the property value
6257 is a member of the list. */);
6258 Vinhibit_read_only
= Qnil
;
6260 DEFVAR_PER_BUFFER ("cursor-type", ¤t_buffer
->cursor_type_
, Qnil
,
6261 doc
: /* Cursor to use when this buffer is in the selected window.
6262 Values are interpreted as follows:
6264 t use the cursor specified for the frame
6265 nil don't display a cursor
6266 box display a filled box cursor
6267 hollow display a hollow box cursor
6268 bar display a vertical bar cursor with default width
6269 (bar . WIDTH) display a vertical bar cursor with width WIDTH
6270 hbar display a horizontal bar cursor with default height
6271 (hbar . HEIGHT) display a horizontal bar cursor with height HEIGHT
6272 ANYTHING ELSE display a hollow box cursor
6274 When the buffer is displayed in a non-selected window, the
6275 cursor's appearance is instead controlled by the variable
6276 `cursor-in-non-selected-windows'. */);
6278 DEFVAR_PER_BUFFER ("line-spacing",
6279 ¤t_buffer
->extra_line_spacing_
, Qnil
,
6280 doc
: /* Additional space to put between lines when displaying a buffer.
6281 The space is measured in pixels, and put below lines on graphic displays,
6282 see `display-graphic-p'.
6283 If value is a floating point number, it specifies the spacing relative
6284 to the default frame line height. A value of nil means add no extra space. */);
6286 DEFVAR_PER_BUFFER ("cursor-in-non-selected-windows",
6287 ¤t_buffer
->cursor_in_non_selected_windows_
, Qnil
,
6288 doc
: /* *Cursor type to display in non-selected windows.
6289 The value t means to use hollow box cursor. See `cursor-type' for other values. */);
6291 DEFVAR_LISP ("kill-buffer-query-functions", &Vkill_buffer_query_functions
,
6292 doc
: /* List of functions called with no args to query before killing a buffer.
6293 The buffer being killed will be current while the functions are running.
6294 If any of them returns nil, the buffer is not killed. */);
6295 Vkill_buffer_query_functions
= Qnil
;
6297 DEFVAR_LISP ("change-major-mode-hook", &Vchange_major_mode_hook
,
6298 doc
: /* Normal hook run before changing the major mode of a buffer.
6299 The function `kill-all-local-variables' runs this before doing anything else. */);
6300 Vchange_major_mode_hook
= Qnil
;
6301 Qchange_major_mode_hook
= intern_c_string ("change-major-mode-hook");
6302 staticpro (&Qchange_major_mode_hook
);
6304 defsubr (&Sbuffer_live_p
);
6305 defsubr (&Sbuffer_list
);
6306 defsubr (&Sget_buffer
);
6307 defsubr (&Sget_file_buffer
);
6308 defsubr (&Sget_buffer_create
);
6309 defsubr (&Smake_indirect_buffer
);
6310 defsubr (&Sgenerate_new_buffer_name
);
6311 defsubr (&Sbuffer_name
);
6312 /*defsubr (&Sbuffer_number);*/
6313 defsubr (&Sbuffer_file_name
);
6314 defsubr (&Sbuffer_base_buffer
);
6315 defsubr (&Sbuffer_local_value
);
6316 defsubr (&Sbuffer_local_variables
);
6317 defsubr (&Sbuffer_modified_p
);
6318 defsubr (&Sset_buffer_modified_p
);
6319 defsubr (&Sbuffer_modified_tick
);
6320 defsubr (&Sbuffer_chars_modified_tick
);
6321 defsubr (&Srename_buffer
);
6322 defsubr (&Sother_buffer
);
6323 defsubr (&Sbuffer_enable_undo
);
6324 defsubr (&Skill_buffer
);
6325 defsubr (&Sset_buffer_major_mode
);
6326 defsubr (&Sswitch_to_buffer
);
6327 defsubr (&Scurrent_buffer
);
6328 defsubr (&Sset_buffer
);
6329 defsubr (&Sbarf_if_buffer_read_only
);
6330 defsubr (&Sbury_buffer
);
6331 defsubr (&Serase_buffer
);
6332 defsubr (&Sbuffer_swap_text
);
6333 defsubr (&Sset_buffer_multibyte
);
6334 defsubr (&Skill_all_local_variables
);
6336 defsubr (&Soverlayp
);
6337 defsubr (&Smake_overlay
);
6338 defsubr (&Sdelete_overlay
);
6339 defsubr (&Smove_overlay
);
6340 defsubr (&Soverlay_start
);
6341 defsubr (&Soverlay_end
);
6342 defsubr (&Soverlay_buffer
);
6343 defsubr (&Soverlay_properties
);
6344 defsubr (&Soverlays_at
);
6345 defsubr (&Soverlays_in
);
6346 defsubr (&Snext_overlay_change
);
6347 defsubr (&Sprevious_overlay_change
);
6348 defsubr (&Soverlay_recenter
);
6349 defsubr (&Soverlay_lists
);
6350 defsubr (&Soverlay_get
);
6351 defsubr (&Soverlay_put
);
6352 defsubr (&Srestore_buffer_modified_p
);
6358 initial_define_key (control_x_map
, 'b', "switch-to-buffer");
6359 initial_define_key (control_x_map
, 'k', "kill-buffer");
6361 /* This must not be in syms_of_buffer, because Qdisabled is not
6362 initialized when that function gets called. */
6363 Fput (intern_c_string ("erase-buffer"), Qdisabled
, Qt
);
6366 /* arch-tag: e48569bf-69a9-4b65-a23b-8e68769436e1
6367 (do not change this comment) */