1 /* Buffer manipulation primitives for GNU Emacs.
2 Copyright (C) 1985,86,87,88,89,93,94,95,97,98, 1999, 2000, 2001, 02, 03, 2004
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
24 #include <sys/types.h>
26 #include <sys/param.h>
35 /* in 4.1 [probably SunOS? -stef] , param.h fails to define this. */
36 #define MAXPATHLEN 1024
37 #endif /* not MAXPATHLEN */
44 #include "intervals.h"
49 #include "region-cache.h"
51 #include "blockinput.h"
56 struct buffer
*current_buffer
; /* the current buffer */
58 /* First buffer in chain of all buffers (in reverse order of creation).
59 Threaded through ->next. */
61 struct buffer
*all_buffers
;
63 /* This structure holds the default values of the buffer-local variables
64 defined with DEFVAR_PER_BUFFER, that have special slots in each buffer.
65 The default value occupies the same slot in this structure
66 as an individual buffer's value occupies in that buffer.
67 Setting the default value also goes through the alist of buffers
68 and stores into each buffer that does not say it has a local value. */
70 DECL_ALIGN (struct buffer
, buffer_defaults
);
72 /* A Lisp_Object pointer to the above, used for staticpro */
74 static Lisp_Object Vbuffer_defaults
;
76 /* This structure marks which slots in a buffer have corresponding
77 default values in buffer_defaults.
78 Each such slot has a nonzero value in this structure.
79 The value has only one nonzero bit.
81 When a buffer has its own local value for a slot,
82 the entry for that slot (found in the same slot in this structure)
83 is turned on in the buffer's local_flags array.
85 If a slot in this structure is -1, then even though there may
86 be a DEFVAR_PER_BUFFER for the slot, there is no default value for it;
87 and the corresponding slot in buffer_defaults is not used.
89 If a slot is -2, then there is no DEFVAR_PER_BUFFER for it,
90 but there is a default value which is copied into each buffer.
92 If a slot in this structure corresponding to a DEFVAR_PER_BUFFER is
93 zero, that is a bug */
95 struct buffer buffer_local_flags
;
97 /* This structure holds the names of symbols whose values may be
98 buffer-local. It is indexed and accessed in the same way as the above. */
100 DECL_ALIGN (struct buffer
, buffer_local_symbols
);
102 /* A Lisp_Object pointer to the above, used for staticpro */
103 static Lisp_Object Vbuffer_local_symbols
;
105 /* This structure holds the required types for the values in the
106 buffer-local slots. If a slot contains Qnil, then the
107 corresponding buffer slot may contain a value of any type. If a
108 slot contains an integer, then prospective values' tags must be
109 equal to that integer (except nil is always allowed).
110 When a tag does not match, the function
111 buffer_slot_type_mismatch will signal an error.
113 If a slot here contains -1, the corresponding variable is read-only. */
114 struct buffer buffer_local_types
;
116 /* Flags indicating which built-in buffer-local variables
117 are permanent locals. */
118 static char buffer_permanent_local_flags
[MAX_PER_BUFFER_VARS
];
120 /* Number of per-buffer variables used. */
122 int last_per_buffer_idx
;
124 Lisp_Object
Fset_buffer ();
125 void set_buffer_internal ();
126 void set_buffer_internal_1 ();
127 static void call_overlay_mod_hooks ();
128 static void swap_out_buffer_local_variables ();
129 static void reset_buffer_local_variables ();
131 /* Alist of all buffer names vs the buffers. */
132 /* This used to be a variable, but is no longer,
133 to prevent lossage due to user rplac'ing this alist or its elements. */
134 Lisp_Object Vbuffer_alist
;
136 /* Functions to call before and after each text change. */
137 Lisp_Object Vbefore_change_functions
;
138 Lisp_Object Vafter_change_functions
;
140 Lisp_Object Vtransient_mark_mode
;
142 /* t means ignore all read-only text properties.
143 A list means ignore such a property if its value is a member of the list.
144 Any non-nil value means ignore buffer-read-only. */
145 Lisp_Object Vinhibit_read_only
;
147 /* List of functions to call that can query about killing a buffer.
148 If any of these functions returns nil, we don't kill it. */
149 Lisp_Object Vkill_buffer_query_functions
;
150 Lisp_Object Qkill_buffer_query_functions
;
152 /* List of functions to call before changing an unmodified buffer. */
153 Lisp_Object Vfirst_change_hook
;
155 Lisp_Object Qfirst_change_hook
;
156 Lisp_Object Qbefore_change_functions
;
157 Lisp_Object Qafter_change_functions
;
158 Lisp_Object Qucs_set_table_for_input
;
160 /* If nonzero, all modification hooks are suppressed. */
161 int inhibit_modification_hooks
;
163 Lisp_Object Qfundamental_mode
, Qmode_class
, Qpermanent_local
;
165 Lisp_Object Qprotected_field
;
167 Lisp_Object QSFundamental
; /* A string "Fundamental" */
169 Lisp_Object Qkill_buffer_hook
;
171 Lisp_Object Qget_file_buffer
;
173 Lisp_Object Qoverlayp
;
175 Lisp_Object Qpriority
, Qwindow
, Qevaporate
, Qbefore_string
, Qafter_string
;
177 Lisp_Object Qmodification_hooks
;
178 Lisp_Object Qinsert_in_front_hooks
;
179 Lisp_Object Qinsert_behind_hooks
;
181 static void alloc_buffer_text
P_ ((struct buffer
*, size_t));
182 static void free_buffer_text
P_ ((struct buffer
*b
));
183 static struct Lisp_Overlay
* copy_overlays
P_ ((struct buffer
*, struct Lisp_Overlay
*));
184 static void modify_overlay
P_ ((struct buffer
*, EMACS_INT
, EMACS_INT
));
187 /* For debugging; temporary. See set_buffer_internal. */
188 /* Lisp_Object Qlisp_mode, Vcheck_symbol; */
195 error ("No buffer named %s", SDATA (spec
));
196 error ("Invalid buffer argument");
199 DEFUN ("buffer-live-p", Fbuffer_live_p
, Sbuffer_live_p
, 1, 1, 0,
200 doc
: /* Return non-nil if OBJECT is a buffer which has not been killed.
201 Value is nil if OBJECT is not a buffer or if it has been killed. */)
205 return ((BUFFERP (object
) && ! NILP (XBUFFER (object
)->name
))
209 DEFUN ("buffer-list", Fbuffer_list
, Sbuffer_list
, 0, 1, 0,
210 doc
: /* Return a list of all existing live buffers.
211 If the optional arg FRAME is a frame, we return the buffer list
212 in the proper order for that frame: the buffers in FRAME's `buffer-list'
213 frame parameter come first, followed by the rest of the buffers. */)
217 Lisp_Object framelist
, general
;
218 general
= Fmapcar (Qcdr
, Vbuffer_alist
);
226 framelist
= Fcopy_sequence (XFRAME (frame
)->buffer_list
);
228 /* Remove from GENERAL any buffer that duplicates one in FRAMELIST. */
230 while (! NILP (tail
))
232 general
= Fdelq (XCAR (tail
), general
);
235 return nconc2 (framelist
, general
);
241 /* Like Fassoc, but use Fstring_equal to compare
242 (which ignores text properties),
243 and don't ever QUIT. */
246 assoc_ignore_text_properties (key
, list
)
247 register Lisp_Object key
;
250 register Lisp_Object tail
;
251 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
253 register Lisp_Object elt
, tem
;
255 tem
= Fstring_equal (Fcar (elt
), key
);
262 DEFUN ("get-buffer", Fget_buffer
, Sget_buffer
, 1, 1, 0,
263 doc
: /* Return the buffer named NAME (a string).
264 If there is no live buffer named NAME, return nil.
265 NAME may also be a buffer; if so, the value is that buffer. */)
267 register Lisp_Object name
;
273 return Fcdr (assoc_ignore_text_properties (name
, Vbuffer_alist
));
276 DEFUN ("get-file-buffer", Fget_file_buffer
, Sget_file_buffer
, 1, 1, 0,
277 doc
: /* Return the buffer visiting file FILENAME (a string).
278 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
279 If there is no such live buffer, return nil.
280 See also `find-buffer-visiting'. */)
282 register Lisp_Object filename
;
284 register Lisp_Object tail
, buf
, tem
;
287 CHECK_STRING (filename
);
288 filename
= Fexpand_file_name (filename
, Qnil
);
290 /* If the file name has special constructs in it,
291 call the corresponding file handler. */
292 handler
= Ffind_file_name_handler (filename
, Qget_file_buffer
);
294 return call2 (handler
, Qget_file_buffer
, filename
);
296 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
298 buf
= Fcdr (XCAR (tail
));
299 if (!BUFFERP (buf
)) continue;
300 if (!STRINGP (XBUFFER (buf
)->filename
)) continue;
301 tem
= Fstring_equal (XBUFFER (buf
)->filename
, filename
);
309 get_truename_buffer (filename
)
310 register Lisp_Object filename
;
312 register Lisp_Object tail
, buf
, tem
;
314 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
316 buf
= Fcdr (XCAR (tail
));
317 if (!BUFFERP (buf
)) continue;
318 if (!STRINGP (XBUFFER (buf
)->file_truename
)) continue;
319 tem
= Fstring_equal (XBUFFER (buf
)->file_truename
, filename
);
326 /* Incremented for each buffer created, to assign the buffer number. */
329 DEFUN ("get-buffer-create", Fget_buffer_create
, Sget_buffer_create
, 1, 1, 0,
330 doc
: /* Return the buffer named NAME, or create such a buffer and return it.
331 A new buffer is created if there is no live buffer named NAME.
332 If NAME starts with a space, the new buffer does not keep undo information.
333 If NAME is a buffer instead of a string, then it is the value returned.
334 The value is never nil. */)
336 register Lisp_Object name
;
338 register Lisp_Object buf
;
339 register struct buffer
*b
;
341 buf
= Fget_buffer (name
);
345 if (SCHARS (name
) == 0)
346 error ("Empty string for buffer name is not allowed");
348 b
= (struct buffer
*) allocate_buffer ();
350 b
->size
= sizeof (struct buffer
) / sizeof (EMACS_INT
);
352 /* An ordinary buffer uses its own struct buffer_text. */
353 b
->text
= &b
->own_text
;
356 BUF_GAP_SIZE (b
) = 20;
358 /* We allocate extra 1-byte at the tail and keep it always '\0' for
359 anchoring a search. */
360 alloc_buffer_text (b
, BUF_GAP_SIZE (b
) + 1);
362 if (! BUF_BEG_ADDR (b
))
363 buffer_memory_full ();
370 BUF_PT_BYTE (b
) = BEG_BYTE
;
371 BUF_GPT_BYTE (b
) = BEG_BYTE
;
372 BUF_BEGV_BYTE (b
) = BEG_BYTE
;
373 BUF_ZV_BYTE (b
) = BEG_BYTE
;
374 BUF_Z_BYTE (b
) = BEG_BYTE
;
376 BUF_OVERLAY_MODIFF (b
) = 1;
377 BUF_SAVE_MODIFF (b
) = 1;
378 BUF_INTERVALS (b
) = 0;
379 BUF_UNCHANGED_MODIFIED (b
) = 1;
380 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = 1;
381 BUF_END_UNCHANGED (b
) = 0;
382 BUF_BEG_UNCHANGED (b
) = 0;
383 *(BUF_GPT_ADDR (b
)) = *(BUF_Z_ADDR (b
)) = 0; /* Put an anchor '\0'. */
385 b
->newline_cache
= 0;
386 b
->width_run_cache
= 0;
387 b
->width_table
= Qnil
;
388 b
->prevent_redisplay_optimizations_p
= 1;
390 /* Put this on the chain of all buffers including killed ones. */
391 b
->next
= all_buffers
;
394 /* An ordinary buffer normally doesn't need markers
395 to handle BEGV and ZV. */
397 b
->begv_marker
= Qnil
;
400 name
= Fcopy_sequence (name
);
401 STRING_SET_INTERVALS (name
, NULL_INTERVAL
);
404 if (SREF (name
, 0) != ' ')
410 reset_buffer_local_variables (b
, 1);
412 b
->mark
= Fmake_marker ();
413 BUF_MARKERS (b
) = NULL
;
416 /* Put this in the alist of all live buffers. */
418 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buf
), Qnil
));
420 /* An error in calling the function here (should someone redfine it)
421 can lead to infinite regress until you run out of stack. rms
422 says that's not worth protecting against. */
423 if (!NILP (Ffboundp (Qucs_set_table_for_input
)))
424 /* buf is on buffer-alist, so no gcpro. */
425 call1 (Qucs_set_table_for_input
, buf
);
431 /* Return a list of overlays which is a copy of the overlay list
432 LIST, but for buffer B. */
434 static struct Lisp_Overlay
*
435 copy_overlays (b
, list
)
437 struct Lisp_Overlay
*list
;
440 struct Lisp_Overlay
*result
= NULL
, *tail
= NULL
;
442 XSETBUFFER (buffer
, b
);
444 for (; list
; list
= list
->next
)
446 Lisp_Object overlay
, start
, end
, old_overlay
;
449 XSETMISC (old_overlay
, list
);
450 charpos
= marker_position (OVERLAY_START (old_overlay
));
451 start
= Fmake_marker ();
452 Fset_marker (start
, make_number (charpos
), buffer
);
453 XMARKER (start
)->insertion_type
454 = XMARKER (OVERLAY_START (old_overlay
))->insertion_type
;
456 charpos
= marker_position (OVERLAY_END (old_overlay
));
457 end
= Fmake_marker ();
458 Fset_marker (end
, make_number (charpos
), buffer
);
459 XMARKER (end
)->insertion_type
460 = XMARKER (OVERLAY_END (old_overlay
))->insertion_type
;
462 overlay
= allocate_misc ();
463 XMISCTYPE (overlay
) = Lisp_Misc_Overlay
;
464 OVERLAY_START (overlay
) = start
;
465 OVERLAY_END (overlay
) = end
;
466 OVERLAY_PLIST (overlay
) = Fcopy_sequence (OVERLAY_PLIST (old_overlay
));
467 XOVERLAY (overlay
)->next
= NULL
;
470 tail
= tail
->next
= XOVERLAY (overlay
);
472 result
= tail
= XOVERLAY (overlay
);
479 /* Clone per-buffer values of buffer FROM.
481 Buffer TO gets the same per-buffer values as FROM, with the
482 following exceptions: (1) TO's name is left untouched, (2) markers
483 are copied and made to refer to TO, and (3) overlay lists are
487 clone_per_buffer_values (from
, to
)
488 struct buffer
*from
, *to
;
490 Lisp_Object to_buffer
;
493 XSETBUFFER (to_buffer
, to
);
495 for (offset
= PER_BUFFER_VAR_OFFSET (name
) + sizeof (Lisp_Object
);
497 offset
+= sizeof (Lisp_Object
))
501 obj
= PER_BUFFER_VALUE (from
, offset
);
504 struct Lisp_Marker
*m
= XMARKER (obj
);
505 obj
= Fmake_marker ();
506 XMARKER (obj
)->insertion_type
= m
->insertion_type
;
507 set_marker_both (obj
, to_buffer
, m
->charpos
, m
->bytepos
);
510 PER_BUFFER_VALUE (to
, offset
) = obj
;
513 bcopy (from
->local_flags
, to
->local_flags
, sizeof to
->local_flags
);
515 to
->overlays_before
= copy_overlays (to
, from
->overlays_before
);
516 to
->overlays_after
= copy_overlays (to
, from
->overlays_after
);
520 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer
, Smake_indirect_buffer
,
522 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ",
523 doc
: /* Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.
524 BASE-BUFFER should be an existing buffer (or buffer name).
525 NAME should be a string which is not the name of an existing buffer.
526 Optional argument CLONE non-nil means preserve BASE-BUFFER's state,
527 such as major and minor modes, in the indirect buffer.
528 CLONE nil means the indirect buffer's state is reset to default values. */)
529 (base_buffer
, name
, clone
)
530 Lisp_Object base_buffer
, name
, clone
;
535 buf
= Fget_buffer (name
);
537 error ("Buffer name `%s' is in use", SDATA (name
));
539 base_buffer
= Fget_buffer (base_buffer
);
540 if (NILP (base_buffer
))
541 error ("No such buffer: `%s'", SDATA (name
));
543 if (SCHARS (name
) == 0)
544 error ("Empty string for buffer name is not allowed");
546 b
= (struct buffer
*) allocate_buffer ();
547 b
->size
= sizeof (struct buffer
) / sizeof (EMACS_INT
);
549 if (XBUFFER (base_buffer
)->base_buffer
)
550 b
->base_buffer
= XBUFFER (base_buffer
)->base_buffer
;
552 b
->base_buffer
= XBUFFER (base_buffer
);
554 /* Use the base buffer's text object. */
555 b
->text
= b
->base_buffer
->text
;
557 BUF_BEGV (b
) = BUF_BEGV (b
->base_buffer
);
558 BUF_ZV (b
) = BUF_ZV (b
->base_buffer
);
559 BUF_PT (b
) = BUF_PT (b
->base_buffer
);
560 BUF_BEGV_BYTE (b
) = BUF_BEGV_BYTE (b
->base_buffer
);
561 BUF_ZV_BYTE (b
) = BUF_ZV_BYTE (b
->base_buffer
);
562 BUF_PT_BYTE (b
) = BUF_PT_BYTE (b
->base_buffer
);
564 b
->newline_cache
= 0;
565 b
->width_run_cache
= 0;
566 b
->width_table
= Qnil
;
568 /* Put this on the chain of all buffers including killed ones. */
569 b
->next
= all_buffers
;
572 name
= Fcopy_sequence (name
);
573 STRING_SET_INTERVALS (name
, NULL_INTERVAL
);
577 reset_buffer_local_variables (b
, 1);
579 /* Put this in the alist of all live buffers. */
581 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buf
), Qnil
));
583 b
->mark
= Fmake_marker ();
586 /* The multibyte status belongs to the base buffer. */
587 b
->enable_multibyte_characters
= b
->base_buffer
->enable_multibyte_characters
;
589 /* Make sure the base buffer has markers for its narrowing. */
590 if (NILP (b
->base_buffer
->pt_marker
))
592 b
->base_buffer
->pt_marker
= Fmake_marker ();
593 set_marker_both (b
->base_buffer
->pt_marker
, base_buffer
,
594 BUF_PT (b
->base_buffer
),
595 BUF_PT_BYTE (b
->base_buffer
));
597 if (NILP (b
->base_buffer
->begv_marker
))
599 b
->base_buffer
->begv_marker
= Fmake_marker ();
600 set_marker_both (b
->base_buffer
->begv_marker
, base_buffer
,
601 BUF_BEGV (b
->base_buffer
),
602 BUF_BEGV_BYTE (b
->base_buffer
));
604 if (NILP (b
->base_buffer
->zv_marker
))
606 b
->base_buffer
->zv_marker
= Fmake_marker ();
607 set_marker_both (b
->base_buffer
->zv_marker
, base_buffer
,
608 BUF_ZV (b
->base_buffer
),
609 BUF_ZV_BYTE (b
->base_buffer
));
610 XMARKER (b
->base_buffer
->zv_marker
)->insertion_type
= 1;
615 /* Give the indirect buffer markers for its narrowing. */
616 b
->pt_marker
= Fmake_marker ();
617 set_marker_both (b
->pt_marker
, buf
, BUF_PT (b
), BUF_PT_BYTE (b
));
618 b
->begv_marker
= Fmake_marker ();
619 set_marker_both (b
->begv_marker
, buf
, BUF_BEGV (b
), BUF_BEGV_BYTE (b
));
620 b
->zv_marker
= Fmake_marker ();
621 set_marker_both (b
->zv_marker
, buf
, BUF_ZV (b
), BUF_ZV_BYTE (b
));
622 XMARKER (b
->zv_marker
)->insertion_type
= 1;
625 clone_per_buffer_values (b
->base_buffer
, b
);
631 delete_all_overlays (b
)
636 /* `reset_buffer' blindly sets the list of overlays to NULL, so we
637 have to empty the list, otherwise we end up with overlays that
638 think they belong to this buffer while the buffer doesn't know about
640 while (b
->overlays_before
)
642 XSETMISC (overlay
, b
->overlays_before
);
643 Fdelete_overlay (overlay
);
645 while (b
->overlays_after
)
647 XSETMISC (overlay
, b
->overlays_after
);
648 Fdelete_overlay (overlay
);
650 eassert (b
->overlays_before
== NULL
);
651 eassert (b
->overlays_after
== NULL
);
654 /* Reinitialize everything about a buffer except its name and contents
656 If called on an already-initialized buffer, the list of overlays
657 should be deleted before calling this function, otherwise we end up
658 with overlays that claim to belong to the buffer but the buffer
659 claims it doesn't belong to it. */
663 register struct buffer
*b
;
666 b
->file_truename
= Qnil
;
667 b
->directory
= (current_buffer
) ? current_buffer
->directory
: Qnil
;
669 XSETFASTINT (b
->save_length
, 0);
670 b
->last_window_start
= 1;
671 /* It is more conservative to start out "changed" than "unchanged". */
673 b
->prevent_redisplay_optimizations_p
= 1;
675 b
->auto_save_modified
= 0;
676 b
->auto_save_failure_time
= -1;
677 b
->auto_save_file_name
= Qnil
;
679 b
->overlays_before
= NULL
;
680 b
->overlays_after
= NULL
;
681 b
->overlay_center
= BEG
;
682 b
->mark_active
= Qnil
;
683 b
->point_before_scroll
= Qnil
;
684 b
->file_format
= Qnil
;
685 b
->last_selected_window
= Qnil
;
686 XSETINT (b
->display_count
, 0);
687 b
->display_time
= Qnil
;
688 b
->enable_multibyte_characters
= buffer_defaults
.enable_multibyte_characters
;
689 b
->cursor_type
= buffer_defaults
.cursor_type
;
690 b
->extra_line_spacing
= buffer_defaults
.extra_line_spacing
;
692 b
->display_error_modiff
= 0;
695 /* Reset buffer B's local variables info.
696 Don't use this on a buffer that has already been in use;
697 it does not treat permanent locals consistently.
698 Instead, use Fkill_all_local_variables.
700 If PERMANENT_TOO is 1, then we reset permanent built-in
701 buffer-local variables. If PERMANENT_TOO is 0,
702 we preserve those. */
705 reset_buffer_local_variables (b
, permanent_too
)
706 register struct buffer
*b
;
712 /* Reset the major mode to Fundamental, together with all the
713 things that depend on the major mode.
714 default-major-mode is handled at a higher level.
715 We ignore it here. */
716 b
->major_mode
= Qfundamental_mode
;
718 b
->mode_name
= QSFundamental
;
719 b
->minor_modes
= Qnil
;
721 /* If the standard case table has been altered and invalidated,
722 fix up its insides first. */
723 if (! (CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[0])
724 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[1])
725 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[2])))
726 Fset_standard_case_table (Vascii_downcase_table
);
728 b
->downcase_table
= Vascii_downcase_table
;
729 b
->upcase_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[0];
730 b
->case_canon_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[1];
731 b
->case_eqv_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[2];
732 b
->invisibility_spec
= Qt
;
734 b
->buffer_file_type
= Qnil
;
737 /* Reset all (or most) per-buffer variables to their defaults. */
738 b
->local_var_alist
= Qnil
;
739 for (i
= 0; i
< last_per_buffer_idx
; ++i
)
740 if (permanent_too
|| buffer_permanent_local_flags
[i
] == 0)
741 SET_PER_BUFFER_VALUE_P (b
, i
, 0);
743 /* For each slot that has a default value,
744 copy that into the slot. */
746 for (offset
= PER_BUFFER_VAR_OFFSET (name
);
748 offset
+= sizeof (Lisp_Object
))
750 int idx
= PER_BUFFER_IDX (offset
);
753 || buffer_permanent_local_flags
[idx
] == 0))
754 /* Is -2 used anywhere? */
756 PER_BUFFER_VALUE (b
, offset
) = PER_BUFFER_DEFAULT (offset
);
760 /* We split this away from generate-new-buffer, because rename-buffer
761 and set-visited-file-name ought to be able to use this to really
762 rename the buffer properly. */
764 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name
, Sgenerate_new_buffer_name
,
766 doc
: /* Return a string that is the name of no existing buffer based on NAME.
767 If there is no live buffer named NAME, then return NAME.
768 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
769 \(starting at 2) until an unused name is found, and then return that name.
770 Optional second argument IGNORE specifies a name that is okay to use
771 \(if it is in the sequence to be tried)
772 even if a buffer with that name exists. */)
774 register Lisp_Object name
, ignore
;
776 register Lisp_Object gentemp
, tem
;
782 tem
= Fstring_equal (name
, ignore
);
785 tem
= Fget_buffer (name
);
792 sprintf (number
, "<%d>", ++count
);
793 gentemp
= concat2 (name
, build_string (number
));
794 tem
= Fstring_equal (gentemp
, ignore
);
797 tem
= Fget_buffer (gentemp
);
804 DEFUN ("buffer-name", Fbuffer_name
, Sbuffer_name
, 0, 1, 0,
805 doc
: /* Return the name of BUFFER, as a string.
806 With no argument or nil as argument, return the name of the current buffer. */)
808 register Lisp_Object buffer
;
811 return current_buffer
->name
;
812 CHECK_BUFFER (buffer
);
813 return XBUFFER (buffer
)->name
;
816 DEFUN ("buffer-file-name", Fbuffer_file_name
, Sbuffer_file_name
, 0, 1, 0,
817 doc
: /* Return name of file BUFFER is visiting, or nil if none.
818 No argument or nil as argument means use the current buffer. */)
820 register Lisp_Object buffer
;
823 return current_buffer
->filename
;
824 CHECK_BUFFER (buffer
);
825 return XBUFFER (buffer
)->filename
;
828 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer
, Sbuffer_base_buffer
,
830 doc
: /* Return the base buffer of indirect buffer BUFFER.
831 If BUFFER is not indirect, return nil. */)
833 register Lisp_Object buffer
;
836 Lisp_Object base_buffer
;
839 base
= current_buffer
->base_buffer
;
842 CHECK_BUFFER (buffer
);
843 base
= XBUFFER (buffer
)->base_buffer
;
848 XSETBUFFER (base_buffer
, base
);
852 DEFUN ("buffer-local-value", Fbuffer_local_value
,
853 Sbuffer_local_value
, 2, 2, 0,
854 doc
: /* Return the value of VARIABLE in BUFFER.
855 If VARIABLE does not have a buffer-local binding in BUFFER, the value
856 is the default binding of variable. */)
858 register Lisp_Object symbol
;
859 register Lisp_Object buffer
;
861 register struct buffer
*buf
;
862 register Lisp_Object result
;
864 CHECK_SYMBOL (symbol
);
865 CHECK_BUFFER (buffer
);
866 buf
= XBUFFER (buffer
);
868 /* Look in local_var_list */
869 result
= Fassoc (symbol
, buf
->local_var_alist
);
875 /* Look in special slots */
876 for (offset
= PER_BUFFER_VAR_OFFSET (name
);
877 offset
< sizeof (struct buffer
);
878 /* sizeof EMACS_INT == sizeof Lisp_Object */
879 offset
+= (sizeof (EMACS_INT
)))
881 idx
= PER_BUFFER_IDX (offset
);
882 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
883 && SYMBOLP (PER_BUFFER_SYMBOL (offset
))
884 && EQ (PER_BUFFER_SYMBOL (offset
), symbol
))
886 result
= PER_BUFFER_VALUE (buf
, offset
);
893 result
= Fdefault_value (symbol
);
897 Lisp_Object valcontents
;
898 Lisp_Object current_alist_element
;
900 /* What binding is loaded right now? */
901 valcontents
= SYMBOL_VALUE (symbol
);
902 current_alist_element
903 = XCAR (XBUFFER_LOCAL_VALUE (valcontents
)->cdr
);
905 /* The value of the currently loaded binding is not
906 stored in it, but rather in the realvalue slot.
907 Store that value into the binding it belongs to
908 in case that is the one we are about to use. */
910 Fsetcdr (current_alist_element
,
911 do_symval_forwarding (XBUFFER_LOCAL_VALUE (valcontents
)->realvalue
));
913 /* Now get the (perhaps updated) value out of the binding. */
914 result
= XCDR (result
);
917 if (EQ (result
, Qunbound
))
918 return Fsignal (Qvoid_variable
, Fcons (symbol
, Qnil
));
923 DEFUN ("buffer-local-variables", Fbuffer_local_variables
,
924 Sbuffer_local_variables
, 0, 1, 0,
925 doc
: /* Return an alist of variables that are buffer-local in BUFFER.
926 Most elements look like (SYMBOL . VALUE), describing one variable.
927 For a symbol that is locally unbound, just the symbol appears in the value.
928 Note that storing new VALUEs in these elements doesn't change the variables.
929 No argument or nil as argument means use current buffer as BUFFER. */)
931 register Lisp_Object buffer
;
933 register struct buffer
*buf
;
934 register Lisp_Object result
;
937 buf
= current_buffer
;
940 CHECK_BUFFER (buffer
);
941 buf
= XBUFFER (buffer
);
947 register Lisp_Object tail
;
948 for (tail
= buf
->local_var_alist
; CONSP (tail
); tail
= XCDR (tail
))
950 Lisp_Object val
, elt
;
954 /* Reference each variable in the alist in buf.
955 If inquiring about the current buffer, this gets the current values,
956 so store them into the alist so the alist is up to date.
957 If inquiring about some other buffer, this swaps out any values
958 for that buffer, making the alist up to date automatically. */
959 val
= find_symbol_value (XCAR (elt
));
960 /* Use the current buffer value only if buf is the current buffer. */
961 if (buf
!= current_buffer
)
964 /* If symbol is unbound, put just the symbol in the list. */
965 if (EQ (val
, Qunbound
))
966 result
= Fcons (XCAR (elt
), result
);
967 /* Otherwise, put (symbol . value) in the list. */
969 result
= Fcons (Fcons (XCAR (elt
), val
), result
);
973 /* Add on all the variables stored in special slots. */
977 for (offset
= PER_BUFFER_VAR_OFFSET (name
);
978 offset
< sizeof (struct buffer
);
979 /* sizeof EMACS_INT == sizeof Lisp_Object */
980 offset
+= (sizeof (EMACS_INT
)))
982 idx
= PER_BUFFER_IDX (offset
);
983 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
984 && SYMBOLP (PER_BUFFER_SYMBOL (offset
)))
985 result
= Fcons (Fcons (PER_BUFFER_SYMBOL (offset
),
986 PER_BUFFER_VALUE (buf
, offset
)),
995 DEFUN ("buffer-modified-p", Fbuffer_modified_p
, Sbuffer_modified_p
,
997 doc
: /* Return t if BUFFER was modified since its file was last read or saved.
998 No argument or nil as argument means use current buffer as BUFFER. */)
1000 register Lisp_Object buffer
;
1002 register struct buffer
*buf
;
1004 buf
= current_buffer
;
1007 CHECK_BUFFER (buffer
);
1008 buf
= XBUFFER (buffer
);
1011 return BUF_SAVE_MODIFF (buf
) < BUF_MODIFF (buf
) ? Qt
: Qnil
;
1014 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p
, Sset_buffer_modified_p
,
1016 doc
: /* Mark current buffer as modified or unmodified according to FLAG.
1017 A non-nil FLAG means mark the buffer modified. */)
1019 register Lisp_Object flag
;
1021 register int already
;
1022 register Lisp_Object fn
;
1023 Lisp_Object buffer
, window
;
1025 #ifdef CLASH_DETECTION
1026 /* If buffer becoming modified, lock the file.
1027 If buffer becoming unmodified, unlock the file. */
1029 fn
= current_buffer
->file_truename
;
1030 /* Test buffer-file-name so that binding it to nil is effective. */
1031 if (!NILP (fn
) && ! NILP (current_buffer
->filename
))
1033 already
= SAVE_MODIFF
< MODIFF
;
1034 if (!already
&& !NILP (flag
))
1036 else if (already
&& NILP (flag
))
1039 #endif /* CLASH_DETECTION */
1041 SAVE_MODIFF
= NILP (flag
) ? MODIFF
: 0;
1043 /* Set update_mode_lines only if buffer is displayed in some window.
1044 Packages like jit-lock or lazy-lock preserve a buffer's modified
1045 state by recording/restoring the state around blocks of code.
1046 Setting update_mode_lines makes redisplay consider all windows
1047 (on all frames). Stealth fontification of buffers not displayed
1048 would incur additional redisplay costs if we'd set
1049 update_modes_lines unconditionally.
1051 Ideally, I think there should be another mechanism for fontifying
1052 buffers without "modifying" buffers, or redisplay should be
1053 smarter about updating the `*' in mode lines. --gerd */
1054 XSETBUFFER (buffer
, current_buffer
);
1055 window
= Fget_buffer_window (buffer
, Qt
);
1056 if (WINDOWP (window
))
1058 ++update_mode_lines
;
1059 current_buffer
->prevent_redisplay_optimizations_p
= 1;
1065 DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p
,
1066 Srestore_buffer_modified_p
, 1, 1, 0,
1067 doc
: /* Like `set-buffer-modified-p', with a differences concerning redisplay.
1068 It is not ensured that mode lines will be updated to show the modified
1069 state of the current buffer. Use with care. */)
1073 #ifdef CLASH_DETECTION
1076 /* If buffer becoming modified, lock the file.
1077 If buffer becoming unmodified, unlock the file. */
1079 fn
= current_buffer
->file_truename
;
1080 /* Test buffer-file-name so that binding it to nil is effective. */
1081 if (!NILP (fn
) && ! NILP (current_buffer
->filename
))
1083 int already
= SAVE_MODIFF
< MODIFF
;
1084 if (!already
&& !NILP (flag
))
1086 else if (already
&& NILP (flag
))
1089 #endif /* CLASH_DETECTION */
1091 SAVE_MODIFF
= NILP (flag
) ? MODIFF
: 0;
1095 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick
, Sbuffer_modified_tick
,
1097 doc
: /* Return BUFFER's tick counter, incremented for each change in text.
1098 Each buffer has a tick counter which is incremented each time the text in
1099 that buffer is changed. It wraps around occasionally.
1100 No argument or nil as argument means use current buffer as BUFFER. */)
1102 register Lisp_Object buffer
;
1104 register struct buffer
*buf
;
1106 buf
= current_buffer
;
1109 CHECK_BUFFER (buffer
);
1110 buf
= XBUFFER (buffer
);
1113 return make_number (BUF_MODIFF (buf
));
1116 DEFUN ("rename-buffer", Frename_buffer
, Srename_buffer
, 1, 2,
1117 "sRename buffer (to new name): \nP",
1118 doc
: /* Change current buffer's name to NEWNAME (a string).
1119 If second arg UNIQUE is nil or omitted, it is an error if a
1120 buffer named NEWNAME already exists.
1121 If UNIQUE is non-nil, come up with a new name using
1122 `generate-new-buffer-name'.
1123 Interactively, you can set UNIQUE with a prefix argument.
1124 We return the name we actually gave the buffer.
1125 This does not change the name of the visited file (if any). */)
1127 register Lisp_Object newname
, unique
;
1129 register Lisp_Object tem
, buf
;
1131 CHECK_STRING (newname
);
1133 if (SCHARS (newname
) == 0)
1134 error ("Empty string is invalid as a buffer name");
1136 tem
= Fget_buffer (newname
);
1139 /* Don't short-circuit if UNIQUE is t. That is a useful way to
1140 rename the buffer automatically so you can create another
1141 with the original name. It makes UNIQUE equivalent to
1142 (rename-buffer (generate-new-buffer-name NEWNAME)). */
1143 if (NILP (unique
) && XBUFFER (tem
) == current_buffer
)
1144 return current_buffer
->name
;
1146 newname
= Fgenerate_new_buffer_name (newname
, current_buffer
->name
);
1148 error ("Buffer name `%s' is in use", SDATA (newname
));
1151 current_buffer
->name
= newname
;
1153 /* Catch redisplay's attention. Unless we do this, the mode lines for
1154 any windows displaying current_buffer will stay unchanged. */
1155 update_mode_lines
++;
1157 XSETBUFFER (buf
, current_buffer
);
1158 Fsetcar (Frassq (buf
, Vbuffer_alist
), newname
);
1159 if (NILP (current_buffer
->filename
)
1160 && !NILP (current_buffer
->auto_save_file_name
))
1161 call0 (intern ("rename-auto-save-file"));
1162 /* Refetch since that last call may have done GC. */
1163 return current_buffer
->name
;
1166 DEFUN ("other-buffer", Fother_buffer
, Sother_buffer
, 0, 3, 0,
1167 doc
: /* Return most recently selected buffer other than BUFFER.
1168 Buffers not visible in windows are preferred to visible buffers,
1169 unless optional second argument VISIBLE-OK is non-nil.
1170 If the optional third argument FRAME is non-nil, use that frame's
1171 buffer list instead of the selected frame's buffer list.
1172 If no other buffer exists, the buffer `*scratch*' is returned.
1173 If BUFFER is omitted or nil, some interesting buffer is returned. */)
1174 (buffer
, visible_ok
, frame
)
1175 register Lisp_Object buffer
, visible_ok
, frame
;
1177 Lisp_Object
Fset_buffer_major_mode ();
1178 register Lisp_Object tail
, buf
, notsogood
, tem
, pred
, add_ons
;
1182 frame
= selected_frame
;
1184 tail
= Vbuffer_alist
;
1185 pred
= frame_buffer_predicate (frame
);
1187 /* Consider buffers that have been seen in the selected frame
1188 before other buffers. */
1190 tem
= frame_buffer_list (frame
);
1194 if (BUFFERP (XCAR (tem
)))
1195 add_ons
= Fcons (Fcons (Qnil
, XCAR (tem
)), add_ons
);
1198 tail
= nconc2 (Fnreverse (add_ons
), tail
);
1200 for (; CONSP (tail
); tail
= XCDR (tail
))
1202 buf
= Fcdr (XCAR (tail
));
1203 if (EQ (buf
, buffer
))
1207 if (NILP (XBUFFER (buf
)->name
))
1209 if (SREF (XBUFFER (buf
)->name
, 0) == ' ')
1211 /* If the selected frame has a buffer_predicate,
1212 disregard buffers that don't fit the predicate. */
1215 tem
= call1 (pred
, buf
);
1220 if (NILP (visible_ok
))
1221 tem
= Fget_buffer_window (buf
, Qvisible
);
1226 if (NILP (notsogood
))
1229 if (!NILP (notsogood
))
1231 buf
= Fget_buffer (build_string ("*scratch*"));
1234 buf
= Fget_buffer_create (build_string ("*scratch*"));
1235 Fset_buffer_major_mode (buf
);
1240 DEFUN ("buffer-disable-undo", Fbuffer_disable_undo
, Sbuffer_disable_undo
,
1242 doc
: /* Make BUFFER stop keeping undo information.
1243 No argument or nil as argument means do this for the current buffer. */)
1245 register Lisp_Object buffer
;
1247 Lisp_Object real_buffer
;
1250 XSETBUFFER (real_buffer
, current_buffer
);
1253 real_buffer
= Fget_buffer (buffer
);
1254 if (NILP (real_buffer
))
1258 XBUFFER (real_buffer
)->undo_list
= Qt
;
1263 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo
, Sbuffer_enable_undo
,
1265 doc
: /* Start keeping undo information for buffer BUFFER.
1266 No argument or nil as argument means do this for the current buffer. */)
1268 register Lisp_Object buffer
;
1270 Lisp_Object real_buffer
;
1273 XSETBUFFER (real_buffer
, current_buffer
);
1276 real_buffer
= Fget_buffer (buffer
);
1277 if (NILP (real_buffer
))
1281 if (EQ (XBUFFER (real_buffer
)->undo_list
, Qt
))
1282 XBUFFER (real_buffer
)->undo_list
= Qnil
;
1288 DEFVAR_LISP ("kill-buffer-hook", no_cell, "\
1289 Hook to be run (by `run-hooks', which see) when a buffer is killed.\n\
1290 The buffer being killed will be current while the hook is running.\n\
1293 DEFUN ("kill-buffer", Fkill_buffer
, Skill_buffer
, 1, 1, "bKill buffer: ",
1294 doc
: /* Kill the buffer BUFFER.
1295 The argument may be a buffer or may be the name of a buffer.
1296 An argument of nil means kill the current buffer.
1298 Value is t if the buffer is actually killed, nil if user says no.
1300 The value of `kill-buffer-hook' (which may be local to that buffer),
1301 if not void, is a list of functions to be called, with no arguments,
1302 before the buffer is actually killed. The buffer to be killed is current
1303 when the hook functions are called.
1305 Any processes that have this buffer as the `process-buffer' are killed
1311 register struct buffer
*b
;
1312 register Lisp_Object tem
;
1313 register struct Lisp_Marker
*m
;
1314 struct gcpro gcpro1
;
1317 buf
= Fcurrent_buffer ();
1319 buf
= Fget_buffer (buffer
);
1325 /* Avoid trouble for buffer already dead. */
1329 /* Query if the buffer is still modified. */
1330 if (INTERACTIVE
&& !NILP (b
->filename
)
1331 && BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
1334 tem
= do_yes_or_no_p (format2 ("Buffer %s modified; kill anyway? ",
1335 b
->name
, make_number (0)));
1341 /* Run hooks with the buffer to be killed the current buffer. */
1343 int count
= SPECPDL_INDEX ();
1344 Lisp_Object arglist
[1];
1346 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1347 set_buffer_internal (b
);
1349 /* First run the query functions; if any query is answered no,
1350 don't kill the buffer. */
1351 arglist
[0] = Qkill_buffer_query_functions
;
1352 if (NILP (Frun_hook_with_args_until_failure (1, arglist
)))
1353 return unbind_to (count
, Qnil
);
1355 /* Then run the hooks. */
1356 Frun_hooks (1, &Qkill_buffer_hook
);
1357 unbind_to (count
, Qnil
);
1360 /* We have no more questions to ask. Verify that it is valid
1361 to kill the buffer. This must be done after the questions
1362 since anything can happen within do_yes_or_no_p. */
1364 /* Don't kill the minibuffer now current. */
1365 if (EQ (buf
, XWINDOW (minibuf_window
)->buffer
))
1371 /* When we kill a base buffer, kill all its indirect buffers.
1372 We do it at this stage so nothing terrible happens if they
1373 ask questions or their hooks get errors. */
1374 if (! b
->base_buffer
)
1376 struct buffer
*other
;
1380 for (other
= all_buffers
; other
; other
= other
->next
)
1381 /* all_buffers contains dead buffers too;
1382 don't re-kill them. */
1383 if (other
->base_buffer
== b
&& !NILP (other
->name
))
1386 XSETBUFFER (buf
, other
);
1393 /* Make this buffer not be current.
1394 In the process, notice if this is the sole visible buffer
1395 and give up if so. */
1396 if (b
== current_buffer
)
1398 tem
= Fother_buffer (buf
, Qnil
, Qnil
);
1400 if (b
== current_buffer
)
1404 /* Notice if the buffer to kill is the sole visible buffer
1405 when we're currently in the mini-buffer, and give up if so. */
1406 XSETBUFFER (tem
, current_buffer
);
1407 if (EQ (tem
, XWINDOW (minibuf_window
)->buffer
))
1409 tem
= Fother_buffer (buf
, Qnil
, Qnil
);
1414 /* Now there is no question: we can kill the buffer. */
1416 #ifdef CLASH_DETECTION
1417 /* Unlock this buffer's file, if it is locked. */
1419 #endif /* CLASH_DETECTION */
1421 kill_buffer_processes (buf
);
1422 clear_charpos_cache (b
);
1424 tem
= Vinhibit_quit
;
1426 replace_buffer_in_all_windows (buf
);
1427 Vbuffer_alist
= Fdelq (Frassq (buf
, Vbuffer_alist
), Vbuffer_alist
);
1428 frames_discard_buffer (buf
);
1429 Vinhibit_quit
= tem
;
1431 /* Delete any auto-save file, if we saved it in this session.
1432 But not if the buffer is modified. */
1433 if (STRINGP (b
->auto_save_file_name
)
1434 && b
->auto_save_modified
!= 0
1435 && BUF_SAVE_MODIFF (b
) < b
->auto_save_modified
1436 && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
)
1437 && NILP (Fsymbol_value (intern ("auto-save-visited-file-name"))))
1440 tem
= Fsymbol_value (intern ("delete-auto-save-files"));
1442 internal_delete_file (b
->auto_save_file_name
);
1447 /* Unchain all markers that belong to this indirect buffer.
1448 Don't unchain the markers that belong to the base buffer
1449 or its other indirect buffers. */
1450 for (m
= BUF_MARKERS (b
); m
; )
1452 struct Lisp_Marker
*next
= m
->next
;
1460 /* Unchain all markers of this buffer and its indirect buffers.
1461 and leave them pointing nowhere. */
1462 for (m
= BUF_MARKERS (b
); m
; )
1464 struct Lisp_Marker
*next
= m
->next
;
1469 BUF_MARKERS (b
) = NULL
;
1470 BUF_INTERVALS (b
) = NULL_INTERVAL
;
1472 /* Perhaps we should explicitly free the interval tree here... */
1475 /* Reset the local variables, so that this buffer's local values
1476 won't be protected from GC. They would be protected
1477 if they happened to remain encached in their symbols.
1478 This gets rid of them for certain. */
1479 swap_out_buffer_local_variables (b
);
1480 reset_buffer_local_variables (b
, 1);
1485 if (! b
->base_buffer
)
1486 free_buffer_text (b
);
1488 if (b
->newline_cache
)
1490 free_region_cache (b
->newline_cache
);
1491 b
->newline_cache
= 0;
1493 if (b
->width_run_cache
)
1495 free_region_cache (b
->width_run_cache
);
1496 b
->width_run_cache
= 0;
1498 b
->width_table
= Qnil
;
1500 b
->undo_list
= Qnil
;
1505 /* Move the assoc for buffer BUF to the front of buffer-alist. Since
1506 we do this each time BUF is selected visibly, the more recently
1507 selected buffers are always closer to the front of the list. This
1508 means that other_buffer is more likely to choose a relevant buffer. */
1514 register Lisp_Object link
, prev
;
1516 frame
= selected_frame
;
1519 for (link
= Vbuffer_alist
; CONSP (link
); link
= XCDR (link
))
1521 if (EQ (XCDR (XCAR (link
)), buf
))
1526 /* Effectively do Vbuffer_alist = Fdelq (link, Vbuffer_alist);
1527 we cannot use Fdelq itself here because it allows quitting. */
1530 Vbuffer_alist
= XCDR (Vbuffer_alist
);
1532 XSETCDR (prev
, XCDR (XCDR (prev
)));
1534 XSETCDR (link
, Vbuffer_alist
);
1535 Vbuffer_alist
= link
;
1537 /* Now move this buffer to the front of frame_buffer_list also. */
1540 for (link
= frame_buffer_list (frame
); CONSP (link
);
1543 if (EQ (XCAR (link
), buf
))
1548 /* Effectively do delq. */
1553 set_frame_buffer_list (frame
,
1554 XCDR (frame_buffer_list (frame
)));
1556 XSETCDR (prev
, XCDR (XCDR (prev
)));
1558 XSETCDR (link
, frame_buffer_list (frame
));
1559 set_frame_buffer_list (frame
, link
);
1562 set_frame_buffer_list (frame
, Fcons (buf
, frame_buffer_list (frame
)));
1565 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode
, Sset_buffer_major_mode
, 1, 1, 0,
1566 doc
: /* Set an appropriate major mode for BUFFER.
1567 For the *scratch* buffer, use `initial-major-mode', otherwise choose a mode
1568 according to `default-major-mode'.
1569 Use this function before selecting the buffer, since it may need to inspect
1570 the current buffer's major mode. */)
1575 Lisp_Object function
;
1577 if (STRINGP (XBUFFER (buffer
)->name
)
1578 && strcmp (SDATA (XBUFFER (buffer
)->name
), "*scratch*") == 0)
1579 function
= find_symbol_value (intern ("initial-major-mode"));
1582 function
= buffer_defaults
.major_mode
;
1584 && NILP (Fget (current_buffer
->major_mode
, Qmode_class
)))
1585 function
= current_buffer
->major_mode
;
1588 if (NILP (function
) || EQ (function
, Qfundamental_mode
))
1591 count
= SPECPDL_INDEX ();
1593 /* To select a nonfundamental mode,
1594 select the buffer temporarily and then call the mode function. */
1596 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1598 Fset_buffer (buffer
);
1601 return unbind_to (count
, Qnil
);
1604 /* If switching buffers in WINDOW would be an error, return
1605 a C string saying what the error would be. */
1608 no_switch_window (window
)
1612 if (EQ (minibuf_window
, window
))
1613 return "Cannot switch buffers in minibuffer window";
1614 tem
= Fwindow_dedicated_p (window
);
1616 return "Cannot switch buffers in a dedicated window";
1620 /* Switch to buffer BUFFER in the selected window.
1621 If NORECORD is non-nil, don't call record_buffer. */
1624 switch_to_buffer_1 (buffer
, norecord
)
1625 Lisp_Object buffer
, norecord
;
1627 register Lisp_Object buf
;
1630 buf
= Fother_buffer (Fcurrent_buffer (), Qnil
, Qnil
);
1633 buf
= Fget_buffer (buffer
);
1636 buf
= Fget_buffer_create (buffer
);
1637 Fset_buffer_major_mode (buf
);
1641 if (NILP (norecord
))
1642 record_buffer (buf
);
1644 Fset_window_buffer (EQ (selected_window
, minibuf_window
)
1645 ? Fnext_window (minibuf_window
, Qnil
, Qnil
)
1652 DEFUN ("switch-to-buffer", Fswitch_to_buffer
, Sswitch_to_buffer
, 1, 2, "BSwitch to buffer: ",
1653 doc
: /* Select buffer BUFFER in the current window.
1654 BUFFER may be a buffer or a buffer name.
1655 Optional second arg NORECORD non-nil means
1656 do not put this buffer at the front of the list of recently selected ones.
1658 WARNING: This is NOT the way to work on another buffer temporarily
1659 within a Lisp program! Use `set-buffer' instead. That avoids messing with
1660 the window-buffer correspondences. */)
1662 Lisp_Object buffer
, norecord
;
1666 if (EQ (buffer
, Fwindow_buffer (selected_window
)))
1667 /* Basically a NOP. Avoid signalling an error if the selected window
1668 is dedicated, or a minibuffer, ... */
1669 return Fset_buffer (buffer
);
1671 err
= no_switch_window (selected_window
);
1672 if (err
) error (err
);
1674 return switch_to_buffer_1 (buffer
, norecord
);
1677 DEFUN ("pop-to-buffer", Fpop_to_buffer
, Spop_to_buffer
, 1, 3, 0,
1678 doc
: /* Select buffer BUFFER in some window, preferably a different one.
1679 If BUFFER is nil, then some other buffer is chosen.
1680 If `pop-up-windows' is non-nil, windows can be split to do this.
1681 If optional second arg OTHER-WINDOW is nil, insist on finding another
1682 window even if BUFFER is already visible in the selected window,
1683 and ignore `same-window-regexps' and `same-window-buffer-names'.
1684 This uses the function `display-buffer' as a subroutine; see the documentation
1685 of `display-buffer' for additional customization information.
1687 Optional third arg NORECORD non-nil means
1688 do not put this buffer at the front of the list of recently selected ones. */)
1689 (buffer
, other_window
, norecord
)
1690 Lisp_Object buffer
, other_window
, norecord
;
1692 register Lisp_Object buf
;
1694 buf
= Fother_buffer (Fcurrent_buffer (), Qnil
, Qnil
);
1697 buf
= Fget_buffer (buffer
);
1700 buf
= Fget_buffer_create (buffer
);
1701 Fset_buffer_major_mode (buf
);
1705 if (NILP (norecord
))
1706 /* Why bother ? Fselect_window will do it for us anyway. -stef */
1707 record_buffer (buf
);
1708 Fselect_window (Fdisplay_buffer (buf
, other_window
, Qnil
), norecord
);
1712 DEFUN ("current-buffer", Fcurrent_buffer
, Scurrent_buffer
, 0, 0, 0,
1713 doc
: /* Return the current buffer as a Lisp object. */)
1716 register Lisp_Object buf
;
1717 XSETBUFFER (buf
, current_buffer
);
1721 /* Set the current buffer to B.
1723 We previously set windows_or_buffers_changed here to invalidate
1724 global unchanged information in beg_unchanged and end_unchanged.
1725 This is no longer necessary because we now compute unchanged
1726 information on a buffer-basis. Every action affecting other
1727 windows than the selected one requires a select_window at some
1728 time, and that increments windows_or_buffers_changed. */
1731 set_buffer_internal (b
)
1732 register struct buffer
*b
;
1734 if (current_buffer
!= b
)
1735 set_buffer_internal_1 (b
);
1738 /* Set the current buffer to B, and do not set windows_or_buffers_changed.
1739 This is used by redisplay. */
1742 set_buffer_internal_1 (b
)
1743 register struct buffer
*b
;
1745 register struct buffer
*old_buf
;
1746 register Lisp_Object tail
, valcontents
;
1749 #ifdef USE_MMAP_FOR_BUFFERS
1750 if (b
->text
->beg
== NULL
)
1751 enlarge_buffer_text (b
, 0);
1752 #endif /* USE_MMAP_FOR_BUFFERS */
1754 if (current_buffer
== b
)
1757 old_buf
= current_buffer
;
1759 last_known_column_point
= -1; /* invalidate indentation cache */
1763 /* Put the undo list back in the base buffer, so that it appears
1764 that an indirect buffer shares the undo list of its base. */
1765 if (old_buf
->base_buffer
)
1766 old_buf
->base_buffer
->undo_list
= old_buf
->undo_list
;
1768 /* If the old current buffer has markers to record PT, BEGV and ZV
1769 when it is not current, update them now. */
1770 if (! NILP (old_buf
->pt_marker
))
1773 XSETBUFFER (obuf
, old_buf
);
1774 set_marker_both (old_buf
->pt_marker
, obuf
,
1775 BUF_PT (old_buf
), BUF_PT_BYTE (old_buf
));
1777 if (! NILP (old_buf
->begv_marker
))
1780 XSETBUFFER (obuf
, old_buf
);
1781 set_marker_both (old_buf
->begv_marker
, obuf
,
1782 BUF_BEGV (old_buf
), BUF_BEGV_BYTE (old_buf
));
1784 if (! NILP (old_buf
->zv_marker
))
1787 XSETBUFFER (obuf
, old_buf
);
1788 set_marker_both (old_buf
->zv_marker
, obuf
,
1789 BUF_ZV (old_buf
), BUF_ZV_BYTE (old_buf
));
1793 /* Get the undo list from the base buffer, so that it appears
1794 that an indirect buffer shares the undo list of its base. */
1796 b
->undo_list
= b
->base_buffer
->undo_list
;
1798 /* If the new current buffer has markers to record PT, BEGV and ZV
1799 when it is not current, fetch them now. */
1800 if (! NILP (b
->pt_marker
))
1802 BUF_PT (b
) = marker_position (b
->pt_marker
);
1803 BUF_PT_BYTE (b
) = marker_byte_position (b
->pt_marker
);
1805 if (! NILP (b
->begv_marker
))
1807 BUF_BEGV (b
) = marker_position (b
->begv_marker
);
1808 BUF_BEGV_BYTE (b
) = marker_byte_position (b
->begv_marker
);
1810 if (! NILP (b
->zv_marker
))
1812 BUF_ZV (b
) = marker_position (b
->zv_marker
);
1813 BUF_ZV_BYTE (b
) = marker_byte_position (b
->zv_marker
);
1816 /* Look down buffer's list of local Lisp variables
1817 to find and update any that forward into C variables. */
1819 for (tail
= b
->local_var_alist
; CONSP (tail
); tail
= XCDR (tail
))
1821 valcontents
= SYMBOL_VALUE (XCAR (XCAR (tail
)));
1822 if ((BUFFER_LOCAL_VALUEP (valcontents
)
1823 || SOME_BUFFER_LOCAL_VALUEP (valcontents
))
1824 && (tem
= XBUFFER_LOCAL_VALUE (valcontents
)->realvalue
,
1825 (BOOLFWDP (tem
) || INTFWDP (tem
) || OBJFWDP (tem
))))
1826 /* Just reference the variable
1827 to cause it to become set for this buffer. */
1828 Fsymbol_value (XCAR (XCAR (tail
)));
1831 /* Do the same with any others that were local to the previous buffer */
1834 for (tail
= old_buf
->local_var_alist
; CONSP (tail
); tail
= XCDR (tail
))
1836 valcontents
= SYMBOL_VALUE (XCAR (XCAR (tail
)));
1837 if ((BUFFER_LOCAL_VALUEP (valcontents
)
1838 || SOME_BUFFER_LOCAL_VALUEP (valcontents
))
1839 && (tem
= XBUFFER_LOCAL_VALUE (valcontents
)->realvalue
,
1840 (BOOLFWDP (tem
) || INTFWDP (tem
) || OBJFWDP (tem
))))
1841 /* Just reference the variable
1842 to cause it to become set for this buffer. */
1843 Fsymbol_value (XCAR (XCAR (tail
)));
1847 /* Switch to buffer B temporarily for redisplay purposes.
1848 This avoids certain things that don't need to be done within redisplay. */
1854 register struct buffer
*old_buf
;
1856 if (current_buffer
== b
)
1859 old_buf
= current_buffer
;
1864 /* If the old current buffer has markers to record PT, BEGV and ZV
1865 when it is not current, update them now. */
1866 if (! NILP (old_buf
->pt_marker
))
1869 XSETBUFFER (obuf
, old_buf
);
1870 set_marker_both (old_buf
->pt_marker
, obuf
,
1871 BUF_PT (old_buf
), BUF_PT_BYTE (old_buf
));
1873 if (! NILP (old_buf
->begv_marker
))
1876 XSETBUFFER (obuf
, old_buf
);
1877 set_marker_both (old_buf
->begv_marker
, obuf
,
1878 BUF_BEGV (old_buf
), BUF_BEGV_BYTE (old_buf
));
1880 if (! NILP (old_buf
->zv_marker
))
1883 XSETBUFFER (obuf
, old_buf
);
1884 set_marker_both (old_buf
->zv_marker
, obuf
,
1885 BUF_ZV (old_buf
), BUF_ZV_BYTE (old_buf
));
1889 /* If the new current buffer has markers to record PT, BEGV and ZV
1890 when it is not current, fetch them now. */
1891 if (! NILP (b
->pt_marker
))
1893 BUF_PT (b
) = marker_position (b
->pt_marker
);
1894 BUF_PT_BYTE (b
) = marker_byte_position (b
->pt_marker
);
1896 if (! NILP (b
->begv_marker
))
1898 BUF_BEGV (b
) = marker_position (b
->begv_marker
);
1899 BUF_BEGV_BYTE (b
) = marker_byte_position (b
->begv_marker
);
1901 if (! NILP (b
->zv_marker
))
1903 BUF_ZV (b
) = marker_position (b
->zv_marker
);
1904 BUF_ZV_BYTE (b
) = marker_byte_position (b
->zv_marker
);
1908 DEFUN ("set-buffer", Fset_buffer
, Sset_buffer
, 1, 1, 0,
1909 doc
: /* Make the buffer BUFFER current for editing operations.
1910 BUFFER may be a buffer or the name of an existing buffer.
1911 See also `save-excursion' when you want to make a buffer current temporarily.
1912 This function does not display the buffer, so its effect ends
1913 when the current command terminates.
1914 Use `switch-to-buffer' or `pop-to-buffer' to switch buffers permanently. */)
1916 register Lisp_Object buffer
;
1918 register Lisp_Object buf
;
1919 buf
= Fget_buffer (buffer
);
1922 if (NILP (XBUFFER (buf
)->name
))
1923 error ("Selecting deleted buffer");
1924 set_buffer_internal (XBUFFER (buf
));
1928 /* Set the current buffer to BUFFER provided it is alive. */
1931 set_buffer_if_live (buffer
)
1934 if (! NILP (XBUFFER (buffer
)->name
))
1935 Fset_buffer (buffer
);
1939 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only
,
1940 Sbarf_if_buffer_read_only
, 0, 0, 0,
1941 doc
: /* Signal a `buffer-read-only' error if the current buffer is read-only. */)
1944 if (!NILP (current_buffer
->read_only
)
1945 && NILP (Vinhibit_read_only
))
1946 Fsignal (Qbuffer_read_only
, (Fcons (Fcurrent_buffer (), Qnil
)));
1950 DEFUN ("bury-buffer", Fbury_buffer
, Sbury_buffer
, 0, 1, "",
1951 doc
: /* Put BUFFER at the end of the list of all buffers.
1952 There it is the least likely candidate for `other-buffer' to return;
1953 thus, the least likely buffer for \\[switch-to-buffer] to select by default.
1954 If BUFFER is nil or omitted, bury the current buffer.
1955 Also, if BUFFER is nil or omitted, remove the current buffer from the
1956 selected window if it is displayed there. */)
1958 register Lisp_Object buffer
;
1960 /* Figure out what buffer we're going to bury. */
1964 XSETBUFFER (buffer
, current_buffer
);
1966 tem
= Fwindow_buffer (selected_window
);
1967 /* If we're burying the current buffer, unshow it. */
1968 if (EQ (buffer
, tem
))
1970 if (NILP (Fwindow_dedicated_p (selected_window
)))
1971 Fswitch_to_buffer (Fother_buffer (buffer
, Qnil
, Qnil
), Qnil
);
1972 else if (NILP (XWINDOW (selected_window
)->parent
))
1973 Ficonify_frame (Fwindow_frame (selected_window
));
1975 Fdelete_window (selected_window
);
1982 buf1
= Fget_buffer (buffer
);
1988 /* Move buffer to the end of the buffer list. Do nothing if the
1989 buffer is killed. */
1990 if (!NILP (XBUFFER (buffer
)->name
))
1992 Lisp_Object aelt
, link
;
1994 aelt
= Frassq (buffer
, Vbuffer_alist
);
1995 link
= Fmemq (aelt
, Vbuffer_alist
);
1996 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
1997 XSETCDR (link
, Qnil
);
1998 Vbuffer_alist
= nconc2 (Vbuffer_alist
, link
);
2000 /* Removing BUFFER from frame-specific lists
2001 has the effect of putting BUFFER at the end
2002 of the combined list in each frame. */
2003 frames_discard_buffer (buffer
);
2009 DEFUN ("erase-buffer", Ferase_buffer
, Serase_buffer
, 0, 0, "*",
2010 doc
: /* Delete the entire contents of the current buffer.
2011 Any narrowing restriction in effect (see `narrow-to-region') is removed,
2012 so the buffer is truly empty after this. */)
2019 current_buffer
->last_window_start
= 1;
2020 /* Prevent warnings, or suspension of auto saving, that would happen
2021 if future size is less than past size. Use of erase-buffer
2022 implies that the future text is not really related to the past text. */
2023 XSETFASTINT (current_buffer
->save_length
, 0);
2028 validate_region (b
, e
)
2029 register Lisp_Object
*b
, *e
;
2031 CHECK_NUMBER_COERCE_MARKER (*b
);
2032 CHECK_NUMBER_COERCE_MARKER (*e
);
2034 if (XINT (*b
) > XINT (*e
))
2037 tem
= *b
; *b
= *e
; *e
= tem
;
2040 if (!(BEGV
<= XINT (*b
) && XINT (*b
) <= XINT (*e
)
2041 && XINT (*e
) <= ZV
))
2042 args_out_of_range (*b
, *e
);
2045 /* Advance BYTE_POS up to a character boundary
2046 and return the adjusted position. */
2049 advance_to_char_boundary (byte_pos
)
2054 if (byte_pos
== BEG
)
2055 /* Beginning of buffer is always a character boundary. */
2058 c
= FETCH_BYTE (byte_pos
);
2059 if (! CHAR_HEAD_P (c
))
2061 /* We should advance BYTE_POS only when C is a constituent of a
2062 multibyte sequence. */
2063 int orig_byte_pos
= byte_pos
;
2068 c
= FETCH_BYTE (byte_pos
);
2070 while (! CHAR_HEAD_P (c
) && byte_pos
> BEG
);
2072 if (byte_pos
< orig_byte_pos
)
2073 byte_pos
= orig_byte_pos
;
2074 /* If C is a constituent of a multibyte sequence, BYTE_POS was
2075 surely advance to the correct character boundary. If C is
2076 not, BYTE_POS was unchanged. */
2082 DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte
, Sset_buffer_multibyte
,
2084 doc
: /* Set the multibyte flag of the current buffer to FLAG.
2085 If FLAG is t, this makes the buffer a multibyte buffer.
2086 If FLAG is nil, this makes the buffer a single-byte buffer.
2087 The buffer contents remain unchanged as a sequence of bytes
2088 but the contents viewed as characters do change.
2089 If the multibyte flag was really changed, undo information of the
2090 current buffer is cleared. */)
2094 struct Lisp_Marker
*tail
, *markers
;
2095 struct buffer
*other
;
2096 int undo_enabled_p
= !EQ (current_buffer
->undo_list
, Qt
);
2098 int narrowed
= (BEG
!= BEGV
|| Z
!= ZV
);
2099 int modified_p
= !NILP (Fbuffer_modified_p (Qnil
));
2101 if (current_buffer
->base_buffer
)
2102 error ("Cannot do `set-buffer-multibyte' on an indirect buffer");
2104 /* Do nothing if nothing actually changes. */
2105 if (NILP (flag
) == NILP (current_buffer
->enable_multibyte_characters
))
2108 /* It would be better to update the list,
2109 but this is good enough for now. */
2111 current_buffer
->undo_list
= Qt
;
2113 /* If the cached position is for this buffer, clear it out. */
2114 clear_charpos_cache (current_buffer
);
2117 begv
= BEGV_BYTE
, zv
= ZV_BYTE
;
2119 begv
= BEGV
, zv
= ZV
;
2129 /* Do this first, so it can use CHAR_TO_BYTE
2130 to calculate the old correspondences. */
2131 set_intervals_multibyte (0);
2133 current_buffer
->enable_multibyte_characters
= Qnil
;
2139 TEMP_SET_PT_BOTH (PT_BYTE
, PT_BYTE
);
2142 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
2143 tail
->charpos
= tail
->bytepos
;
2145 /* Convert multibyte form of 8-bit characters to unibyte. */
2160 if (MULTIBYTE_STR_AS_UNIBYTE_P (p
, bytes
))
2161 p
+= bytes
, pos
+= bytes
;
2164 c
= STRING_CHAR (p
, stop
- pos
);
2165 /* Delete all bytes for this 8-bit character but the
2166 last one, and change the last one to the charcter
2169 del_range_2 (pos
, pos
, pos
+ bytes
, pos
+ bytes
, 0);
2181 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2189 /* Be sure not to have a multibyte sequence striding over the GAP.
2190 Ex: We change this: "...abc\201 _GAP_ \241def..."
2191 to: "...abc _GAP_ \201\241def..." */
2193 if (GPT_BYTE
> 1 && GPT_BYTE
< Z_BYTE
2194 && ! CHAR_HEAD_P (*(GAP_END_ADDR
)))
2196 unsigned char *p
= GPT_ADDR
- 1;
2198 while (! CHAR_HEAD_P (*p
) && p
> BEG_ADDR
) p
--;
2199 if (BASE_LEADING_CODE_P (*p
))
2201 int new_gpt
= GPT_BYTE
- (GPT_ADDR
- p
);
2203 move_gap_both (new_gpt
, new_gpt
);
2207 /* Make the buffer contents valid as multibyte by converting
2208 8-bit characters to multibyte form. */
2224 if (UNIBYTE_STR_AS_MULTIBYTE_P (p
, stop
- pos
, bytes
))
2225 p
+= bytes
, pos
+= bytes
;
2228 unsigned char tmp
[MAX_MULTIBYTE_LENGTH
];
2230 bytes
= CHAR_STRING (*p
, tmp
);
2232 TEMP_SET_PT_BOTH (pos
+ 1, pos
+ 1);
2234 insert_1_both (tmp
+ 1, bytes
, bytes
, 1, 0, 0);
2235 /* Now the gap is after the just inserted data. */
2252 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2254 /* Do this first, so that chars_in_text asks the right question.
2255 set_intervals_multibyte needs it too. */
2256 current_buffer
->enable_multibyte_characters
= Qt
;
2258 GPT_BYTE
= advance_to_char_boundary (GPT_BYTE
);
2259 GPT
= chars_in_text (BEG_ADDR
, GPT_BYTE
- BEG_BYTE
) + BEG
;
2261 Z
= chars_in_text (GAP_END_ADDR
, Z_BYTE
- GPT_BYTE
) + GPT
;
2263 BEGV_BYTE
= advance_to_char_boundary (BEGV_BYTE
);
2264 if (BEGV_BYTE
> GPT_BYTE
)
2265 BEGV
= chars_in_text (GAP_END_ADDR
, BEGV_BYTE
- GPT_BYTE
) + GPT
;
2267 BEGV
= chars_in_text (BEG_ADDR
, BEGV_BYTE
- BEG_BYTE
) + BEG
;
2269 ZV_BYTE
= advance_to_char_boundary (ZV_BYTE
);
2270 if (ZV_BYTE
> GPT_BYTE
)
2271 ZV
= chars_in_text (GAP_END_ADDR
, ZV_BYTE
- GPT_BYTE
) + GPT
;
2273 ZV
= chars_in_text (BEG_ADDR
, ZV_BYTE
- BEG_BYTE
) + BEG
;
2276 int pt_byte
= advance_to_char_boundary (PT_BYTE
);
2279 if (pt_byte
> GPT_BYTE
)
2280 pt
= chars_in_text (GAP_END_ADDR
, pt_byte
- GPT_BYTE
) + GPT
;
2282 pt
= chars_in_text (BEG_ADDR
, pt_byte
- BEG_BYTE
) + BEG
;
2283 TEMP_SET_PT_BOTH (pt
, pt_byte
);
2286 tail
= markers
= BUF_MARKERS (current_buffer
);
2288 /* This prevents BYTE_TO_CHAR (that is, buf_bytepos_to_charpos) from
2289 getting confused by the markers that have not yet been updated.
2290 It is also a signal that it should never create a marker. */
2291 BUF_MARKERS (current_buffer
) = NULL
;
2293 for (; tail
; tail
= tail
->next
)
2295 tail
->bytepos
= advance_to_char_boundary (tail
->bytepos
);
2296 tail
->charpos
= BYTE_TO_CHAR (tail
->bytepos
);
2299 /* Make sure no markers were put on the chain
2300 while the chain value was incorrect. */
2301 if (BUF_MARKERS (current_buffer
))
2304 BUF_MARKERS (current_buffer
) = markers
;
2306 /* Do this last, so it can calculate the new correspondences
2307 between chars and bytes. */
2308 set_intervals_multibyte (1);
2312 current_buffer
->undo_list
= Qnil
;
2314 /* Changing the multibyteness of a buffer means that all windows
2315 showing that buffer must be updated thoroughly. */
2316 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2317 ++windows_or_buffers_changed
;
2319 /* Copy this buffer's new multibyte status
2320 into all of its indirect buffers. */
2321 for (other
= all_buffers
; other
; other
= other
->next
)
2322 if (other
->base_buffer
== current_buffer
&& !NILP (other
->name
))
2324 other
->enable_multibyte_characters
2325 = current_buffer
->enable_multibyte_characters
;
2326 other
->prevent_redisplay_optimizations_p
= 1;
2329 /* Restore the modifiedness of the buffer. */
2330 if (!modified_p
&& !NILP (Fbuffer_modified_p (Qnil
)))
2331 Fset_buffer_modified_p (Qnil
);
2334 /* Update coding systems of this buffer's process (if any). */
2336 Lisp_Object process
;
2338 process
= Fget_buffer_process (Fcurrent_buffer ());
2339 if (PROCESSP (process
))
2340 setup_process_coding_systems (process
);
2342 #endif /* subprocesses */
2347 DEFUN ("kill-all-local-variables", Fkill_all_local_variables
, Skill_all_local_variables
,
2349 doc
: /* Switch to Fundamental mode by killing current buffer's local variables.
2350 Most local variable bindings are eliminated so that the default values
2351 become effective once more. Also, the syntax table is set from
2352 `standard-syntax-table', the local keymap is set to nil,
2353 and the abbrev table from `fundamental-mode-abbrev-table'.
2354 This function also forces redisplay of the mode line.
2356 Every function to select a new major mode starts by
2357 calling this function.
2359 As a special exception, local variables whose names have
2360 a non-nil `permanent-local' property are not eliminated by this function.
2362 The first thing this function does is run
2363 the normal hook `change-major-mode-hook'. */)
2366 register Lisp_Object alist
, sym
, tem
;
2369 if (!NILP (Vrun_hooks
))
2370 call1 (Vrun_hooks
, intern ("change-major-mode-hook"));
2371 oalist
= current_buffer
->local_var_alist
;
2373 /* Make sure none of the bindings in oalist
2374 remain swapped in, in their symbols. */
2376 swap_out_buffer_local_variables (current_buffer
);
2378 /* Actually eliminate all local bindings of this buffer. */
2380 reset_buffer_local_variables (current_buffer
, 0);
2382 /* Any which are supposed to be permanent,
2383 make local again, with the same values they had. */
2385 for (alist
= oalist
; !NILP (alist
); alist
= XCDR (alist
))
2387 sym
= XCAR (XCAR (alist
));
2388 tem
= Fget (sym
, Qpermanent_local
);
2391 Fmake_local_variable (sym
);
2392 Fset (sym
, XCDR (XCAR (alist
)));
2396 /* Force mode-line redisplay. Useful here because all major mode
2397 commands call this function. */
2398 update_mode_lines
++;
2403 /* Make sure no local variables remain set up with buffer B
2404 for their current values. */
2407 swap_out_buffer_local_variables (b
)
2410 Lisp_Object oalist
, alist
, sym
, tem
, buffer
;
2412 XSETBUFFER (buffer
, b
);
2413 oalist
= b
->local_var_alist
;
2415 for (alist
= oalist
; !NILP (alist
); alist
= XCDR (alist
))
2417 sym
= XCAR (XCAR (alist
));
2419 /* Need not do anything if some other buffer's binding is now encached. */
2420 tem
= XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->buffer
;
2421 if (BUFFERP (tem
) && XBUFFER (tem
) == current_buffer
)
2423 /* Symbol is set up for this buffer's old local value.
2424 Set it up for the current buffer with the default value. */
2426 tem
= XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->cdr
;
2427 /* Store the symbol's current value into the alist entry
2428 it is currently set up for. This is so that, if the
2429 local is marked permanent, and we make it local again
2430 later in Fkill_all_local_variables, we don't lose the value. */
2431 XSETCDR (XCAR (tem
),
2432 do_symval_forwarding (XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->realvalue
));
2433 /* Switch to the symbol's default-value alist entry. */
2435 /* Mark it as current for buffer B. */
2436 XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->buffer
= buffer
;
2437 /* Store the current value into any forwarding in the symbol. */
2438 store_symval_forwarding (sym
,
2439 XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->realvalue
,
2445 /* Find all the overlays in the current buffer that contain position POS.
2446 Return the number found, and store them in a vector in *VEC_PTR.
2447 Store in *LEN_PTR the size allocated for the vector.
2448 Store in *NEXT_PTR the next position after POS where an overlay starts,
2449 or ZV if there are no more overlays.
2450 Store in *PREV_PTR the previous position before POS where an overlay ends,
2451 or where an overlay starts which ends at or after POS;
2452 or BEGV if there are no such overlays.
2453 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2455 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2456 when this function is called.
2458 If EXTEND is non-zero, we make the vector bigger if necessary.
2459 If EXTEND is zero, we never extend the vector,
2460 and we store only as many overlays as will fit.
2461 But we still return the total number of overlays.
2463 If CHANGE_REQ is true, then any position written into *PREV_PTR or
2464 *NEXT_PTR is guaranteed to be not equal to POS, unless it is the
2465 default (BEGV or ZV). */
2468 overlays_at (pos
, extend
, vec_ptr
, len_ptr
, next_ptr
, prev_ptr
, change_req
)
2471 Lisp_Object
**vec_ptr
;
2477 Lisp_Object overlay
, start
, end
;
2478 struct Lisp_Overlay
*tail
;
2481 Lisp_Object
*vec
= *vec_ptr
;
2484 int inhibit_storing
= 0;
2486 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2488 int startpos
, endpos
;
2490 XSETMISC (overlay
, tail
);
2492 start
= OVERLAY_START (overlay
);
2493 end
= OVERLAY_END (overlay
);
2494 endpos
= OVERLAY_POSITION (end
);
2501 startpos
= OVERLAY_POSITION (start
);
2502 /* This one ends at or after POS
2503 so its start counts for PREV_PTR if it's before POS. */
2504 if (prev
< startpos
&& startpos
< pos
)
2508 if (startpos
<= pos
)
2512 /* The supplied vector is full.
2513 Either make it bigger, or don't store any more in it. */
2516 /* Make it work with an initial len == 0. */
2521 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2525 inhibit_storing
= 1;
2528 if (!inhibit_storing
)
2530 /* Keep counting overlays even if we can't return them all. */
2533 else if (startpos
< next
)
2537 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2539 int startpos
, endpos
;
2541 XSETMISC (overlay
, tail
);
2543 start
= OVERLAY_START (overlay
);
2544 end
= OVERLAY_END (overlay
);
2545 startpos
= OVERLAY_POSITION (start
);
2548 if (startpos
< next
)
2552 endpos
= OVERLAY_POSITION (end
);
2559 /* Make it work with an initial len == 0. */
2564 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2568 inhibit_storing
= 1;
2571 if (!inhibit_storing
)
2575 if (startpos
< pos
&& startpos
> prev
)
2578 else if (endpos
< pos
&& endpos
> prev
)
2580 else if (endpos
== pos
&& startpos
> prev
2581 && (!change_req
|| startpos
< pos
))
2592 /* Find all the overlays in the current buffer that overlap the range BEG-END
2593 or are empty at BEG.
2595 Return the number found, and store them in a vector in *VEC_PTR.
2596 Store in *LEN_PTR the size allocated for the vector.
2597 Store in *NEXT_PTR the next position after POS where an overlay starts,
2598 or ZV if there are no more overlays.
2599 Store in *PREV_PTR the previous position before POS where an overlay ends,
2600 or BEGV if there are no previous overlays.
2601 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2603 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2604 when this function is called.
2606 If EXTEND is non-zero, we make the vector bigger if necessary.
2607 If EXTEND is zero, we never extend the vector,
2608 and we store only as many overlays as will fit.
2609 But we still return the total number of overlays. */
2612 overlays_in (beg
, end
, extend
, vec_ptr
, len_ptr
, next_ptr
, prev_ptr
)
2615 Lisp_Object
**vec_ptr
;
2620 Lisp_Object overlay
, ostart
, oend
;
2621 struct Lisp_Overlay
*tail
;
2624 Lisp_Object
*vec
= *vec_ptr
;
2627 int inhibit_storing
= 0;
2629 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2631 int startpos
, endpos
;
2633 XSETMISC (overlay
, tail
);
2635 ostart
= OVERLAY_START (overlay
);
2636 oend
= OVERLAY_END (overlay
);
2637 endpos
= OVERLAY_POSITION (oend
);
2644 startpos
= OVERLAY_POSITION (ostart
);
2645 /* Count an interval if it either overlaps the range
2646 or is empty at the start of the range. */
2647 if ((beg
< endpos
&& startpos
< end
)
2648 || (startpos
== endpos
&& beg
== endpos
))
2652 /* The supplied vector is full.
2653 Either make it bigger, or don't store any more in it. */
2656 /* Make it work with an initial len == 0. */
2661 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2665 inhibit_storing
= 1;
2668 if (!inhibit_storing
)
2670 /* Keep counting overlays even if we can't return them all. */
2673 else if (startpos
< next
)
2677 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2679 int startpos
, endpos
;
2681 XSETMISC (overlay
, tail
);
2683 ostart
= OVERLAY_START (overlay
);
2684 oend
= OVERLAY_END (overlay
);
2685 startpos
= OVERLAY_POSITION (ostart
);
2688 if (startpos
< next
)
2692 endpos
= OVERLAY_POSITION (oend
);
2693 /* Count an interval if it either overlaps the range
2694 or is empty at the start of the range. */
2695 if ((beg
< endpos
&& startpos
< end
)
2696 || (startpos
== endpos
&& beg
== endpos
))
2702 /* Make it work with an initial len == 0. */
2707 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2711 inhibit_storing
= 1;
2714 if (!inhibit_storing
)
2718 else if (endpos
< beg
&& endpos
> prev
)
2730 /* Return non-zero if there exists an overlay with a non-nil
2731 `mouse-face' property overlapping OVERLAY. */
2734 mouse_face_overlay_overlaps (overlay
)
2735 Lisp_Object overlay
;
2737 int start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2738 int end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2740 Lisp_Object
*v
, tem
;
2743 v
= (Lisp_Object
*) alloca (size
* sizeof *v
);
2744 n
= overlays_in (start
, end
, 0, &v
, &size
, NULL
, NULL
);
2747 v
= (Lisp_Object
*) alloca (n
* sizeof *v
);
2748 overlays_in (start
, end
, 0, &v
, &n
, NULL
, NULL
);
2751 for (i
= 0; i
< n
; ++i
)
2752 if (!EQ (v
[i
], overlay
)
2753 && (tem
= Foverlay_get (overlay
, Qmouse_face
),
2762 /* Fast function to just test if we're at an overlay boundary. */
2764 overlay_touches_p (pos
)
2767 Lisp_Object overlay
;
2768 struct Lisp_Overlay
*tail
;
2770 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2774 XSETMISC (overlay
,tail
);
2775 if (!GC_OVERLAYP (overlay
))
2778 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2781 if (endpos
== pos
|| OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
)
2785 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2789 XSETMISC (overlay
, tail
);
2790 if (!GC_OVERLAYP (overlay
))
2793 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2796 if (startpos
== pos
|| OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
)
2804 Lisp_Object overlay
;
2810 compare_overlays (v1
, v2
)
2811 const void *v1
, *v2
;
2813 const struct sortvec
*s1
= (const struct sortvec
*) v1
;
2814 const struct sortvec
*s2
= (const struct sortvec
*) v2
;
2815 if (s1
->priority
!= s2
->priority
)
2816 return s1
->priority
- s2
->priority
;
2817 if (s1
->beg
!= s2
->beg
)
2818 return s1
->beg
- s2
->beg
;
2819 if (s1
->end
!= s2
->end
)
2820 return s2
->end
- s1
->end
;
2824 /* Sort an array of overlays by priority. The array is modified in place.
2825 The return value is the new size; this may be smaller than the original
2826 size if some of the overlays were invalid or were window-specific. */
2828 sort_overlays (overlay_vec
, noverlays
, w
)
2829 Lisp_Object
*overlay_vec
;
2834 struct sortvec
*sortvec
;
2835 sortvec
= (struct sortvec
*) alloca (noverlays
* sizeof (struct sortvec
));
2837 /* Put the valid and relevant overlays into sortvec. */
2839 for (i
= 0, j
= 0; i
< noverlays
; i
++)
2842 Lisp_Object overlay
;
2844 overlay
= overlay_vec
[i
];
2845 if (OVERLAY_VALID (overlay
)
2846 && OVERLAY_POSITION (OVERLAY_START (overlay
)) > 0
2847 && OVERLAY_POSITION (OVERLAY_END (overlay
)) > 0)
2849 /* If we're interested in a specific window, then ignore
2850 overlays that are limited to some other window. */
2855 window
= Foverlay_get (overlay
, Qwindow
);
2856 if (WINDOWP (window
) && XWINDOW (window
) != w
)
2860 /* This overlay is good and counts: put it into sortvec. */
2861 sortvec
[j
].overlay
= overlay
;
2862 sortvec
[j
].beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2863 sortvec
[j
].end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2864 tem
= Foverlay_get (overlay
, Qpriority
);
2866 sortvec
[j
].priority
= XINT (tem
);
2868 sortvec
[j
].priority
= 0;
2874 /* Sort the overlays into the proper order: increasing priority. */
2877 qsort (sortvec
, noverlays
, sizeof (struct sortvec
), compare_overlays
);
2879 for (i
= 0; i
< noverlays
; i
++)
2880 overlay_vec
[i
] = sortvec
[i
].overlay
;
2886 Lisp_Object string
, string2
;
2893 struct sortstr
*buf
; /* An array that expands as needed; never freed. */
2894 int size
; /* Allocated length of that array. */
2895 int used
; /* How much of the array is currently in use. */
2896 int bytes
; /* Total length of the strings in buf. */
2899 /* Buffers for storing information about the overlays touching a given
2900 position. These could be automatic variables in overlay_strings, but
2901 it's more efficient to hold onto the memory instead of repeatedly
2902 allocating and freeing it. */
2903 static struct sortstrlist overlay_heads
, overlay_tails
;
2904 static unsigned char *overlay_str_buf
;
2906 /* Allocated length of overlay_str_buf. */
2907 static int overlay_str_len
;
2909 /* A comparison function suitable for passing to qsort. */
2911 cmp_for_strings (as1
, as2
)
2914 struct sortstr
*s1
= (struct sortstr
*)as1
;
2915 struct sortstr
*s2
= (struct sortstr
*)as2
;
2916 if (s1
->size
!= s2
->size
)
2917 return s2
->size
- s1
->size
;
2918 if (s1
->priority
!= s2
->priority
)
2919 return s1
->priority
- s2
->priority
;
2924 record_overlay_string (ssl
, str
, str2
, pri
, size
)
2925 struct sortstrlist
*ssl
;
2926 Lisp_Object str
, str2
, pri
;
2931 if (ssl
->used
== ssl
->size
)
2937 ssl
->buf
= ((struct sortstr
*)
2938 xrealloc (ssl
->buf
, ssl
->size
* sizeof (struct sortstr
)));
2940 ssl
->buf
[ssl
->used
].string
= str
;
2941 ssl
->buf
[ssl
->used
].string2
= str2
;
2942 ssl
->buf
[ssl
->used
].size
= size
;
2943 ssl
->buf
[ssl
->used
].priority
= (INTEGERP (pri
) ? XINT (pri
) : 0);
2946 if (NILP (current_buffer
->enable_multibyte_characters
))
2947 nbytes
= SCHARS (str
);
2948 else if (! STRING_MULTIBYTE (str
))
2949 nbytes
= count_size_as_multibyte (SDATA (str
),
2952 nbytes
= SBYTES (str
);
2954 ssl
->bytes
+= nbytes
;
2958 if (NILP (current_buffer
->enable_multibyte_characters
))
2959 nbytes
= SCHARS (str2
);
2960 else if (! STRING_MULTIBYTE (str2
))
2961 nbytes
= count_size_as_multibyte (SDATA (str2
),
2964 nbytes
= SBYTES (str2
);
2966 ssl
->bytes
+= nbytes
;
2970 /* Return the concatenation of the strings associated with overlays that
2971 begin or end at POS, ignoring overlays that are specific to a window
2972 other than W. The strings are concatenated in the appropriate order:
2973 shorter overlays nest inside longer ones, and higher priority inside
2974 lower. Normally all of the after-strings come first, but zero-sized
2975 overlays have their after-strings ride along with the before-strings
2976 because it would look strange to print them inside-out.
2978 Returns the string length, and stores the contents indirectly through
2979 PSTR, if that variable is non-null. The string may be overwritten by
2980 subsequent calls. */
2983 overlay_strings (pos
, w
, pstr
)
2986 unsigned char **pstr
;
2988 Lisp_Object overlay
, window
, str
;
2989 struct Lisp_Overlay
*ov
;
2990 int startpos
, endpos
;
2991 int multibyte
= ! NILP (current_buffer
->enable_multibyte_characters
);
2993 overlay_heads
.used
= overlay_heads
.bytes
= 0;
2994 overlay_tails
.used
= overlay_tails
.bytes
= 0;
2995 for (ov
= current_buffer
->overlays_before
; ov
; ov
= ov
->next
)
2997 XSETMISC (overlay
, ov
);
2998 eassert (OVERLAYP (overlay
));
3000 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3001 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3004 if (endpos
!= pos
&& startpos
!= pos
)
3006 window
= Foverlay_get (overlay
, Qwindow
);
3007 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3010 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3011 record_overlay_string (&overlay_heads
, str
,
3013 ? Foverlay_get (overlay
, Qafter_string
)
3015 Foverlay_get (overlay
, Qpriority
),
3017 else if (endpos
== pos
3018 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3019 record_overlay_string (&overlay_tails
, str
, Qnil
,
3020 Foverlay_get (overlay
, Qpriority
),
3023 for (ov
= current_buffer
->overlays_after
; ov
; ov
= ov
->next
)
3025 XSETMISC (overlay
, ov
);
3026 eassert (OVERLAYP (overlay
));
3028 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3029 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3032 if (endpos
!= pos
&& startpos
!= pos
)
3034 window
= Foverlay_get (overlay
, Qwindow
);
3035 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3038 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3039 record_overlay_string (&overlay_heads
, str
,
3041 ? Foverlay_get (overlay
, Qafter_string
)
3043 Foverlay_get (overlay
, Qpriority
),
3045 else if (endpos
== pos
3046 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3047 record_overlay_string (&overlay_tails
, str
, Qnil
,
3048 Foverlay_get (overlay
, Qpriority
),
3051 if (overlay_tails
.used
> 1)
3052 qsort (overlay_tails
.buf
, overlay_tails
.used
, sizeof (struct sortstr
),
3054 if (overlay_heads
.used
> 1)
3055 qsort (overlay_heads
.buf
, overlay_heads
.used
, sizeof (struct sortstr
),
3057 if (overlay_heads
.bytes
|| overlay_tails
.bytes
)
3062 int total
= overlay_heads
.bytes
+ overlay_tails
.bytes
;
3064 if (total
> overlay_str_len
)
3066 overlay_str_len
= total
;
3067 overlay_str_buf
= (unsigned char *)xrealloc (overlay_str_buf
,
3070 p
= overlay_str_buf
;
3071 for (i
= overlay_tails
.used
; --i
>= 0;)
3074 tem
= overlay_tails
.buf
[i
].string
;
3075 nbytes
= copy_text (SDATA (tem
), p
,
3077 STRING_MULTIBYTE (tem
), multibyte
);
3080 for (i
= 0; i
< overlay_heads
.used
; ++i
)
3083 tem
= overlay_heads
.buf
[i
].string
;
3084 nbytes
= copy_text (SDATA (tem
), p
,
3086 STRING_MULTIBYTE (tem
), multibyte
);
3088 tem
= overlay_heads
.buf
[i
].string2
;
3091 nbytes
= copy_text (SDATA (tem
), p
,
3093 STRING_MULTIBYTE (tem
), multibyte
);
3097 if (p
!= overlay_str_buf
+ total
)
3100 *pstr
= overlay_str_buf
;
3106 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
3109 recenter_overlay_lists (buf
, pos
)
3113 Lisp_Object overlay
, beg
, end
;
3114 struct Lisp_Overlay
*prev
, *tail
, *next
;
3116 /* See if anything in overlays_before should move to overlays_after. */
3118 /* We don't strictly need prev in this loop; it should always be nil.
3119 But we use it for symmetry and in case that should cease to be true
3120 with some future change. */
3122 for (tail
= buf
->overlays_before
; tail
; prev
= tail
, tail
= next
)
3125 XSETMISC (overlay
, tail
);
3127 /* If the overlay is not valid, get rid of it. */
3128 if (!OVERLAY_VALID (overlay
))
3133 /* Splice the cons cell TAIL out of overlays_before. */
3137 buf
->overlays_before
= next
;
3143 beg
= OVERLAY_START (overlay
);
3144 end
= OVERLAY_END (overlay
);
3146 if (OVERLAY_POSITION (end
) > pos
)
3148 /* OVERLAY needs to be moved. */
3149 int where
= OVERLAY_POSITION (beg
);
3150 struct Lisp_Overlay
*other
, *other_prev
;
3152 /* Splice the cons cell TAIL out of overlays_before. */
3156 buf
->overlays_before
= next
;
3158 /* Search thru overlays_after for where to put it. */
3160 for (other
= buf
->overlays_after
; other
;
3161 other_prev
= other
, other
= other
->next
)
3163 Lisp_Object otherbeg
, otheroverlay
;
3165 XSETMISC (otheroverlay
, other
);
3166 eassert (OVERLAY_VALID (otheroverlay
));
3168 otherbeg
= OVERLAY_START (otheroverlay
);
3169 if (OVERLAY_POSITION (otherbeg
) >= where
)
3173 /* Add TAIL to overlays_after before OTHER. */
3176 other_prev
->next
= tail
;
3178 buf
->overlays_after
= tail
;
3182 /* We've reached the things that should stay in overlays_before.
3183 All the rest of overlays_before must end even earlier,
3188 /* See if anything in overlays_after should be in overlays_before. */
3190 for (tail
= buf
->overlays_after
; tail
; prev
= tail
, tail
= next
)
3193 XSETMISC (overlay
, tail
);
3195 /* If the overlay is not valid, get rid of it. */
3196 if (!OVERLAY_VALID (overlay
))
3201 /* Splice the cons cell TAIL out of overlays_after. */
3205 buf
->overlays_after
= next
;
3211 beg
= OVERLAY_START (overlay
);
3212 end
= OVERLAY_END (overlay
);
3214 /* Stop looking, when we know that nothing further
3215 can possibly end before POS. */
3216 if (OVERLAY_POSITION (beg
) > pos
)
3219 if (OVERLAY_POSITION (end
) <= pos
)
3221 /* OVERLAY needs to be moved. */
3222 int where
= OVERLAY_POSITION (end
);
3223 struct Lisp_Overlay
*other
, *other_prev
;
3225 /* Splice the cons cell TAIL out of overlays_after. */
3229 buf
->overlays_after
= next
;
3231 /* Search thru overlays_before for where to put it. */
3233 for (other
= buf
->overlays_before
; other
;
3234 other_prev
= other
, other
= other
->next
)
3236 Lisp_Object otherend
, otheroverlay
;
3238 XSETMISC (otheroverlay
, other
);
3239 eassert (OVERLAY_VALID (otheroverlay
));
3241 otherend
= OVERLAY_END (otheroverlay
);
3242 if (OVERLAY_POSITION (otherend
) <= where
)
3246 /* Add TAIL to overlays_before before OTHER. */
3249 other_prev
->next
= tail
;
3251 buf
->overlays_before
= tail
;
3256 buf
->overlay_center
= pos
;
3260 adjust_overlays_for_insert (pos
, length
)
3264 /* After an insertion, the lists are still sorted properly,
3265 but we may need to update the value of the overlay center. */
3266 if (current_buffer
->overlay_center
>= pos
)
3267 current_buffer
->overlay_center
+= length
;
3271 adjust_overlays_for_delete (pos
, length
)
3275 if (current_buffer
->overlay_center
< pos
)
3276 /* The deletion was to our right. No change needed; the before- and
3277 after-lists are still consistent. */
3279 else if (current_buffer
->overlay_center
> pos
+ length
)
3280 /* The deletion was to our left. We need to adjust the center value
3281 to account for the change in position, but the lists are consistent
3282 given the new value. */
3283 current_buffer
->overlay_center
-= length
;
3285 /* We're right in the middle. There might be things on the after-list
3286 that now belong on the before-list. Recentering will move them,
3287 and also update the center point. */
3288 recenter_overlay_lists (current_buffer
, pos
);
3291 /* Fix up overlays that were garbled as a result of permuting markers
3292 in the range START through END. Any overlay with at least one
3293 endpoint in this range will need to be unlinked from the overlay
3294 list and reinserted in its proper place.
3295 Such an overlay might even have negative size at this point.
3296 If so, we'll make the overlay empty. */
3298 fix_start_end_in_overlays (start
, end
)
3299 register int start
, end
;
3301 Lisp_Object overlay
;
3302 struct Lisp_Overlay
*before_list
, *after_list
;
3303 /* These are either nil, indicating that before_list or after_list
3304 should be assigned, or the cons cell the cdr of which should be
3306 struct Lisp_Overlay
*beforep
= NULL
, *afterp
= NULL
;
3307 /* 'Parent', likewise, indicates a cons cell or
3308 current_buffer->overlays_before or overlays_after, depending
3309 which loop we're in. */
3310 struct Lisp_Overlay
*tail
, *parent
;
3311 int startpos
, endpos
;
3313 /* This algorithm shifts links around instead of consing and GCing.
3314 The loop invariant is that before_list (resp. after_list) is a
3315 well-formed list except that its last element, the CDR of beforep
3316 (resp. afterp) if beforep (afterp) isn't nil or before_list
3317 (after_list) if it is, is still uninitialized. So it's not a bug
3318 that before_list isn't initialized, although it may look
3320 for (parent
= NULL
, tail
= current_buffer
->overlays_before
; tail
;)
3322 XSETMISC (overlay
, tail
);
3324 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3325 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3327 /* If the overlay is backwards, make it empty. */
3328 if (endpos
< startpos
)
3331 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3339 || (startpos
>= start
&& startpos
< end
))
3341 /* Add it to the end of the wrong list. Later on,
3342 recenter_overlay_lists will move it to the right place. */
3343 if (endpos
< current_buffer
->overlay_center
)
3348 afterp
->next
= tail
;
3356 beforep
->next
= tail
;
3360 current_buffer
->overlays_before
= tail
->next
;
3362 parent
->next
= tail
->next
;
3366 parent
= tail
, tail
= parent
->next
;
3368 for (parent
= NULL
, tail
= current_buffer
->overlays_after
; tail
;)
3370 XSETMISC (overlay
, tail
);
3372 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3373 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3375 /* If the overlay is backwards, make it empty. */
3376 if (endpos
< startpos
)
3379 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3383 if (startpos
>= end
)
3386 if (startpos
>= start
3387 || (endpos
>= start
&& endpos
< end
))
3389 if (endpos
< current_buffer
->overlay_center
)
3394 afterp
->next
= tail
;
3402 beforep
->next
= tail
;
3406 current_buffer
->overlays_after
= tail
->next
;
3408 parent
->next
= tail
->next
;
3412 parent
= tail
, tail
= parent
->next
;
3415 /* Splice the constructed (wrong) lists into the buffer's lists,
3416 and let the recenter function make it sane again. */
3419 beforep
->next
= current_buffer
->overlays_before
;
3420 current_buffer
->overlays_before
= before_list
;
3422 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3426 afterp
->next
= current_buffer
->overlays_after
;
3427 current_buffer
->overlays_after
= after_list
;
3429 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3432 /* We have two types of overlay: the one whose ending marker is
3433 after-insertion-marker (this is the usual case) and the one whose
3434 ending marker is before-insertion-marker. When `overlays_before'
3435 contains overlays of the latter type and the former type in this
3436 order and both overlays end at inserting position, inserting a text
3437 increases only the ending marker of the latter type, which results
3438 in incorrect ordering of `overlays_before'.
3440 This function fixes ordering of overlays in the slot
3441 `overlays_before' of the buffer *BP. Before the insertion, `point'
3442 was at PREV, and now is at POS. */
3445 fix_overlays_before (bp
, prev
, pos
)
3447 EMACS_INT prev
, pos
;
3449 /* If parent is nil, replace overlays_before; otherwise, parent->next. */
3450 struct Lisp_Overlay
*tail
= bp
->overlays_before
, *parent
= NULL
, *right_pair
;
3454 /* After the insertion, the several overlays may be in incorrect
3455 order. The possibility is that, in the list `overlays_before',
3456 an overlay which ends at POS appears after an overlay which ends
3457 at PREV. Since POS is greater than PREV, we must fix the
3458 ordering of these overlays, by moving overlays ends at POS before
3459 the overlays ends at PREV. */
3461 /* At first, find a place where disordered overlays should be linked
3462 in. It is where an overlay which end before POS exists. (i.e. an
3463 overlay whose ending marker is after-insertion-marker if disorder
3466 && (XSETMISC (tem
, tail
),
3467 (end
= OVERLAY_POSITION (OVERLAY_END (tem
))) >= pos
))
3473 /* If we don't find such an overlay,
3474 or the found one ends before PREV,
3475 or the found one is the last one in the list,
3476 we don't have to fix anything. */
3477 if (!tail
|| end
< prev
|| !tail
->next
)
3480 right_pair
= parent
;
3484 /* Now, end position of overlays in the list TAIL should be before
3485 or equal to PREV. In the loop, an overlay which ends at POS is
3486 moved ahead to the place indicated by the CDR of RIGHT_PAIR. If
3487 we found an overlay which ends before PREV, the remaining
3488 overlays are in correct order. */
3491 XSETMISC (tem
, tail
);
3492 end
= OVERLAY_POSITION (OVERLAY_END (tem
));
3495 { /* This overlay is disordered. */
3496 struct Lisp_Overlay
*found
= tail
;
3498 /* Unlink the found overlay. */
3500 parent
->next
= tail
;
3501 /* Move an overlay at RIGHT_PLACE to the next of the found one,
3502 and link it into the right place. */
3505 found
->next
= bp
->overlays_before
;
3506 bp
->overlays_before
= found
;
3510 found
->next
= right_pair
->next
;
3511 right_pair
->next
= found
;
3514 else if (end
== prev
)
3519 else /* No more disordered overlay. */
3524 DEFUN ("overlayp", Foverlayp
, Soverlayp
, 1, 1, 0,
3525 doc
: /* Return t if OBJECT is an overlay. */)
3529 return (OVERLAYP (object
) ? Qt
: Qnil
);
3532 DEFUN ("make-overlay", Fmake_overlay
, Smake_overlay
, 2, 5, 0,
3533 doc
: /* Create a new overlay with range BEG to END in BUFFER.
3534 If omitted, BUFFER defaults to the current buffer.
3535 BEG and END may be integers or markers.
3536 The fourth arg FRONT-ADVANCE, if non-nil, makes the
3537 front delimiter advance when text is inserted there.
3538 The fifth arg REAR-ADVANCE, if non-nil, makes the
3539 rear delimiter advance when text is inserted there. */)
3540 (beg
, end
, buffer
, front_advance
, rear_advance
)
3541 Lisp_Object beg
, end
, buffer
;
3542 Lisp_Object front_advance
, rear_advance
;
3544 Lisp_Object overlay
;
3548 XSETBUFFER (buffer
, current_buffer
);
3550 CHECK_BUFFER (buffer
);
3552 && ! EQ (Fmarker_buffer (beg
), buffer
))
3553 error ("Marker points into wrong buffer");
3555 && ! EQ (Fmarker_buffer (end
), buffer
))
3556 error ("Marker points into wrong buffer");
3558 CHECK_NUMBER_COERCE_MARKER (beg
);
3559 CHECK_NUMBER_COERCE_MARKER (end
);
3561 if (XINT (beg
) > XINT (end
))
3564 temp
= beg
; beg
= end
; end
= temp
;
3567 b
= XBUFFER (buffer
);
3569 beg
= Fset_marker (Fmake_marker (), beg
, buffer
);
3570 end
= Fset_marker (Fmake_marker (), end
, buffer
);
3572 if (!NILP (front_advance
))
3573 XMARKER (beg
)->insertion_type
= 1;
3574 if (!NILP (rear_advance
))
3575 XMARKER (end
)->insertion_type
= 1;
3577 overlay
= allocate_misc ();
3578 XMISCTYPE (overlay
) = Lisp_Misc_Overlay
;
3579 XOVERLAY (overlay
)->start
= beg
;
3580 XOVERLAY (overlay
)->end
= end
;
3581 XOVERLAY (overlay
)->plist
= Qnil
;
3582 XOVERLAY (overlay
)->next
= NULL
;
3584 /* Put the new overlay on the wrong list. */
3585 end
= OVERLAY_END (overlay
);
3586 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
3588 if (b
->overlays_after
)
3589 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3590 b
->overlays_after
= XOVERLAY (overlay
);
3594 if (b
->overlays_before
)
3595 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3596 b
->overlays_before
= XOVERLAY (overlay
);
3599 /* This puts it in the right list, and in the right order. */
3600 recenter_overlay_lists (b
, b
->overlay_center
);
3602 /* We don't need to redisplay the region covered by the overlay, because
3603 the overlay has no properties at the moment. */
3608 /* Mark a section of BUF as needing redisplay because of overlays changes. */
3611 modify_overlay (buf
, start
, end
)
3613 EMACS_INT start
, end
;
3622 BUF_COMPUTE_UNCHANGED (buf
, start
, end
);
3624 /* If this is a buffer not in the selected window,
3625 we must do other windows. */
3626 if (buf
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
3627 windows_or_buffers_changed
= 1;
3628 /* If multiple windows show this buffer, we must do other windows. */
3629 else if (buffer_shared
> 1)
3630 windows_or_buffers_changed
= 1;
3632 ++BUF_OVERLAY_MODIFF (buf
);
3636 Lisp_Object
Fdelete_overlay ();
3638 static struct Lisp_Overlay
*
3639 unchain_overlay (list
, overlay
)
3640 struct Lisp_Overlay
*list
, *overlay
;
3642 struct Lisp_Overlay
*tmp
, *prev
;
3643 for (tmp
= list
, prev
= NULL
; tmp
; prev
= tmp
, tmp
= tmp
->next
)
3647 prev
->next
= tmp
->next
;
3650 overlay
->next
= NULL
;
3656 DEFUN ("move-overlay", Fmove_overlay
, Smove_overlay
, 3, 4, 0,
3657 doc
: /* Set the endpoints of OVERLAY to BEG and END in BUFFER.
3658 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.
3659 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current
3661 (overlay
, beg
, end
, buffer
)
3662 Lisp_Object overlay
, beg
, end
, buffer
;
3664 struct buffer
*b
, *ob
;
3665 Lisp_Object obuffer
;
3666 int count
= SPECPDL_INDEX ();
3668 CHECK_OVERLAY (overlay
);
3670 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3672 XSETBUFFER (buffer
, current_buffer
);
3673 CHECK_BUFFER (buffer
);
3676 && ! EQ (Fmarker_buffer (beg
), buffer
))
3677 error ("Marker points into wrong buffer");
3679 && ! EQ (Fmarker_buffer (end
), buffer
))
3680 error ("Marker points into wrong buffer");
3682 CHECK_NUMBER_COERCE_MARKER (beg
);
3683 CHECK_NUMBER_COERCE_MARKER (end
);
3685 if (XINT (beg
) == XINT (end
) && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
3686 return Fdelete_overlay (overlay
);
3688 if (XINT (beg
) > XINT (end
))
3691 temp
= beg
; beg
= end
; end
= temp
;
3694 specbind (Qinhibit_quit
, Qt
);
3696 obuffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3697 b
= XBUFFER (buffer
);
3698 ob
= BUFFERP (obuffer
) ? XBUFFER (obuffer
) : (struct buffer
*) 0;
3700 /* If the overlay has changed buffers, do a thorough redisplay. */
3701 if (!EQ (buffer
, obuffer
))
3703 /* Redisplay where the overlay was. */
3704 if (!NILP (obuffer
))
3709 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3710 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3712 modify_overlay (ob
, o_beg
, o_end
);
3715 /* Redisplay where the overlay is going to be. */
3716 modify_overlay (b
, XINT (beg
), XINT (end
));
3719 /* Redisplay the area the overlay has just left, or just enclosed. */
3723 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3724 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3726 if (o_beg
== XINT (beg
))
3727 modify_overlay (b
, o_end
, XINT (end
));
3728 else if (o_end
== XINT (end
))
3729 modify_overlay (b
, o_beg
, XINT (beg
));
3732 if (XINT (beg
) < o_beg
) o_beg
= XINT (beg
);
3733 if (XINT (end
) > o_end
) o_end
= XINT (end
);
3734 modify_overlay (b
, o_beg
, o_end
);
3738 if (!NILP (obuffer
))
3741 = unchain_overlay (ob
->overlays_before
, XOVERLAY (overlay
));
3743 = unchain_overlay (ob
->overlays_after
, XOVERLAY (overlay
));
3744 eassert (XOVERLAY (overlay
)->next
== NULL
);
3747 Fset_marker (OVERLAY_START (overlay
), beg
, buffer
);
3748 Fset_marker (OVERLAY_END (overlay
), end
, buffer
);
3750 /* Put the overlay on the wrong list. */
3751 end
= OVERLAY_END (overlay
);
3752 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
3754 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3755 b
->overlays_after
= XOVERLAY (overlay
);
3759 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3760 b
->overlays_before
= XOVERLAY (overlay
);
3763 /* This puts it in the right list, and in the right order. */
3764 recenter_overlay_lists (b
, b
->overlay_center
);
3766 return unbind_to (count
, overlay
);
3769 DEFUN ("delete-overlay", Fdelete_overlay
, Sdelete_overlay
, 1, 1, 0,
3770 doc
: /* Delete the overlay OVERLAY from its buffer. */)
3772 Lisp_Object overlay
;
3776 int count
= SPECPDL_INDEX ();
3778 CHECK_OVERLAY (overlay
);
3780 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3784 b
= XBUFFER (buffer
);
3785 specbind (Qinhibit_quit
, Qt
);
3787 b
->overlays_before
= unchain_overlay (b
->overlays_before
,XOVERLAY (overlay
));
3788 b
->overlays_after
= unchain_overlay (b
->overlays_after
, XOVERLAY (overlay
));
3789 eassert (XOVERLAY (overlay
)->next
== NULL
);
3791 marker_position (OVERLAY_START (overlay
)),
3792 marker_position (OVERLAY_END (overlay
)));
3793 Fset_marker (OVERLAY_START (overlay
), Qnil
, Qnil
);
3794 Fset_marker (OVERLAY_END (overlay
), Qnil
, Qnil
);
3796 /* When deleting an overlay with before or after strings, turn off
3797 display optimizations for the affected buffer, on the basis that
3798 these strings may contain newlines. This is easier to do than to
3799 check for that situation during redisplay. */
3800 if (!windows_or_buffers_changed
3801 && (!NILP (Foverlay_get (overlay
, Qbefore_string
))
3802 || !NILP (Foverlay_get (overlay
, Qafter_string
))))
3803 b
->prevent_redisplay_optimizations_p
= 1;
3805 return unbind_to (count
, Qnil
);
3808 /* Overlay dissection functions. */
3810 DEFUN ("overlay-start", Foverlay_start
, Soverlay_start
, 1, 1, 0,
3811 doc
: /* Return the position at which OVERLAY starts. */)
3813 Lisp_Object overlay
;
3815 CHECK_OVERLAY (overlay
);
3817 return (Fmarker_position (OVERLAY_START (overlay
)));
3820 DEFUN ("overlay-end", Foverlay_end
, Soverlay_end
, 1, 1, 0,
3821 doc
: /* Return the position at which OVERLAY ends. */)
3823 Lisp_Object overlay
;
3825 CHECK_OVERLAY (overlay
);
3827 return (Fmarker_position (OVERLAY_END (overlay
)));
3830 DEFUN ("overlay-buffer", Foverlay_buffer
, Soverlay_buffer
, 1, 1, 0,
3831 doc
: /* Return the buffer OVERLAY belongs to. */)
3833 Lisp_Object overlay
;
3835 CHECK_OVERLAY (overlay
);
3837 return Fmarker_buffer (OVERLAY_START (overlay
));
3840 DEFUN ("overlay-properties", Foverlay_properties
, Soverlay_properties
, 1, 1, 0,
3841 doc
: /* Return a list of the properties on OVERLAY.
3842 This is a copy of OVERLAY's plist; modifying its conses has no effect on
3845 Lisp_Object overlay
;
3847 CHECK_OVERLAY (overlay
);
3849 return Fcopy_sequence (XOVERLAY (overlay
)->plist
);
3853 DEFUN ("overlays-at", Foverlays_at
, Soverlays_at
, 1, 1, 0,
3854 doc
: /* Return a list of the overlays that contain position POS. */)
3859 Lisp_Object
*overlay_vec
;
3863 CHECK_NUMBER_COERCE_MARKER (pos
);
3866 /* We can't use alloca here because overlays_at can call xrealloc. */
3867 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3869 /* Put all the overlays we want in a vector in overlay_vec.
3870 Store the length in len. */
3871 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
3872 (int *) 0, (int *) 0, 0);
3874 /* Make a list of them all. */
3875 result
= Flist (noverlays
, overlay_vec
);
3877 xfree (overlay_vec
);
3881 DEFUN ("overlays-in", Foverlays_in
, Soverlays_in
, 2, 2, 0,
3882 doc
: /* Return a list of the overlays that overlap the region BEG ... END.
3883 Overlap means that at least one character is contained within the overlay
3884 and also contained within the specified region.
3885 Empty overlays are included in the result if they are located at BEG
3886 or between BEG and END. */)
3888 Lisp_Object beg
, end
;
3891 Lisp_Object
*overlay_vec
;
3895 CHECK_NUMBER_COERCE_MARKER (beg
);
3896 CHECK_NUMBER_COERCE_MARKER (end
);
3899 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3901 /* Put all the overlays we want in a vector in overlay_vec.
3902 Store the length in len. */
3903 noverlays
= overlays_in (XINT (beg
), XINT (end
), 1, &overlay_vec
, &len
,
3904 (int *) 0, (int *) 0);
3906 /* Make a list of them all. */
3907 result
= Flist (noverlays
, overlay_vec
);
3909 xfree (overlay_vec
);
3913 DEFUN ("next-overlay-change", Fnext_overlay_change
, Snext_overlay_change
,
3915 doc
: /* Return the next position after POS where an overlay starts or ends.
3916 If there are no more overlay boundaries after POS, return (point-max). */)
3922 Lisp_Object
*overlay_vec
;
3926 CHECK_NUMBER_COERCE_MARKER (pos
);
3929 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3931 /* Put all the overlays we want in a vector in overlay_vec.
3932 Store the length in len.
3933 endpos gets the position where the next overlay starts. */
3934 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
3935 &endpos
, (int *) 0, 1);
3937 /* If any of these overlays ends before endpos,
3938 use its ending point instead. */
3939 for (i
= 0; i
< noverlays
; i
++)
3944 oend
= OVERLAY_END (overlay_vec
[i
]);
3945 oendpos
= OVERLAY_POSITION (oend
);
3946 if (oendpos
< endpos
)
3950 xfree (overlay_vec
);
3951 return make_number (endpos
);
3954 DEFUN ("previous-overlay-change", Fprevious_overlay_change
,
3955 Sprevious_overlay_change
, 1, 1, 0,
3956 doc
: /* Return the previous position before POS where an overlay starts or ends.
3957 If there are no more overlay boundaries before POS, return (point-min). */)
3963 Lisp_Object
*overlay_vec
;
3966 CHECK_NUMBER_COERCE_MARKER (pos
);
3968 /* At beginning of buffer, we know the answer;
3969 avoid bug subtracting 1 below. */
3970 if (XINT (pos
) == BEGV
)
3974 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3976 /* Put all the overlays we want in a vector in overlay_vec.
3977 Store the length in len.
3978 prevpos gets the position of the previous change. */
3979 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
3980 (int *) 0, &prevpos
, 1);
3982 xfree (overlay_vec
);
3983 return make_number (prevpos
);
3986 /* These functions are for debugging overlays. */
3988 DEFUN ("overlay-lists", Foverlay_lists
, Soverlay_lists
, 0, 0, 0,
3989 doc
: /* Return a pair of lists giving all the overlays of the current buffer.
3990 The car has all the overlays before the overlay center;
3991 the cdr has all the overlays after the overlay center.
3992 Recentering overlays moves overlays between these lists.
3993 The lists you get are copies, so that changing them has no effect.
3994 However, the overlays you get are the real objects that the buffer uses. */)
3997 struct Lisp_Overlay
*ol
;
3998 Lisp_Object before
= Qnil
, after
= Qnil
, tmp
;
3999 for (ol
= current_buffer
->overlays_before
; ol
; ol
= ol
->next
)
4002 before
= Fcons (tmp
, before
);
4004 for (ol
= current_buffer
->overlays_after
; ol
; ol
= ol
->next
)
4007 after
= Fcons (tmp
, after
);
4009 return Fcons (Fnreverse (before
), Fnreverse (after
));
4012 DEFUN ("overlay-recenter", Foverlay_recenter
, Soverlay_recenter
, 1, 1, 0,
4013 doc
: /* Recenter the overlays of the current buffer around position POS.
4014 That makes overlay lookup faster for positions near POS (but perhaps slower
4015 for positions far away from POS). */)
4019 CHECK_NUMBER_COERCE_MARKER (pos
);
4021 recenter_overlay_lists (current_buffer
, XINT (pos
));
4025 DEFUN ("overlay-get", Foverlay_get
, Soverlay_get
, 2, 2, 0,
4026 doc
: /* Get the property of overlay OVERLAY with property name PROP. */)
4028 Lisp_Object overlay
, prop
;
4030 CHECK_OVERLAY (overlay
);
4031 return lookup_char_property (XOVERLAY (overlay
)->plist
, prop
, 0);
4034 DEFUN ("overlay-put", Foverlay_put
, Soverlay_put
, 3, 3, 0,
4035 doc
: /* Set one property of overlay OVERLAY: give property PROP value VALUE. */)
4036 (overlay
, prop
, value
)
4037 Lisp_Object overlay
, prop
, value
;
4039 Lisp_Object tail
, buffer
;
4042 CHECK_OVERLAY (overlay
);
4044 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4046 for (tail
= XOVERLAY (overlay
)->plist
;
4047 CONSP (tail
) && CONSP (XCDR (tail
));
4048 tail
= XCDR (XCDR (tail
)))
4049 if (EQ (XCAR (tail
), prop
))
4051 changed
= !EQ (XCAR (XCDR (tail
)), value
);
4052 XSETCAR (XCDR (tail
), value
);
4055 /* It wasn't in the list, so add it to the front. */
4056 changed
= !NILP (value
);
4057 XOVERLAY (overlay
)->plist
4058 = Fcons (prop
, Fcons (value
, XOVERLAY (overlay
)->plist
));
4060 if (! NILP (buffer
))
4063 modify_overlay (XBUFFER (buffer
),
4064 marker_position (OVERLAY_START (overlay
)),
4065 marker_position (OVERLAY_END (overlay
)));
4066 if (EQ (prop
, Qevaporate
) && ! NILP (value
)
4067 && (OVERLAY_POSITION (OVERLAY_START (overlay
))
4068 == OVERLAY_POSITION (OVERLAY_END (overlay
))))
4069 Fdelete_overlay (overlay
);
4074 /* Subroutine of report_overlay_modification. */
4076 /* Lisp vector holding overlay hook functions to call.
4077 Vector elements come in pairs.
4078 Each even-index element is a list of hook functions.
4079 The following odd-index element is the overlay they came from.
4081 Before the buffer change, we fill in this vector
4082 as we call overlay hook functions.
4083 After the buffer change, we get the functions to call from this vector.
4084 This way we always call the same functions before and after the change. */
4085 static Lisp_Object last_overlay_modification_hooks
;
4087 /* Number of elements actually used in last_overlay_modification_hooks. */
4088 static int last_overlay_modification_hooks_used
;
4090 /* Add one functionlist/overlay pair
4091 to the end of last_overlay_modification_hooks. */
4094 add_overlay_mod_hooklist (functionlist
, overlay
)
4095 Lisp_Object functionlist
, overlay
;
4097 int oldsize
= XVECTOR (last_overlay_modification_hooks
)->size
;
4099 if (last_overlay_modification_hooks_used
== oldsize
)
4102 old
= last_overlay_modification_hooks
;
4103 last_overlay_modification_hooks
4104 = Fmake_vector (make_number (oldsize
* 2), Qnil
);
4105 bcopy (XVECTOR (old
)->contents
,
4106 XVECTOR (last_overlay_modification_hooks
)->contents
,
4107 sizeof (Lisp_Object
) * oldsize
);
4109 AREF (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
++) = functionlist
;
4110 AREF (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
++) = overlay
;
4113 /* Run the modification-hooks of overlays that include
4114 any part of the text in START to END.
4115 If this change is an insertion, also
4116 run the insert-before-hooks of overlay starting at END,
4117 and the insert-after-hooks of overlay ending at START.
4119 This is called both before and after the modification.
4120 AFTER is nonzero when we call after the modification.
4122 ARG1, ARG2, ARG3 are arguments to pass to the hook functions.
4123 When AFTER is nonzero, they are the start position,
4124 the position after the inserted new text,
4125 and the length of deleted or replaced old text. */
4128 report_overlay_modification (start
, end
, after
, arg1
, arg2
, arg3
)
4129 Lisp_Object start
, end
;
4131 Lisp_Object arg1
, arg2
, arg3
;
4133 Lisp_Object prop
, overlay
;
4134 struct Lisp_Overlay
*tail
;
4135 /* 1 if this change is an insertion. */
4136 int insertion
= (after
? XFASTINT (arg3
) == 0 : EQ (start
, end
));
4137 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4142 /* We used to run the functions as soon as we found them and only register
4143 them in last_overlay_modification_hooks for the purpose of the `after'
4144 case. But running elisp code as we traverse the list of overlays is
4145 painful because the list can be modified by the elisp code so we had to
4146 copy at several places. We now simply do a read-only traversal that
4147 only collects the functions to run and we run them afterwards. It's
4148 simpler, especially since all the code was already there. -stef */
4152 /* We are being called before a change.
4153 Scan the overlays to find the functions to call. */
4154 last_overlay_modification_hooks_used
= 0;
4155 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4157 int startpos
, endpos
;
4158 Lisp_Object ostart
, oend
;
4160 XSETMISC (overlay
, tail
);
4162 ostart
= OVERLAY_START (overlay
);
4163 oend
= OVERLAY_END (overlay
);
4164 endpos
= OVERLAY_POSITION (oend
);
4165 if (XFASTINT (start
) > endpos
)
4167 startpos
= OVERLAY_POSITION (ostart
);
4168 if (insertion
&& (XFASTINT (start
) == startpos
4169 || XFASTINT (end
) == startpos
))
4171 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4173 add_overlay_mod_hooklist (prop
, overlay
);
4175 if (insertion
&& (XFASTINT (start
) == endpos
4176 || XFASTINT (end
) == endpos
))
4178 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4180 add_overlay_mod_hooklist (prop
, overlay
);
4182 /* Test for intersecting intervals. This does the right thing
4183 for both insertion and deletion. */
4184 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4186 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4188 add_overlay_mod_hooklist (prop
, overlay
);
4192 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4194 int startpos
, endpos
;
4195 Lisp_Object ostart
, oend
;
4197 XSETMISC (overlay
, tail
);
4199 ostart
= OVERLAY_START (overlay
);
4200 oend
= OVERLAY_END (overlay
);
4201 startpos
= OVERLAY_POSITION (ostart
);
4202 endpos
= OVERLAY_POSITION (oend
);
4203 if (XFASTINT (end
) < startpos
)
4205 if (insertion
&& (XFASTINT (start
) == startpos
4206 || XFASTINT (end
) == startpos
))
4208 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4210 add_overlay_mod_hooklist (prop
, overlay
);
4212 if (insertion
&& (XFASTINT (start
) == endpos
4213 || XFASTINT (end
) == endpos
))
4215 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4217 add_overlay_mod_hooklist (prop
, overlay
);
4219 /* Test for intersecting intervals. This does the right thing
4220 for both insertion and deletion. */
4221 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4223 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4225 add_overlay_mod_hooklist (prop
, overlay
);
4230 GCPRO4 (overlay
, arg1
, arg2
, arg3
);
4232 /* Call the functions recorded in last_overlay_modification_hooks.
4233 First copy the vector contents, in case some of these hooks
4234 do subsequent modification of the buffer. */
4235 int size
= last_overlay_modification_hooks_used
;
4236 Lisp_Object
*copy
= (Lisp_Object
*) alloca (size
* sizeof (Lisp_Object
));
4239 bcopy (XVECTOR (last_overlay_modification_hooks
)->contents
,
4240 copy
, size
* sizeof (Lisp_Object
));
4242 gcpro1
.nvars
= size
;
4244 for (i
= 0; i
< size
;)
4246 Lisp_Object prop
, overlay
;
4248 overlay
= copy
[i
++];
4249 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
4256 call_overlay_mod_hooks (list
, overlay
, after
, arg1
, arg2
, arg3
)
4257 Lisp_Object list
, overlay
;
4259 Lisp_Object arg1
, arg2
, arg3
;
4261 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4263 GCPRO4 (list
, arg1
, arg2
, arg3
);
4265 while (CONSP (list
))
4268 call4 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
);
4270 call5 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
, arg3
);
4276 /* Delete any zero-sized overlays at position POS, if the `evaporate'
4279 evaporate_overlays (pos
)
4282 Lisp_Object overlay
, hit_list
;
4283 struct Lisp_Overlay
*tail
;
4286 if (pos
<= current_buffer
->overlay_center
)
4287 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4290 XSETMISC (overlay
, tail
);
4291 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4294 if (endpos
== pos
&& OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
4295 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4296 hit_list
= Fcons (overlay
, hit_list
);
4299 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4302 XSETMISC (overlay
, tail
);
4303 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4306 if (startpos
== pos
&& OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
4307 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4308 hit_list
= Fcons (overlay
, hit_list
);
4310 for (; CONSP (hit_list
); hit_list
= XCDR (hit_list
))
4311 Fdelete_overlay (XCAR (hit_list
));
4314 /* Somebody has tried to store a value with an unacceptable type
4315 in the slot with offset OFFSET. */
4318 buffer_slot_type_mismatch (offset
)
4324 switch (XINT (PER_BUFFER_TYPE (offset
)))
4327 type_name
= "integers";
4331 type_name
= "strings";
4335 type_name
= "symbols";
4342 sym
= PER_BUFFER_SYMBOL (offset
);
4343 error ("Only %s should be stored in the buffer-local variable %s",
4344 type_name
, SDATA (SYMBOL_NAME (sym
)));
4348 /***********************************************************************
4349 Allocation with mmap
4350 ***********************************************************************/
4352 #ifdef USE_MMAP_FOR_BUFFERS
4354 #include <sys/types.h>
4355 #include <sys/mman.h>
4358 #ifdef MAP_ANONYMOUS
4359 #define MAP_ANON MAP_ANONYMOUS
4366 #define MAP_FAILED ((void *) -1)
4379 /* Memory is allocated in regions which are mapped using mmap(2).
4380 The current implementation lets the system select mapped
4381 addresses; we're not using MAP_FIXED in general, except when
4382 trying to enlarge regions.
4384 Each mapped region starts with a mmap_region structure, the user
4385 area starts after that structure, aligned to MEM_ALIGN.
4387 +-----------------------+
4388 | struct mmap_info + |
4390 +-----------------------+
4394 +-----------------------+ */
4398 /* User-specified size. */
4399 size_t nbytes_specified
;
4401 /* Number of bytes mapped */
4402 size_t nbytes_mapped
;
4404 /* Pointer to the location holding the address of the memory
4405 allocated with the mmap'd block. The variable actually points
4406 after this structure. */
4409 /* Next and previous in list of all mmap'd regions. */
4410 struct mmap_region
*next
, *prev
;
4413 /* Doubly-linked list of mmap'd regions. */
4415 static struct mmap_region
*mmap_regions
;
4417 /* File descriptor for mmap. If we don't have anonymous mapping,
4418 /dev/zero will be opened on it. */
4422 /* Temporary storage for mmap_set_vars, see there. */
4424 static struct mmap_region
*mmap_regions_1
;
4425 static int mmap_fd_1
;
4427 /* Page size on this system. */
4429 static int mmap_page_size
;
4431 /* 1 means mmap has been intialized. */
4433 static int mmap_initialized_p
;
4435 /* Value is X rounded up to the next multiple of N. */
4437 #define ROUND(X, N) (((X) + (N) - 1) / (N) * (N))
4439 /* Size of mmap_region structure plus padding. */
4441 #define MMAP_REGION_STRUCT_SIZE \
4442 ROUND (sizeof (struct mmap_region), MEM_ALIGN)
4444 /* Given a pointer P to the start of the user-visible part of a mapped
4445 region, return a pointer to the start of the region. */
4447 #define MMAP_REGION(P) \
4448 ((struct mmap_region *) ((char *) (P) - MMAP_REGION_STRUCT_SIZE))
4450 /* Given a pointer P to the start of a mapped region, return a pointer
4451 to the start of the user-visible part of the region. */
4453 #define MMAP_USER_AREA(P) \
4454 ((POINTER_TYPE *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
4456 #define MEM_ALIGN sizeof (double)
4458 /* Predicate returning true if part of the address range [START .. END]
4459 is currently mapped. Used to prevent overwriting an existing
4462 Default is to conservativly assume the address range is occupied by
4463 something else. This can be overridden by system configuration
4464 files if system-specific means to determine this exists. */
4466 #ifndef MMAP_ALLOCATED_P
4467 #define MMAP_ALLOCATED_P(start, end) 1
4470 /* Function prototypes. */
4472 static int mmap_free_1
P_ ((struct mmap_region
*));
4473 static int mmap_enlarge
P_ ((struct mmap_region
*, int));
4474 static struct mmap_region
*mmap_find
P_ ((POINTER_TYPE
*, POINTER_TYPE
*));
4475 static POINTER_TYPE
*mmap_alloc
P_ ((POINTER_TYPE
**, size_t));
4476 static POINTER_TYPE
*mmap_realloc
P_ ((POINTER_TYPE
**, size_t));
4477 static void mmap_free
P_ ((POINTER_TYPE
**ptr
));
4478 static void mmap_init
P_ ((void));
4481 /* Return a region overlapping address range START...END, or null if
4482 none. END is not including, i.e. the last byte in the range
4485 static struct mmap_region
*
4486 mmap_find (start
, end
)
4487 POINTER_TYPE
*start
, *end
;
4489 struct mmap_region
*r
;
4490 char *s
= (char *) start
, *e
= (char *) end
;
4492 for (r
= mmap_regions
; r
; r
= r
->next
)
4494 char *rstart
= (char *) r
;
4495 char *rend
= rstart
+ r
->nbytes_mapped
;
4497 if (/* First byte of range, i.e. START, in this region? */
4498 (s
>= rstart
&& s
< rend
)
4499 /* Last byte of range, i.e. END - 1, in this region? */
4500 || (e
> rstart
&& e
<= rend
)
4501 /* First byte of this region in the range? */
4502 || (rstart
>= s
&& rstart
< e
)
4503 /* Last byte of this region in the range? */
4504 || (rend
> s
&& rend
<= e
))
4512 /* Unmap a region. P is a pointer to the start of the user-araa of
4513 the region. Value is non-zero if successful. */
4517 struct mmap_region
*r
;
4520 r
->next
->prev
= r
->prev
;
4522 r
->prev
->next
= r
->next
;
4524 mmap_regions
= r
->next
;
4526 if (munmap ((POINTER_TYPE
*) r
, r
->nbytes_mapped
) == -1)
4528 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4536 /* Enlarge region R by NPAGES pages. NPAGES < 0 means shrink R.
4537 Value is non-zero if successful. */
4540 mmap_enlarge (r
, npages
)
4541 struct mmap_region
*r
;
4544 char *region_end
= (char *) r
+ r
->nbytes_mapped
;
4550 /* Unmap pages at the end of the region. */
4551 nbytes
= - npages
* mmap_page_size
;
4552 if (munmap (region_end
- nbytes
, nbytes
) == -1)
4553 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4556 r
->nbytes_mapped
-= nbytes
;
4560 else if (npages
> 0)
4562 nbytes
= npages
* mmap_page_size
;
4564 /* Try to map additional pages at the end of the region. We
4565 cannot do this if the address range is already occupied by
4566 something else because mmap deletes any previous mapping.
4567 I'm not sure this is worth doing, let's see. */
4568 if (!MMAP_ALLOCATED_P (region_end
, region_end
+ nbytes
))
4572 p
= mmap (region_end
, nbytes
, PROT_READ
| PROT_WRITE
,
4573 MAP_ANON
| MAP_PRIVATE
| MAP_FIXED
, mmap_fd
, 0);
4574 if (p
== MAP_FAILED
)
4575 ; /* fprintf (stderr, "mmap: %s\n", emacs_strerror (errno)); */
4576 else if (p
!= (POINTER_TYPE
*) region_end
)
4578 /* Kernels are free to choose a different address. In
4579 that case, unmap what we've mapped above; we have
4581 if (munmap (p
, nbytes
) == -1)
4582 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4586 r
->nbytes_mapped
+= nbytes
;
4596 /* Set or reset variables holding references to mapped regions. If
4597 RESTORE_P is zero, set all variables to null. If RESTORE_P is
4598 non-zero, set all variables to the start of the user-areas
4601 This function is called from Fdump_emacs to ensure that the dumped
4602 Emacs doesn't contain references to memory that won't be mapped
4603 when Emacs starts. */
4606 mmap_set_vars (restore_p
)
4609 struct mmap_region
*r
;
4613 mmap_regions
= mmap_regions_1
;
4614 mmap_fd
= mmap_fd_1
;
4615 for (r
= mmap_regions
; r
; r
= r
->next
)
4616 *r
->var
= MMAP_USER_AREA (r
);
4620 for (r
= mmap_regions
; r
; r
= r
->next
)
4622 mmap_regions_1
= mmap_regions
;
4623 mmap_regions
= NULL
;
4624 mmap_fd_1
= mmap_fd
;
4630 /* Allocate a block of storage large enough to hold NBYTES bytes of
4631 data. A pointer to the data is returned in *VAR. VAR is thus the
4632 address of some variable which will use the data area.
4634 The allocation of 0 bytes is valid.
4636 If we can't allocate the necessary memory, set *VAR to null, and
4639 static POINTER_TYPE
*
4640 mmap_alloc (var
, nbytes
)
4649 map
= ROUND (nbytes
+ MMAP_REGION_STRUCT_SIZE
, mmap_page_size
);
4650 p
= mmap (NULL
, map
, PROT_READ
| PROT_WRITE
, MAP_ANON
| MAP_PRIVATE
,
4653 if (p
== MAP_FAILED
)
4655 if (errno
!= ENOMEM
)
4656 fprintf (stderr
, "mmap: %s\n", emacs_strerror (errno
));
4661 struct mmap_region
*r
= (struct mmap_region
*) p
;
4663 r
->nbytes_specified
= nbytes
;
4664 r
->nbytes_mapped
= map
;
4667 r
->next
= mmap_regions
;
4672 p
= MMAP_USER_AREA (p
);
4679 /* Given a pointer at address VAR to data allocated with mmap_alloc,
4680 resize it to size NBYTES. Change *VAR to reflect the new block,
4681 and return this value. If more memory cannot be allocated, then
4682 leave *VAR unchanged, and return null. */
4684 static POINTER_TYPE
*
4685 mmap_realloc (var
, nbytes
)
4689 POINTER_TYPE
*result
;
4694 result
= mmap_alloc (var
, nbytes
);
4695 else if (nbytes
== 0)
4698 result
= mmap_alloc (var
, nbytes
);
4702 struct mmap_region
*r
= MMAP_REGION (*var
);
4703 size_t room
= r
->nbytes_mapped
- MMAP_REGION_STRUCT_SIZE
;
4708 POINTER_TYPE
*old_ptr
= *var
;
4710 /* Try to map additional pages at the end of the region.
4711 If that fails, allocate a new region, copy data
4712 from the old region, then free it. */
4713 if (mmap_enlarge (r
, (ROUND (nbytes
- room
, mmap_page_size
)
4716 r
->nbytes_specified
= nbytes
;
4717 *var
= result
= old_ptr
;
4719 else if (mmap_alloc (var
, nbytes
))
4721 bcopy (old_ptr
, *var
, r
->nbytes_specified
);
4722 mmap_free_1 (MMAP_REGION (old_ptr
));
4724 r
= MMAP_REGION (result
);
4725 r
->nbytes_specified
= nbytes
;
4733 else if (room
- nbytes
>= mmap_page_size
)
4735 /* Shrinking by at least a page. Let's give some
4736 memory back to the system.
4738 The extra parens are to make the division happens first,
4739 on positive values, so we know it will round towards
4741 mmap_enlarge (r
, - ((room
- nbytes
) / mmap_page_size
));
4743 r
->nbytes_specified
= nbytes
;
4747 /* Leave it alone. */
4749 r
->nbytes_specified
= nbytes
;
4757 /* Free a block of relocatable storage whose data is pointed to by
4758 PTR. Store 0 in *PTR to show there's no block allocated. */
4768 mmap_free_1 (MMAP_REGION (*var
));
4774 /* Perform necessary intializations for the use of mmap. */
4780 /* The value of mmap_fd is initially 0 in temacs, and -1
4781 in a dumped Emacs. */
4784 /* No anonymous mmap -- we need the file descriptor. */
4785 mmap_fd
= open ("/dev/zero", O_RDONLY
);
4787 fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno
));
4789 #endif /* MAP_ANON == 0 */
4791 if (mmap_initialized_p
)
4793 mmap_initialized_p
= 1;
4799 mmap_page_size
= getpagesize ();
4802 #endif /* USE_MMAP_FOR_BUFFERS */
4806 /***********************************************************************
4807 Buffer-text Allocation
4808 ***********************************************************************/
4811 extern POINTER_TYPE
*r_alloc
P_ ((POINTER_TYPE
**, size_t));
4812 extern POINTER_TYPE
*r_re_alloc
P_ ((POINTER_TYPE
**, size_t));
4813 extern void r_alloc_free
P_ ((POINTER_TYPE
**ptr
));
4814 #endif /* REL_ALLOC */
4817 /* Allocate NBYTES bytes for buffer B's text buffer. */
4820 alloc_buffer_text (b
, nbytes
)
4827 #if defined USE_MMAP_FOR_BUFFERS
4828 p
= mmap_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4829 #elif defined REL_ALLOC
4830 p
= r_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4832 p
= xmalloc (nbytes
);
4841 b
->text
->beg
= (unsigned char *) p
;
4845 /* Enlarge buffer B's text buffer by DELTA bytes. DELTA < 0 means
4849 enlarge_buffer_text (b
, delta
)
4854 size_t nbytes
= (BUF_Z_BYTE (b
) - BUF_BEG_BYTE (b
) + BUF_GAP_SIZE (b
) + 1
4857 #if defined USE_MMAP_FOR_BUFFERS
4858 p
= mmap_realloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4859 #elif defined REL_ALLOC
4860 p
= r_re_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4862 p
= xrealloc (b
->text
->beg
, nbytes
);
4871 BUF_BEG_ADDR (b
) = (unsigned char *) p
;
4876 /* Free buffer B's text buffer. */
4879 free_buffer_text (b
)
4884 #if defined USE_MMAP_FOR_BUFFERS
4885 mmap_free ((POINTER_TYPE
**) &b
->text
->beg
);
4886 #elif defined REL_ALLOC
4887 r_alloc_free ((POINTER_TYPE
**) &b
->text
->beg
);
4889 xfree (b
->text
->beg
);
4892 BUF_BEG_ADDR (b
) = NULL
;
4898 /***********************************************************************
4900 ***********************************************************************/
4907 bzero (buffer_permanent_local_flags
, sizeof buffer_permanent_local_flags
);
4909 /* Make sure all markable slots in buffer_defaults
4910 are initialized reasonably, so mark_buffer won't choke. */
4911 reset_buffer (&buffer_defaults
);
4912 reset_buffer_local_variables (&buffer_defaults
, 1);
4913 reset_buffer (&buffer_local_symbols
);
4914 reset_buffer_local_variables (&buffer_local_symbols
, 1);
4915 /* Prevent GC from getting confused. */
4916 buffer_defaults
.text
= &buffer_defaults
.own_text
;
4917 buffer_local_symbols
.text
= &buffer_local_symbols
.own_text
;
4918 BUF_INTERVALS (&buffer_defaults
) = 0;
4919 BUF_INTERVALS (&buffer_local_symbols
) = 0;
4920 XSETBUFFER (Vbuffer_defaults
, &buffer_defaults
);
4921 XSETBUFFER (Vbuffer_local_symbols
, &buffer_local_symbols
);
4923 /* Set up the default values of various buffer slots. */
4924 /* Must do these before making the first buffer! */
4926 /* real setup is done in bindings.el */
4927 buffer_defaults
.mode_line_format
= build_string ("%-");
4928 buffer_defaults
.header_line_format
= Qnil
;
4929 buffer_defaults
.abbrev_mode
= Qnil
;
4930 buffer_defaults
.overwrite_mode
= Qnil
;
4931 buffer_defaults
.case_fold_search
= Qt
;
4932 buffer_defaults
.auto_fill_function
= Qnil
;
4933 buffer_defaults
.selective_display
= Qnil
;
4935 buffer_defaults
.selective_display_ellipses
= Qt
;
4937 buffer_defaults
.abbrev_table
= Qnil
;
4938 buffer_defaults
.display_table
= Qnil
;
4939 buffer_defaults
.undo_list
= Qnil
;
4940 buffer_defaults
.mark_active
= Qnil
;
4941 buffer_defaults
.file_format
= Qnil
;
4942 buffer_defaults
.overlays_before
= NULL
;
4943 buffer_defaults
.overlays_after
= NULL
;
4944 buffer_defaults
.overlay_center
= BEG
;
4946 XSETFASTINT (buffer_defaults
.tab_width
, 8);
4947 buffer_defaults
.truncate_lines
= Qnil
;
4948 buffer_defaults
.ctl_arrow
= Qt
;
4949 buffer_defaults
.direction_reversed
= Qnil
;
4950 buffer_defaults
.cursor_type
= Qt
;
4951 buffer_defaults
.extra_line_spacing
= Qnil
;
4954 buffer_defaults
.buffer_file_type
= Qnil
; /* TEXT */
4956 buffer_defaults
.enable_multibyte_characters
= Qt
;
4957 buffer_defaults
.buffer_file_coding_system
= Qnil
;
4958 XSETFASTINT (buffer_defaults
.fill_column
, 70);
4959 XSETFASTINT (buffer_defaults
.left_margin
, 0);
4960 buffer_defaults
.cache_long_line_scans
= Qnil
;
4961 buffer_defaults
.file_truename
= Qnil
;
4962 XSETFASTINT (buffer_defaults
.display_count
, 0);
4963 XSETFASTINT (buffer_defaults
.left_margin_cols
, 0);
4964 XSETFASTINT (buffer_defaults
.right_margin_cols
, 0);
4965 buffer_defaults
.left_fringe_width
= Qnil
;
4966 buffer_defaults
.right_fringe_width
= Qnil
;
4967 buffer_defaults
.fringes_outside_margins
= Qnil
;
4968 buffer_defaults
.scroll_bar_width
= Qnil
;
4969 buffer_defaults
.vertical_scroll_bar_type
= Qt
;
4970 buffer_defaults
.indicate_empty_lines
= Qnil
;
4971 buffer_defaults
.indicate_buffer_boundaries
= Qnil
;
4972 buffer_defaults
.scroll_up_aggressively
= Qnil
;
4973 buffer_defaults
.scroll_down_aggressively
= Qnil
;
4974 buffer_defaults
.display_time
= Qnil
;
4976 /* Assign the local-flags to the slots that have default values.
4977 The local flag is a bit that is used in the buffer
4978 to say that it has its own local value for the slot.
4979 The local flag bits are in the local_var_flags slot of the buffer. */
4981 /* Nothing can work if this isn't true */
4982 if (sizeof (EMACS_INT
) != sizeof (Lisp_Object
)) abort ();
4984 /* 0 means not a lisp var, -1 means always local, else mask */
4985 bzero (&buffer_local_flags
, sizeof buffer_local_flags
);
4986 XSETINT (buffer_local_flags
.filename
, -1);
4987 XSETINT (buffer_local_flags
.directory
, -1);
4988 XSETINT (buffer_local_flags
.backed_up
, -1);
4989 XSETINT (buffer_local_flags
.save_length
, -1);
4990 XSETINT (buffer_local_flags
.auto_save_file_name
, -1);
4991 XSETINT (buffer_local_flags
.read_only
, -1);
4992 XSETINT (buffer_local_flags
.major_mode
, -1);
4993 XSETINT (buffer_local_flags
.mode_name
, -1);
4994 XSETINT (buffer_local_flags
.undo_list
, -1);
4995 XSETINT (buffer_local_flags
.mark_active
, -1);
4996 XSETINT (buffer_local_flags
.point_before_scroll
, -1);
4997 XSETINT (buffer_local_flags
.file_truename
, -1);
4998 XSETINT (buffer_local_flags
.invisibility_spec
, -1);
4999 XSETINT (buffer_local_flags
.file_format
, -1);
5000 XSETINT (buffer_local_flags
.display_count
, -1);
5001 XSETINT (buffer_local_flags
.display_time
, -1);
5002 XSETINT (buffer_local_flags
.enable_multibyte_characters
, -1);
5005 XSETFASTINT (buffer_local_flags
.mode_line_format
, idx
); ++idx
;
5006 XSETFASTINT (buffer_local_flags
.abbrev_mode
, idx
); ++idx
;
5007 XSETFASTINT (buffer_local_flags
.overwrite_mode
, idx
); ++idx
;
5008 XSETFASTINT (buffer_local_flags
.case_fold_search
, idx
); ++idx
;
5009 XSETFASTINT (buffer_local_flags
.auto_fill_function
, idx
); ++idx
;
5010 XSETFASTINT (buffer_local_flags
.selective_display
, idx
); ++idx
;
5012 XSETFASTINT (buffer_local_flags
.selective_display_ellipses
, idx
); ++idx
;
5014 XSETFASTINT (buffer_local_flags
.tab_width
, idx
); ++idx
;
5015 XSETFASTINT (buffer_local_flags
.truncate_lines
, idx
); ++idx
;
5016 XSETFASTINT (buffer_local_flags
.ctl_arrow
, idx
); ++idx
;
5017 XSETFASTINT (buffer_local_flags
.fill_column
, idx
); ++idx
;
5018 XSETFASTINT (buffer_local_flags
.left_margin
, idx
); ++idx
;
5019 XSETFASTINT (buffer_local_flags
.abbrev_table
, idx
); ++idx
;
5020 XSETFASTINT (buffer_local_flags
.display_table
, idx
); ++idx
;
5022 XSETFASTINT (buffer_local_flags
.buffer_file_type
, idx
);
5023 /* Make this one a permanent local. */
5024 buffer_permanent_local_flags
[idx
++] = 1;
5026 XSETFASTINT (buffer_local_flags
.syntax_table
, idx
); ++idx
;
5027 XSETFASTINT (buffer_local_flags
.cache_long_line_scans
, idx
); ++idx
;
5028 XSETFASTINT (buffer_local_flags
.category_table
, idx
); ++idx
;
5029 XSETFASTINT (buffer_local_flags
.direction_reversed
, idx
); ++idx
;
5030 XSETFASTINT (buffer_local_flags
.buffer_file_coding_system
, idx
);
5031 /* Make this one a permanent local. */
5032 buffer_permanent_local_flags
[idx
++] = 1;
5033 XSETFASTINT (buffer_local_flags
.left_margin_cols
, idx
); ++idx
;
5034 XSETFASTINT (buffer_local_flags
.right_margin_cols
, idx
); ++idx
;
5035 XSETFASTINT (buffer_local_flags
.left_fringe_width
, idx
); ++idx
;
5036 XSETFASTINT (buffer_local_flags
.right_fringe_width
, idx
); ++idx
;
5037 XSETFASTINT (buffer_local_flags
.fringes_outside_margins
, idx
); ++idx
;
5038 XSETFASTINT (buffer_local_flags
.scroll_bar_width
, idx
); ++idx
;
5039 XSETFASTINT (buffer_local_flags
.vertical_scroll_bar_type
, idx
); ++idx
;
5040 XSETFASTINT (buffer_local_flags
.indicate_empty_lines
, idx
); ++idx
;
5041 XSETFASTINT (buffer_local_flags
.indicate_buffer_boundaries
, idx
); ++idx
;
5042 XSETFASTINT (buffer_local_flags
.scroll_up_aggressively
, idx
); ++idx
;
5043 XSETFASTINT (buffer_local_flags
.scroll_down_aggressively
, idx
); ++idx
;
5044 XSETFASTINT (buffer_local_flags
.header_line_format
, idx
); ++idx
;
5045 XSETFASTINT (buffer_local_flags
.cursor_type
, idx
); ++idx
;
5046 XSETFASTINT (buffer_local_flags
.extra_line_spacing
, idx
); ++idx
;
5048 /* Need more room? */
5049 if (idx
>= MAX_PER_BUFFER_VARS
)
5051 last_per_buffer_idx
= idx
;
5053 Vbuffer_alist
= Qnil
;
5057 QSFundamental
= build_string ("Fundamental");
5059 Qfundamental_mode
= intern ("fundamental-mode");
5060 buffer_defaults
.major_mode
= Qfundamental_mode
;
5062 Qmode_class
= intern ("mode-class");
5064 Qprotected_field
= intern ("protected-field");
5066 Qpermanent_local
= intern ("permanent-local");
5068 Qkill_buffer_hook
= intern ("kill-buffer-hook");
5069 Fput (Qkill_buffer_hook
, Qpermanent_local
, Qt
);
5071 Qucs_set_table_for_input
= intern ("ucs-set-table-for-input");
5073 Vprin1_to_string_buffer
= Fget_buffer_create (build_string (" prin1"));
5075 /* super-magic invisible buffer */
5076 Vbuffer_alist
= Qnil
;
5078 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
5080 inhibit_modification_hooks
= 0;
5086 char buf
[MAXPATHLEN
+ 1];
5088 struct stat dotstat
, pwdstat
;
5092 #ifdef USE_MMAP_FOR_BUFFERS
5094 /* When using the ralloc implementation based on mmap(2), buffer
5095 text pointers will have been set to null in the dumped Emacs.
5099 for (b
= all_buffers
; b
; b
= b
->next
)
5100 if (b
->text
->beg
== NULL
)
5101 enlarge_buffer_text (b
, 0);
5103 #endif /* USE_MMAP_FOR_BUFFERS */
5105 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
5106 if (NILP (buffer_defaults
.enable_multibyte_characters
))
5107 Fset_buffer_multibyte (Qnil
);
5109 /* If PWD is accurate, use it instead of calling getwd. PWD is
5110 sometimes a nicer name, and using it may avoid a fatal error if a
5111 parent directory is searchable but not readable. */
5112 if ((pwd
= getenv ("PWD")) != 0
5113 && (IS_DIRECTORY_SEP (*pwd
) || (*pwd
&& IS_DEVICE_SEP (pwd
[1])))
5114 && stat (pwd
, &pwdstat
) == 0
5115 && stat (".", &dotstat
) == 0
5116 && dotstat
.st_ino
== pwdstat
.st_ino
5117 && dotstat
.st_dev
== pwdstat
.st_dev
5118 && strlen (pwd
) < MAXPATHLEN
)
5121 else if (getcwd (buf
, MAXPATHLEN
+1) == 0)
5122 fatal ("`getcwd' failed: %s\n", strerror (errno
));
5124 else if (getwd (buf
) == 0)
5125 fatal ("`getwd' failed: %s\n", buf
);
5129 /* Maybe this should really use some standard subroutine
5130 whose definition is filename syntax dependent. */
5132 if (!(IS_DIRECTORY_SEP (buf
[rc
- 1])))
5134 buf
[rc
] = DIRECTORY_SEP
;
5137 #endif /* not VMS */
5139 current_buffer
->directory
= build_string (buf
);
5141 /* Add /: to the front of the name
5142 if it would otherwise be treated as magic. */
5143 temp
= Ffind_file_name_handler (current_buffer
->directory
, Qt
);
5145 /* If the default dir is just /, TEMP is non-nil
5146 because of the ange-ftp completion handler.
5147 However, it is not necessary to turn / into /:/.
5148 So avoid doing that. */
5149 && strcmp ("/", SDATA (current_buffer
->directory
)))
5150 current_buffer
->directory
5151 = concat2 (build_string ("/:"), current_buffer
->directory
);
5153 temp
= get_minibuffer (0);
5154 XBUFFER (temp
)->directory
= current_buffer
->directory
;
5157 /* initialize the buffer routines */
5161 staticpro (&last_overlay_modification_hooks
);
5162 last_overlay_modification_hooks
5163 = Fmake_vector (make_number (10), Qnil
);
5165 staticpro (&Vbuffer_defaults
);
5166 staticpro (&Vbuffer_local_symbols
);
5167 staticpro (&Qfundamental_mode
);
5168 staticpro (&Qmode_class
);
5169 staticpro (&QSFundamental
);
5170 staticpro (&Vbuffer_alist
);
5171 staticpro (&Qprotected_field
);
5172 staticpro (&Qpermanent_local
);
5173 staticpro (&Qkill_buffer_hook
);
5174 Qoverlayp
= intern ("overlayp");
5175 staticpro (&Qoverlayp
);
5176 Qevaporate
= intern ("evaporate");
5177 staticpro (&Qevaporate
);
5178 Qmodification_hooks
= intern ("modification-hooks");
5179 staticpro (&Qmodification_hooks
);
5180 Qinsert_in_front_hooks
= intern ("insert-in-front-hooks");
5181 staticpro (&Qinsert_in_front_hooks
);
5182 Qinsert_behind_hooks
= intern ("insert-behind-hooks");
5183 staticpro (&Qinsert_behind_hooks
);
5184 Qget_file_buffer
= intern ("get-file-buffer");
5185 staticpro (&Qget_file_buffer
);
5186 Qpriority
= intern ("priority");
5187 staticpro (&Qpriority
);
5188 Qwindow
= intern ("window");
5189 staticpro (&Qwindow
);
5190 Qbefore_string
= intern ("before-string");
5191 staticpro (&Qbefore_string
);
5192 Qafter_string
= intern ("after-string");
5193 staticpro (&Qafter_string
);
5194 Qfirst_change_hook
= intern ("first-change-hook");
5195 staticpro (&Qfirst_change_hook
);
5196 Qbefore_change_functions
= intern ("before-change-functions");
5197 staticpro (&Qbefore_change_functions
);
5198 Qafter_change_functions
= intern ("after-change-functions");
5199 staticpro (&Qafter_change_functions
);
5200 staticpro (&Qucs_set_table_for_input
);
5202 Qkill_buffer_query_functions
= intern ("kill-buffer-query-functions");
5203 staticpro (&Qkill_buffer_query_functions
);
5205 Fput (Qprotected_field
, Qerror_conditions
,
5206 Fcons (Qprotected_field
, Fcons (Qerror
, Qnil
)));
5207 Fput (Qprotected_field
, Qerror_message
,
5208 build_string ("Attempt to modify a protected field"));
5210 /* All these use DEFVAR_LISP_NOPRO because the slots in
5211 buffer_defaults will all be marked via Vbuffer_defaults. */
5213 DEFVAR_LISP_NOPRO ("default-mode-line-format",
5214 &buffer_defaults
.mode_line_format
,
5215 doc
: /* Default value of `mode-line-format' for buffers that don't override it.
5216 This is the same as (default-value 'mode-line-format). */);
5218 DEFVAR_LISP_NOPRO ("default-header-line-format",
5219 &buffer_defaults
.header_line_format
,
5220 doc
: /* Default value of `header-line-format' for buffers that don't override it.
5221 This is the same as (default-value 'header-line-format). */);
5223 DEFVAR_LISP_NOPRO ("default-cursor-type", &buffer_defaults
.cursor_type
,
5224 doc
: /* Default value of `cursor-type' for buffers that don't override it.
5225 This is the same as (default-value 'cursor-type). */);
5227 DEFVAR_LISP_NOPRO ("default-line-spacing",
5228 &buffer_defaults
.extra_line_spacing
,
5229 doc
: /* Default value of `line-spacing' for buffers that don't override it.
5230 This is the same as (default-value 'line-spacing). */);
5232 DEFVAR_LISP_NOPRO ("default-abbrev-mode",
5233 &buffer_defaults
.abbrev_mode
,
5234 doc
: /* Default value of `abbrev-mode' for buffers that do not override it.
5235 This is the same as (default-value 'abbrev-mode). */);
5237 DEFVAR_LISP_NOPRO ("default-ctl-arrow",
5238 &buffer_defaults
.ctl_arrow
,
5239 doc
: /* Default value of `ctl-arrow' for buffers that do not override it.
5240 This is the same as (default-value 'ctl-arrow). */);
5242 DEFVAR_LISP_NOPRO ("default-direction-reversed",
5243 &buffer_defaults
.direction_reversed
,
5244 doc
: /* Default value of `direction-reversed' for buffers that do not override it.
5245 This is the same as (default-value 'direction-reversed). */);
5247 DEFVAR_LISP_NOPRO ("default-enable-multibyte-characters",
5248 &buffer_defaults
.enable_multibyte_characters
,
5249 doc
: /* *Default value of `enable-multibyte-characters' for buffers not overriding it.
5250 This is the same as (default-value 'enable-multibyte-characters). */);
5252 DEFVAR_LISP_NOPRO ("default-buffer-file-coding-system",
5253 &buffer_defaults
.buffer_file_coding_system
,
5254 doc
: /* Default value of `buffer-file-coding-system' for buffers not overriding it.
5255 This is the same as (default-value 'buffer-file-coding-system). */);
5257 DEFVAR_LISP_NOPRO ("default-truncate-lines",
5258 &buffer_defaults
.truncate_lines
,
5259 doc
: /* Default value of `truncate-lines' for buffers that do not override it.
5260 This is the same as (default-value 'truncate-lines). */);
5262 DEFVAR_LISP_NOPRO ("default-fill-column",
5263 &buffer_defaults
.fill_column
,
5264 doc
: /* Default value of `fill-column' for buffers that do not override it.
5265 This is the same as (default-value 'fill-column). */);
5267 DEFVAR_LISP_NOPRO ("default-left-margin",
5268 &buffer_defaults
.left_margin
,
5269 doc
: /* Default value of `left-margin' for buffers that do not override it.
5270 This is the same as (default-value 'left-margin). */);
5272 DEFVAR_LISP_NOPRO ("default-tab-width",
5273 &buffer_defaults
.tab_width
,
5274 doc
: /* Default value of `tab-width' for buffers that do not override it.
5275 This is the same as (default-value 'tab-width). */);
5277 DEFVAR_LISP_NOPRO ("default-case-fold-search",
5278 &buffer_defaults
.case_fold_search
,
5279 doc
: /* Default value of `case-fold-search' for buffers that don't override it.
5280 This is the same as (default-value 'case-fold-search). */);
5283 DEFVAR_LISP_NOPRO ("default-buffer-file-type",
5284 &buffer_defaults
.buffer_file_type
,
5285 doc
: /* Default file type for buffers that do not override it.
5286 This is the same as (default-value 'buffer-file-type).
5287 The file type is nil for text, t for binary. */);
5290 DEFVAR_LISP_NOPRO ("default-left-margin-width",
5291 &buffer_defaults
.left_margin_cols
,
5292 doc
: /* Default value of `left-margin-width' for buffers that don't override it.
5293 This is the same as (default-value 'left-margin-width). */);
5295 DEFVAR_LISP_NOPRO ("default-right-margin-width",
5296 &buffer_defaults
.right_margin_cols
,
5297 doc
: /* Default value of `right-margin-width' for buffers that don't override it.
5298 This is the same as (default-value 'right-margin-width). */);
5300 DEFVAR_LISP_NOPRO ("default-left-fringe-width",
5301 &buffer_defaults
.left_fringe_width
,
5302 doc
: /* Default value of `left-fringe-width' for buffers that don't override it.
5303 This is the same as (default-value 'left-fringe-width). */);
5305 DEFVAR_LISP_NOPRO ("default-right-fringe-width",
5306 &buffer_defaults
.right_fringe_width
,
5307 doc
: /* Default value of `right-fringe-width' for buffers that don't override it.
5308 This is the same as (default-value 'right-fringe-width). */);
5310 DEFVAR_LISP_NOPRO ("default-fringes-outside-margins",
5311 &buffer_defaults
.fringes_outside_margins
,
5312 doc
: /* Default value of `fringes-outside-margins' for buffers that don't override it.
5313 This is the same as (default-value 'fringes-outside-margins). */);
5315 DEFVAR_LISP_NOPRO ("default-scroll-bar-width",
5316 &buffer_defaults
.scroll_bar_width
,
5317 doc
: /* Default value of `scroll-bar-width' for buffers that don't override it.
5318 This is the same as (default-value 'scroll-bar-width). */);
5320 DEFVAR_LISP_NOPRO ("default-vertical-scroll-bar",
5321 &buffer_defaults
.vertical_scroll_bar_type
,
5322 doc
: /* Default value of `vertical-scroll-bar' for buffers that don't override it.
5323 This is the same as (default-value 'vertical-scroll-bar). */);
5325 DEFVAR_LISP_NOPRO ("default-indicate-empty-lines",
5326 &buffer_defaults
.indicate_empty_lines
,
5327 doc
: /* Default value of `indicate-empty-lines' for buffers that don't override it.
5328 This is the same as (default-value 'indicate-empty-lines). */);
5330 DEFVAR_LISP_NOPRO ("default-indicate-buffer-boundaries",
5331 &buffer_defaults
.indicate_buffer_boundaries
,
5332 doc
: /* Default value of `indicate-buffer-boundaries' for buffers that don't override it.
5333 This is the same as (default-value 'indicate-buffer-boundaries). */);
5335 DEFVAR_LISP_NOPRO ("default-scroll-up-aggressively",
5336 &buffer_defaults
.scroll_up_aggressively
,
5337 doc
: /* Default value of `scroll-up-aggressively'.
5338 This value applies in buffers that don't have their own local values.
5339 This variable is an alias for (default-value 'scroll-up-aggressively). */);
5341 DEFVAR_LISP_NOPRO ("default-scroll-down-aggressively",
5342 &buffer_defaults
.scroll_down_aggressively
,
5343 doc
: /* Default value of `scroll-down-aggressively'.
5344 This value applies in buffers that don't have their own local values.
5345 This variable is an alias for (default-value 'scroll-down-aggressively). */);
5347 DEFVAR_PER_BUFFER ("header-line-format",
5348 ¤t_buffer
->header_line_format
,
5350 doc
: /* Analogous to `mode-line-format', but controls the header line.
5351 The header line appears, optionally, at the top of a window;
5352 the mode line appears at the bottom. */);
5354 DEFVAR_PER_BUFFER ("mode-line-format", ¤t_buffer
->mode_line_format
,
5356 doc
: /* Template for displaying mode line for current buffer.
5357 Each buffer has its own value of this variable.
5358 Value may be nil, a string, a symbol or a list or cons cell.
5359 A value of nil means don't display a mode line.
5360 For a symbol, its value is used (but it is ignored if t or nil).
5361 A string appearing directly as the value of a symbol is processed verbatim
5362 in that the %-constructs below are not recognized.
5363 Note that unless the symbol is marked as a `risky-local-variable', all
5364 properties in any strings, as well as all :eval and :propertize forms
5365 in the value of that symbol will be ignored.
5366 For a list of the form `(:eval FORM)', FORM is evaluated and the result
5367 is used as a mode line element. Be careful--FORM should not load any files,
5368 because that can cause an infinite recursion.
5369 For a list of the form `(:propertize ELT PROPS...)', ELT is displayed
5370 with the specified properties PROPS applied.
5371 For a list whose car is a symbol, the symbol's value is taken,
5372 and if that is non-nil, the cadr of the list is processed recursively.
5373 Otherwise, the caddr of the list (if there is one) is processed.
5374 For a list whose car is a string or list, each element is processed
5375 recursively and the results are effectively concatenated.
5376 For a list whose car is an integer, the cdr of the list is processed
5377 and padded (if the number is positive) or truncated (if negative)
5378 to the width specified by that number.
5379 A string is printed verbatim in the mode line except for %-constructs:
5380 (%-constructs are allowed when the string is the entire mode-line-format
5381 or when it is found in a cons-cell or a list)
5382 %b -- print buffer name. %f -- print visited file name.
5383 %F -- print frame name.
5384 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
5385 %& is like %*, but ignore read-only-ness.
5386 % means buffer is read-only and * means it is modified.
5387 For a modified read-only buffer, %* gives % and %+ gives *.
5388 %s -- print process status. %l -- print the current line number.
5389 %c -- print the current column number (this makes editing slower).
5390 To make the column number update correctly in all cases,
5391 `column-number-mode' must be non-nil.
5392 %i -- print the size of the buffer.
5393 %I -- like %i, but use k, M, G, etc., to abbreviate.
5394 %p -- print percent of buffer above top of window, or Top, Bot or All.
5395 %P -- print percent of buffer above bottom of window, perhaps plus Top,
5396 or print Bottom or All.
5397 %m -- print the mode name.
5398 %n -- print Narrow if appropriate.
5399 %z -- print mnemonics of buffer, terminal, and keyboard coding systems.
5400 %Z -- like %z, but including the end-of-line format.
5401 %[ -- print one [ for each recursive editing level. %] similar.
5402 %% -- print %. %- -- print infinitely many dashes.
5403 Decimal digits after the % specify field width to which to pad. */);
5405 DEFVAR_LISP_NOPRO ("default-major-mode", &buffer_defaults
.major_mode
,
5406 doc
: /* *Major mode for new buffers. Defaults to `fundamental-mode'.
5407 nil here means use current buffer's major mode. */);
5409 DEFVAR_PER_BUFFER ("major-mode", ¤t_buffer
->major_mode
,
5410 make_number (Lisp_Symbol
),
5411 doc
: /* Symbol for current buffer's major mode. */);
5413 DEFVAR_PER_BUFFER ("mode-name", ¤t_buffer
->mode_name
,
5415 doc
: /* Pretty name of current buffer's major mode (a string). */);
5417 DEFVAR_PER_BUFFER ("abbrev-mode", ¤t_buffer
->abbrev_mode
, Qnil
,
5418 doc
: /* Non-nil turns on automatic expansion of abbrevs as they are inserted. */);
5420 DEFVAR_PER_BUFFER ("case-fold-search", ¤t_buffer
->case_fold_search
,
5422 doc
: /* *Non-nil if searches and matches should ignore case. */);
5424 DEFVAR_PER_BUFFER ("fill-column", ¤t_buffer
->fill_column
,
5425 make_number (Lisp_Int
),
5426 doc
: /* *Column beyond which automatic line-wrapping should happen.
5427 Interactively, you can set this using \\[set-fill-column]. */);
5429 DEFVAR_PER_BUFFER ("left-margin", ¤t_buffer
->left_margin
,
5430 make_number (Lisp_Int
),
5431 doc
: /* *Column for the default indent-line-function to indent to.
5432 Linefeed indents to this column in Fundamental mode. */);
5434 DEFVAR_PER_BUFFER ("tab-width", ¤t_buffer
->tab_width
,
5435 make_number (Lisp_Int
),
5436 doc
: /* *Distance between tab stops (for display of tab characters), in columns. */);
5438 DEFVAR_PER_BUFFER ("ctl-arrow", ¤t_buffer
->ctl_arrow
, Qnil
,
5439 doc
: /* *Non-nil means display control chars with uparrow.
5440 A value of nil means use backslash and octal digits.
5441 This variable does not apply to characters whose display is specified
5442 in the current display table (if there is one). */);
5444 DEFVAR_PER_BUFFER ("enable-multibyte-characters",
5445 ¤t_buffer
->enable_multibyte_characters
,
5447 doc
: /* Non-nil means the buffer contents are regarded as multi-byte characters.
5448 Otherwise they are regarded as unibyte. This affects the display,
5449 file I/O and the behavior of various editing commands.
5451 This variable is buffer-local but you cannot set it directly;
5452 use the function `set-buffer-multibyte' to change a buffer's representation.
5453 Changing its default value with `setq-default' is supported.
5454 See also variable `default-enable-multibyte-characters' and Info node
5455 `(elisp)Text Representations'. */);
5456 XSYMBOL (intern ("enable-multibyte-characters"))->constant
= 1;
5458 DEFVAR_PER_BUFFER ("buffer-file-coding-system",
5459 ¤t_buffer
->buffer_file_coding_system
, Qnil
,
5460 doc
: /* Coding system to be used for encoding the buffer contents on saving.
5461 This variable applies to saving the buffer, and also to `write-region'
5462 and other functions that use `write-region'.
5463 It does not apply to sending output to subprocesses, however.
5465 If this is nil, the buffer is saved without any code conversion
5466 unless some coding system is specified in `file-coding-system-alist'
5467 for the buffer file.
5469 If the text to be saved cannot be encoded as specified by this variable,
5470 an alternative encoding is selected by `select-safe-coding-system', which see.
5472 The variable `coding-system-for-write', if non-nil, overrides this variable.
5474 This variable is never applied to a way of decoding a file while reading it. */);
5476 DEFVAR_PER_BUFFER ("direction-reversed", ¤t_buffer
->direction_reversed
,
5478 doc
: /* *Non-nil means lines in the buffer are displayed right to left. */);
5480 DEFVAR_PER_BUFFER ("truncate-lines", ¤t_buffer
->truncate_lines
, Qnil
,
5481 doc
: /* *Non-nil means do not display continuation lines.
5482 Instead, give each line of text just one screen line.
5484 Note that this is overridden by the variable
5485 `truncate-partial-width-windows' if that variable is non-nil
5486 and this buffer is not full-frame width. */);
5489 DEFVAR_PER_BUFFER ("buffer-file-type", ¤t_buffer
->buffer_file_type
,
5491 doc
: /* Non-nil if the visited file is a binary file.
5492 This variable is meaningful on MS-DOG and Windows NT.
5493 On those systems, it is automatically local in every buffer.
5494 On other systems, this variable is normally always nil. */);
5497 DEFVAR_PER_BUFFER ("default-directory", ¤t_buffer
->directory
,
5498 make_number (Lisp_String
),
5499 doc
: /* Name of default directory of current buffer. Should end with slash.
5500 To interactively change the default directory, use command `cd'. */);
5502 DEFVAR_PER_BUFFER ("auto-fill-function", ¤t_buffer
->auto_fill_function
,
5504 doc
: /* Function called (if non-nil) to perform auto-fill.
5505 It is called after self-inserting any character specified in
5506 the `auto-fill-chars' table.
5507 NOTE: This variable is not a hook;
5508 its value may not be a list of functions. */);
5510 DEFVAR_PER_BUFFER ("buffer-file-name", ¤t_buffer
->filename
,
5511 make_number (Lisp_String
),
5512 doc
: /* Name of file visited in current buffer, or nil if not visiting a file. */);
5514 DEFVAR_PER_BUFFER ("buffer-file-truename", ¤t_buffer
->file_truename
,
5515 make_number (Lisp_String
),
5516 doc
: /* Abbreviated truename of file visited in current buffer, or nil if none.
5517 The truename of a file is calculated by `file-truename'
5518 and then abbreviated with `abbreviate-file-name'. */);
5520 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
5521 ¤t_buffer
->auto_save_file_name
,
5522 make_number (Lisp_String
),
5523 doc
: /* Name of file for auto-saving current buffer.
5524 If it is nil, that means don't auto-save this buffer. */);
5526 DEFVAR_PER_BUFFER ("buffer-read-only", ¤t_buffer
->read_only
, Qnil
,
5527 doc
: /* Non-nil if this buffer is read-only. */);
5529 DEFVAR_PER_BUFFER ("buffer-backed-up", ¤t_buffer
->backed_up
, Qnil
,
5530 doc
: /* Non-nil if this buffer's file has been backed up.
5531 Backing up is done before the first time the file is saved. */);
5533 DEFVAR_PER_BUFFER ("buffer-saved-size", ¤t_buffer
->save_length
,
5534 make_number (Lisp_Int
),
5535 doc
: /* Length of current buffer when last read in, saved or auto-saved.
5538 DEFVAR_PER_BUFFER ("selective-display", ¤t_buffer
->selective_display
,
5540 doc
: /* Non-nil enables selective display.
5541 An Integer N as value means display only lines
5542 that start with less than n columns of space.
5543 A value of t means that the character ^M makes itself and
5544 all the rest of the line invisible; also, when saving the buffer
5545 in a file, save the ^M as a newline. */);
5548 DEFVAR_PER_BUFFER ("selective-display-ellipses",
5549 ¤t_buffer
->selective_display_ellipses
,
5551 doc
: /* Non-nil means display ... on previous line when a line is invisible. */);
5554 DEFVAR_PER_BUFFER ("overwrite-mode", ¤t_buffer
->overwrite_mode
, Qnil
,
5555 doc
: /* Non-nil if self-insertion should replace existing text.
5556 The value should be one of `overwrite-mode-textual',
5557 `overwrite-mode-binary', or nil.
5558 If it is `overwrite-mode-textual', self-insertion still
5559 inserts at the end of a line, and inserts when point is before a tab,
5560 until the tab is filled in.
5561 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too. */);
5563 DEFVAR_PER_BUFFER ("buffer-display-table", ¤t_buffer
->display_table
,
5565 doc
: /* Display table that controls display of the contents of current buffer.
5567 If this variable is nil, the value of `standard-display-table' is used.
5568 Each window can have its own, overriding display table, see
5569 `set-window-display-table' and `window-display-table'.
5571 The display table is a char-table created with `make-display-table'.
5572 A char-table is an array indexed by character codes. Normal array
5573 primitives `aref' and `aset' can be used to access elements of a char-table.
5575 Each of the char-table elements control how to display the corresponding
5576 text character: the element at index C in the table says how to display
5577 the character whose code is C. Each element should be a vector of
5578 characters or nil. nil means display the character in the default fashion;
5579 otherwise, the characters from the vector are delivered to the screen
5580 instead of the original character.
5582 For example, (aset buffer-display-table ?X ?Y) will cause Emacs to display
5583 a capital Y instead of each X character.
5585 In addition, a char-table has six extra slots to control the display of:
5587 the end of a truncated screen line (extra-slot 0, a single character);
5588 the end of a continued line (extra-slot 1, a single character);
5589 the escape character used to display character codes in octal
5590 (extra-slot 2, a single character);
5591 the character used as an arrow for control characters (extra-slot 3,
5592 a single character);
5593 the decoration indicating the presence of invisible lines (extra-slot 4,
5594 a vector of characters);
5595 the character used to draw the border between side-by-side windows
5596 (extra-slot 5, a single character).
5598 See also the functions `display-table-slot' and `set-display-table-slot'. */);
5600 DEFVAR_PER_BUFFER ("left-margin-width", ¤t_buffer
->left_margin_cols
,
5602 doc
: /* *Width of left marginal area for display of a buffer.
5603 A value of nil means no marginal area. */);
5605 DEFVAR_PER_BUFFER ("right-margin-width", ¤t_buffer
->right_margin_cols
,
5607 doc
: /* *Width of right marginal area for display of a buffer.
5608 A value of nil means no marginal area. */);
5610 DEFVAR_PER_BUFFER ("left-fringe-width", ¤t_buffer
->left_fringe_width
,
5612 doc
: /* *Width of this buffer's left fringe (in pixels).
5613 A value of 0 means no left fringe is shown in this buffer's window.
5614 A value of nil means to use the left fringe width from the window's frame. */);
5616 DEFVAR_PER_BUFFER ("right-fringe-width", ¤t_buffer
->right_fringe_width
,
5618 doc
: /* *Width of this buffer's right fringe (in pixels).
5619 A value of 0 means no right fringe is shown in this buffer's window.
5620 A value of nil means to use the right fringe width from the window's frame. */);
5622 DEFVAR_PER_BUFFER ("fringes-outside-margins", ¤t_buffer
->fringes_outside_margins
,
5624 doc
: /* *Non-nil means to display fringes outside display margins.
5625 A value of nil means to display fringes between margins and buffer text. */);
5627 DEFVAR_PER_BUFFER ("scroll-bar-width", ¤t_buffer
->scroll_bar_width
,
5629 doc
: /* *Width of this buffer's scroll bars in pixels.
5630 A value of nil means to use the scroll bar width from the window's frame. */);
5632 DEFVAR_PER_BUFFER ("vertical-scroll-bar", ¤t_buffer
->vertical_scroll_bar_type
,
5634 doc
: /* *Position of this buffer's vertical scroll bar.
5635 A value of left or right means to place the vertical scroll bar at that side
5636 of the window; a value of nil means that this window has no vertical scroll bar.
5637 A value of t means to use the vertical scroll bar type from the window's frame. */);
5639 DEFVAR_PER_BUFFER ("indicate-empty-lines",
5640 ¤t_buffer
->indicate_empty_lines
, Qnil
,
5641 doc
: /* *Visually indicate empty lines after the buffer end.
5642 If non-nil, a bitmap is displayed in the left fringe of a window on
5643 window-systems. */);
5645 DEFVAR_PER_BUFFER ("indicate-buffer-boundaries",
5646 ¤t_buffer
->indicate_buffer_boundaries
, Qnil
,
5647 doc
: /* *Visually indicate buffer boundaries and scrolling.
5648 If non-nil, the first and last line of the buffer are marked in the fringe
5649 of a window on window-systems with angle bitmaps, or if the window can be
5650 scrolled, the top and bottom line of the window are marked with up and down
5652 If value is `left' or `right', both angle and arrow bitmaps are displayed in
5653 the left or right fringe, resp. Any other non-nil value causes the
5654 bitmap on the top line to be displayed in the left fringe, and the
5655 bitmap on the bottom line in the right fringe.
5656 If value is a cons (ANGLES . ARROWS), the car specifies the position
5657 of the angle bitmaps, and the cdr specifies the position of the arrow
5658 bitmaps. For example, (t . right) places the top angle bitmap in left
5659 fringe, the bottom angle bitmap in right fringe, and both arrow
5660 bitmaps in right fringe. To show just the angle bitmaps in the left
5661 fringe, but no arrow bitmaps, use (left . nil). */);
5663 DEFVAR_PER_BUFFER ("scroll-up-aggressively",
5664 ¤t_buffer
->scroll_up_aggressively
, Qnil
,
5665 doc
: /* How far to scroll windows upward.
5666 If you move point off the bottom, the window scrolls automatically.
5667 This variable controls how far it scrolls. nil, the default,
5668 means scroll to center point. A fraction means scroll to put point
5669 that fraction of the window's height from the bottom of the window.
5670 When the value is 0.0, point goes at the bottom line, which in the simple
5671 case that you moved off with C-f means scrolling just one line. 1.0 means
5672 point goes at the top, so that in that simple case, the window
5673 window scrolls by a full window height. Meaningful values are
5674 between 0.0 and 1.0, inclusive. */);
5676 DEFVAR_PER_BUFFER ("scroll-down-aggressively",
5677 ¤t_buffer
->scroll_down_aggressively
, Qnil
,
5678 doc
: /* How far to scroll windows downward.
5679 If you move point off the top, the window scrolls automatically.
5680 This variable controls how far it scrolls. nil, the default,
5681 means scroll to center point. A fraction means scroll to put point
5682 that fraction of the window's height from the top of the window.
5683 When the value is 0.0, point goes at the top line, which in the simple
5684 case that you moved off with C-b means scrolling just one line. 1.0 means
5685 point goes at the bottom, so that in that simple case, the window
5686 window scrolls by a full window height. Meaningful values are
5687 between 0.0 and 1.0, inclusive. */);
5689 /*DEFVAR_LISP ("debug-check-symbol", &Vcheck_symbol,
5693 DEFVAR_LISP ("before-change-functions", &Vbefore_change_functions
,
5694 doc
: /* List of functions to call before each text change.
5695 Two arguments are passed to each function: the positions of
5696 the beginning and end of the range of old text to be changed.
5697 \(For an insertion, the beginning and end are at the same place.)
5698 No information is given about the length of the text after the change.
5700 Buffer changes made while executing the `before-change-functions'
5701 don't call any before-change or after-change functions.
5702 That's because these variables are temporarily set to nil.
5703 As a result, a hook function cannot straightforwardly alter the value of
5704 these variables. See the Emacs Lisp manual for a way of
5705 accomplishing an equivalent result by using other variables.
5707 If an unhandled error happens in running these functions,
5708 the variable's value remains nil. That prevents the error
5709 from happening repeatedly and making Emacs nonfunctional. */);
5710 Vbefore_change_functions
= Qnil
;
5712 DEFVAR_LISP ("after-change-functions", &Vafter_change_functions
,
5713 doc
: /* List of functions to call after each text change.
5714 Three arguments are passed to each function: the positions of
5715 the beginning and end of the range of changed text,
5716 and the length in bytes of the pre-change text replaced by that range.
5717 \(For an insertion, the pre-change length is zero;
5718 for a deletion, that length is the number of bytes deleted,
5719 and the post-change beginning and end are at the same place.)
5721 Buffer changes made while executing the `after-change-functions'
5722 don't call any before-change or after-change functions.
5723 That's because these variables are temporarily set to nil.
5724 As a result, a hook function cannot straightforwardly alter the value of
5725 these variables. See the Emacs Lisp manual for a way of
5726 accomplishing an equivalent result by using other variables.
5728 If an unhandled error happens in running these functions,
5729 the variable's value remains nil. That prevents the error
5730 from happening repeatedly and making Emacs nonfunctional. */);
5731 Vafter_change_functions
= Qnil
;
5733 DEFVAR_LISP ("first-change-hook", &Vfirst_change_hook
,
5734 doc
: /* A list of functions to call before changing a buffer which is unmodified.
5735 The functions are run using the `run-hooks' function. */);
5736 Vfirst_change_hook
= Qnil
;
5738 DEFVAR_PER_BUFFER ("buffer-undo-list", ¤t_buffer
->undo_list
, Qnil
,
5739 doc
: /* List of undo entries in current buffer.
5740 Recent changes come first; older changes follow newer.
5742 An entry (BEG . END) represents an insertion which begins at
5743 position BEG and ends at position END.
5745 An entry (TEXT . POSITION) represents the deletion of the string TEXT
5746 from (abs POSITION). If POSITION is positive, point was at the front
5747 of the text being deleted; if negative, point was at the end.
5749 An entry (t HIGH . LOW) indicates that the buffer previously had
5750 \"unmodified\" status. HIGH and LOW are the high and low 16-bit portions
5751 of the visited file's modification time, as of that time. If the
5752 modification time of the most recent save is different, this entry is
5755 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
5756 was modified between BEG and END. PROPERTY is the property name,
5757 and VALUE is the old value.
5759 An entry (MARKER . DISTANCE) indicates that the marker MARKER
5760 was adjusted in position by the offset DISTANCE (an integer).
5762 An entry of the form POSITION indicates that point was at the buffer
5763 location given by the integer. Undoing an entry of this form places
5766 nil marks undo boundaries. The undo command treats the changes
5767 between two undo boundaries as a single step to be undone.
5769 If the value of the variable is t, undo information is not recorded. */);
5771 DEFVAR_PER_BUFFER ("mark-active", ¤t_buffer
->mark_active
, Qnil
,
5772 doc
: /* Non-nil means the mark and region are currently active in this buffer. */);
5774 DEFVAR_PER_BUFFER ("cache-long-line-scans", ¤t_buffer
->cache_long_line_scans
, Qnil
,
5775 doc
: /* Non-nil means that Emacs should use caches to handle long lines more quickly.
5777 Normally, the line-motion functions work by scanning the buffer for
5778 newlines. Columnar operations (like move-to-column and
5779 compute-motion) also work by scanning the buffer, summing character
5780 widths as they go. This works well for ordinary text, but if the
5781 buffer's lines are very long (say, more than 500 characters), these
5782 motion functions will take longer to execute. Emacs may also take
5783 longer to update the display.
5785 If cache-long-line-scans is non-nil, these motion functions cache the
5786 results of their scans, and consult the cache to avoid rescanning
5787 regions of the buffer until the text is modified. The caches are most
5788 beneficial when they prevent the most searching---that is, when the
5789 buffer contains long lines and large regions of characters with the
5790 same, fixed screen width.
5792 When cache-long-line-scans is non-nil, processing short lines will
5793 become slightly slower (because of the overhead of consulting the
5794 cache), and the caches will use memory roughly proportional to the
5795 number of newlines and characters whose screen width varies.
5797 The caches require no explicit maintenance; their accuracy is
5798 maintained internally by the Emacs primitives. Enabling or disabling
5799 the cache should not affect the behavior of any of the motion
5800 functions; it should only affect their performance. */);
5802 DEFVAR_PER_BUFFER ("point-before-scroll", ¤t_buffer
->point_before_scroll
, Qnil
,
5803 doc
: /* Value of point before the last series of scroll operations, or nil. */);
5805 DEFVAR_PER_BUFFER ("buffer-file-format", ¤t_buffer
->file_format
, Qnil
,
5806 doc
: /* List of formats to use when saving this buffer.
5807 Formats are defined by `format-alist'. This variable is
5808 set when a file is visited. */);
5810 DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
5811 ¤t_buffer
->invisibility_spec
, Qnil
,
5812 doc
: /* Invisibility spec of this buffer.
5813 The default is t, which means that text is invisible
5814 if it has a non-nil `invisible' property.
5815 If the value is a list, a text character is invisible if its `invisible'
5816 property is an element in that list.
5817 If an element is a cons cell of the form (PROP . ELLIPSIS),
5818 then characters with property value PROP are invisible,
5819 and they have an ellipsis as well if ELLIPSIS is non-nil. */);
5821 DEFVAR_PER_BUFFER ("buffer-display-count",
5822 ¤t_buffer
->display_count
, Qnil
,
5823 doc
: /* A number incremented each time this buffer is displayed in a window.
5824 The function `set-window-buffer' increments it. */);
5826 DEFVAR_PER_BUFFER ("buffer-display-time",
5827 ¤t_buffer
->display_time
, Qnil
,
5828 doc
: /* Time stamp updated each time this buffer is displayed in a window.
5829 The function `set-window-buffer' updates this variable
5830 to the value obtained by calling `current-time'.
5831 If the buffer has never been shown in a window, the value is nil. */);
5833 DEFVAR_LISP ("transient-mark-mode", &Vtransient_mark_mode
,
5834 doc
: /* *Non-nil means deactivate the mark when the buffer contents change.
5835 Non-nil also enables highlighting of the region whenever the mark is active.
5836 The variable `highlight-nonselected-windows' controls whether to highlight
5837 all windows or just the selected window. */);
5838 Vtransient_mark_mode
= Qnil
;
5840 DEFVAR_LISP ("inhibit-read-only", &Vinhibit_read_only
,
5841 doc
: /* *Non-nil means disregard read-only status of buffers or characters.
5842 If the value is t, disregard `buffer-read-only' and all `read-only'
5843 text properties. If the value is a list, disregard `buffer-read-only'
5844 and disregard a `read-only' text property if the property value
5845 is a member of the list. */);
5846 Vinhibit_read_only
= Qnil
;
5848 DEFVAR_PER_BUFFER ("cursor-type", ¤t_buffer
->cursor_type
, Qnil
,
5849 doc
: /* Cursor to use when this buffer is in the selected window.
5850 Values are interpreted as follows:
5852 t use the cursor specified for the frame
5853 nil don't display a cursor
5854 bar display a bar cursor with default width
5855 (bar . WIDTH) display a bar cursor with width WIDTH
5856 ANYTHING ELSE display a box cursor.
5858 When the buffer is displayed in a nonselected window,
5859 this variable has no effect; the cursor appears as a hollow box. */);
5861 DEFVAR_PER_BUFFER ("line-spacing",
5862 ¤t_buffer
->extra_line_spacing
, Qnil
,
5863 doc
: /* Additional space to put between lines when displaying a buffer.
5864 The space is measured in pixels, and put below lines on window systems. */);
5866 DEFVAR_LISP ("kill-buffer-query-functions", &Vkill_buffer_query_functions
,
5867 doc
: /* List of functions called with no args to query before killing a buffer. */);
5868 Vkill_buffer_query_functions
= Qnil
;
5870 defsubr (&Sbuffer_live_p
);
5871 defsubr (&Sbuffer_list
);
5872 defsubr (&Sget_buffer
);
5873 defsubr (&Sget_file_buffer
);
5874 defsubr (&Sget_buffer_create
);
5875 defsubr (&Smake_indirect_buffer
);
5876 defsubr (&Sgenerate_new_buffer_name
);
5877 defsubr (&Sbuffer_name
);
5878 /*defsubr (&Sbuffer_number);*/
5879 defsubr (&Sbuffer_file_name
);
5880 defsubr (&Sbuffer_base_buffer
);
5881 defsubr (&Sbuffer_local_value
);
5882 defsubr (&Sbuffer_local_variables
);
5883 defsubr (&Sbuffer_modified_p
);
5884 defsubr (&Sset_buffer_modified_p
);
5885 defsubr (&Sbuffer_modified_tick
);
5886 defsubr (&Srename_buffer
);
5887 defsubr (&Sother_buffer
);
5888 defsubr (&Sbuffer_disable_undo
);
5889 defsubr (&Sbuffer_enable_undo
);
5890 defsubr (&Skill_buffer
);
5891 defsubr (&Sset_buffer_major_mode
);
5892 defsubr (&Sswitch_to_buffer
);
5893 defsubr (&Spop_to_buffer
);
5894 defsubr (&Scurrent_buffer
);
5895 defsubr (&Sset_buffer
);
5896 defsubr (&Sbarf_if_buffer_read_only
);
5897 defsubr (&Sbury_buffer
);
5898 defsubr (&Serase_buffer
);
5899 defsubr (&Sset_buffer_multibyte
);
5900 defsubr (&Skill_all_local_variables
);
5902 defsubr (&Soverlayp
);
5903 defsubr (&Smake_overlay
);
5904 defsubr (&Sdelete_overlay
);
5905 defsubr (&Smove_overlay
);
5906 defsubr (&Soverlay_start
);
5907 defsubr (&Soverlay_end
);
5908 defsubr (&Soverlay_buffer
);
5909 defsubr (&Soverlay_properties
);
5910 defsubr (&Soverlays_at
);
5911 defsubr (&Soverlays_in
);
5912 defsubr (&Snext_overlay_change
);
5913 defsubr (&Sprevious_overlay_change
);
5914 defsubr (&Soverlay_recenter
);
5915 defsubr (&Soverlay_lists
);
5916 defsubr (&Soverlay_get
);
5917 defsubr (&Soverlay_put
);
5918 defsubr (&Srestore_buffer_modified_p
);
5924 initial_define_key (control_x_map
, 'b', "switch-to-buffer");
5925 initial_define_key (control_x_map
, 'k', "kill-buffer");
5927 /* This must not be in syms_of_buffer, because Qdisabled is not
5928 initialized when that function gets called. */
5929 Fput (intern ("erase-buffer"), Qdisabled
, Qt
);
5932 /* arch-tag: e48569bf-69a9-4b65-a23b-8e68769436e1
5933 (do not change this comment) */